对于凯斯西储大学轴承数据的下载，现在网上随便一个帖子都可以下载到。
 在下载数据的时候，发现里面分了正常数据、驱动端、风扇端等类别，然后在具体的某一类，比如驱动端里面又区分了不同类别的故障数据。具体可以参见相关说明，或者参见其他帖子。
 然后下载其中某一个类别的某一个故障数据文件后，文件类型是.mat格式，可以使用MATLAB打开，打开后发现里面又区分了三种类型的数据，
 如上图，这里不太清楚为什么在已经区分了正常、驱动端、风扇端数据类别的情况下，文件里面还要再分成这几类？？？？难道又分了不同位置的故障数据？有点搞不清
 当然，如果需要进行处理这些数据，用来机器学习、CNN的话，并不是需要网站中的所有数据，自然可以只选择我们需要的，比如选择驱动端+0HP的故障数据
 处理数据步骤为：
 ①对于数据的处理，由于轴承信号数据是时间序列的数据，但是在训练使用的时候有些不方便，这里我是把同一类别的数据随机分组，将一维的序列分成二维，具体一组多少数据，看自己分类吧。下载的文件每一个都进行如此操作（可以使用程序在调用数据的时候处理）。
 ②然后将每个类别的数据文件对应建立标签文件。
 ③这样处理之后，每一类故障数据都对应着一个数据文件和一个标签文件，然后将所有类别的数据文件整合到一起组合成训练网络需要的数据集，再将数据集按比例分成训练集和测试集即可。
 以上为使用凯斯西储大学自制数据集的过程，如有错误，还请大佬指点，欢迎交流！！

数据集地址，这份数据集是猫的图片和狗的图片，是谷歌摘取了一部分Kaggle的猫狗分类图片集。这次我们并没有给出制作好的数据集，而是只有放在两个不同文件夹内的猫和狗的图片。
 
我们第一步先用PIL把图片格式统一一下，我们这里将像素改为(150*150)。
 
import os
from PIL import Image

base_dir = './dataset/cats_and_dogs_filtered'
train_dir = os.path.join(base_dir, 'train')
validation_dir = os.path.join(base_dir, 'validation')
train_cats_dir = os.path.join(train_dir, 'cats/')
train_dogs_dir = os.path.join(train_dir, 'dogs/')
validation_cats_dir = os.path.join(validation_dir, 'cats/')
validation_dogs_dir = os.path.join(validation_dir, 'dogs/')
train_cat_fnames = os.listdir(train_cats_dir)
train_dog_fnames = os.listdir(train_dogs_dir)
validation_cat_fnames = os.listdir(validation_cats_dir)
validation_dog_fnames = os.listdir(validation_dogs_dir)
os.mkdir(train_dir + '/resize_cats')
os.mkdir(train_dir + '/resize_dogs')
os.mkdir(validation_dir + '/resize_cats')
os.mkdir(validation_dir + '/resize_dogs')
for i in train_cat_fnames:
    original_img = Image.open(train_cats_dir+i)
    clipping_img = original_img.resize((150, 150), Image.ANTIALIAS)
    clipping_img.save(train_dir+'/resize_cats/'+i)

for i in train_dog_fnames:
    original_img = Image.open(train_dogs_dir + i)
    clipping_img = original_img.resize((150, 150), Image.ANTIALIAS)
    clipping_img.save(train_dir + '/resize_dogs/' + i)

for i in validation_cat_fnames:
    original_img = Image.open(validation_cats_dir + i)
    clipping_img = original_img.resize((150, 150), Image.ANTIALIAS)
    clipping_img.save(validation_dir + '/resize_cats/' + i)

for i in validation_dog_fnames:
    original_img = Image.open(validation_dogs_dir + i)
    clipping_img = original_img.resize((150, 150), Image.ANTIALIAS)
    clipping_img.save(validation_dir + '/resize_dogs/' + i)
 
下一步我们将猫狗图片制作成tfrecords格式的文件。
 
import os
import tensorflow as tf
from PIL import Image


cwd = './dataset/cats_and_dogs_filtered/train/'
classes = ('resize_cats', 'resize_dogs')
writer = tf.python_io.TFRecordWriter('cats_and_dogs_train_onehot.tfrecords')

for index, name in enumerate(classes):
    class_path = cwd + name + '/'
    for img_name in os.listdir(class_path):
        img_path = class_path + img_name
        img = Image.open(img_path)
        img_raw = img.tobytes()
        example = tf.train.Example(features=tf.train.Features(feature={
            'label': tf.train.Feature(int64_list=tf.train.Int64List(value=[1, 0]if index==0 else[0, 1])),
            'img_raw': tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw]))
        }))
        writer.write(example.SerializeToString())

writer.close()
 
这里猫狗是个2分类问题，我们可以选择独热码作为标签，也可以选择用[0]或者[1]来代替猫和狗。
 
如果用[0,1]  [1,0]这种方式来作为猫和狗标签的话，我们可以用softmax作为输出层的activation function这时我们需要用交叉熵来作为loss函数，这种好处是我们可以很轻易的计算准确率。
 
如果用[0] [1]来作为猫和狗标签的话，我们可以用sigmoid 作为输出层的 activation function 这时我们需要用logloss来作为loss函数，这种好处是我们可以很轻易的计算出AUC以及设置lambda阈值(分类阈值)。
 
我这里选择独热码的方式来作为标签，原因是我懒(设置阈值看AUC什么的太麻烦了)。
 
如果你不想用独热码方式，需要把上面的代码这部分:
 
'label': tf.train.Feature(int64_list=tf.train.Int64List(value=[1, 0]if index==0 else[0, 1]))
# 改为
'label': tf.train.Feature(int64_list=tf.train.Int64List(value=[index]))
 
这样猫就是0狗就是1了。
 
对于验证集也是这么制作cwd里的train改成validation就好了。
 
关于tfrecords的读取我们用之前官网给出的代码就好了，这段代码还蛮实用的，就算记不住也希望可以放在一个自己能找到的位置，方便随时调用。
 
 
 
目标:
 
我们这里先搭建一个简单的网络，只有1个卷积层，1个全连接层，1个分类输出层(softmax)。同样我们也需要保存训练结果，方便移植到其他网络。
 
可选练习(这里我不弄了，感兴趣不妨把这些内容加上):
 
动态lr:需要 设置global_step(不可训练变量), 需要用到 
 
tf.train.exponential_decay()
 
 
 
tensorboard可视化:需要 用到
 
tf.summary.scalar()
tf.summary.histogram()
tf.summary.merge_all()
tf.summary.FileWriter()
等
 
 神经网络中对图片的处理可视化:需要matplotlib 
 
不同的train方法:(SGD,Adam等)
 
 
 
这里是训练用的神经网络。
 
import tensorflow as tf


def _parse_function(record):
    """Extracts features and labels.

    Args:
      record: File path to a TFRecord file
    Returns:
      A `tuple` `(labels, features)`:
        features: A dict of tensors representing the features
        labels: A tensor with the corresponding labels.
    """
    features = {
        "label": tf.FixedLenFeature([2], tf.int64),  # terms are strings of varying lengths
        "img_raw": tf.FixedLenFeature([], tf.string)  # labels are 0 or 1
    }

    parsed_features = tf.parse_single_example(record, features)

    img_raw = parsed_features['img_raw']
    img_raw = tf.decode_raw(img_raw, tf.uint8)
    img_raw = tf.reshape(img_raw, [150, 150, 3])
    labels = parsed_features['label']

    return img_raw, labels


def my_input_fn(input_filenames, num_epochs=None, shuffle=True):
    # Same code as above; create a dataset and map features and labels.
    ds = tf.data.TFRecordDataset(input_filenames)
    ds = ds.map(_parse_function)

    if shuffle:
        ds = ds.shuffle(10000)

    # Our feature data is variable-length, so we pad and batch
    # each field of the dataset structure to whatever size is necessary.
    ds = ds.padded_batch(25, ds.output_shapes)

    ds = ds.repeat(num_epochs)

    # Return the next batch of data.
    features, labels = ds.make_one_shot_iterator().get_next()
    return features, labels


def weight_variable(shape):
    initial = tf.truncated_normal(shape, stddev=.1)
    return tf.Variable(initial)


def biases_variable(shape):
    initial = tf.constant(.1, shape=shape)
    return tf.Variable(initial)


def conv2d(x, w):
    return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME')


def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')


def _loss(ys, pred):
    cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys*tf.log(tf.clip_by_value(pred, 1e-10, 1.0)), reduction_indices=[1]))
    return cross_entropy


def train_step(learning_rate, loss):
    optimizer = tf.train.RMSPropOptimizer(learning_rate).minimize(loss)
    return optimizer


def accuracy(pred, ys):
    _bool = tf.equal(tf.argmax(pred, 1), tf.argmax(ys, 1))
    acc = tf.reduce_mean(tf.cast(_bool, tf.float32))
    return acc


train_path = my_input_fn('cats_and_dogs_train_onehot.tfrecords')
xs = train_path[0]
xs = tf.cast(xs, tf.float32)
x_input = xs/255
ys = train_path[1]
y_input = tf.cast(ys, tf.float32)


w_conv1 = weight_variable([3, 3, 3, 6])
b_conv1 = biases_variable([6])
h_conv1 = tf.nn.relu(conv2d(x_input, w_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
h_pool1_flat = tf.reshape(h_pool1, [-1, 75*75*6])
w_fc1 = weight_variable([75*75*6, 10])
b_fc1 = biases_variable([10])
h_fc1 = tf.nn.relu(tf.matmul(h_pool1_flat, w_fc1) + b_fc1)
w_fc2 = weight_variable([10, 2])
b_fc2 = biases_variable([2])
pred = tf.nn.softmax(tf.matmul(h_fc1, w_fc2) + b_fc2)


start_learning_rate = .005
loss = _loss(y_input, pred)
train = train_step(start_learning_rate, loss)
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

saver = tf.train.Saver()

for i in range(1000):
    sess.run(train)
    save_path = saver.save(sess, 'my_net/simple_cnn1.ckpt')
    if i % 50 == 0:
        acc = accuracy(pred, y_input)
        print('accuracy:', sess.run(acc))
 
整个网络训练好后，我们来新建一个网络来看看效果如何。
 
import tensorflow as tf
import numpy as np


def _parse_function(record):
    """Extracts features and labels.

    Args:
      record: File path to a TFRecord file
    Returns:
      A `tuple` `(labels, features)`:
        features: A dict of tensors representing the features
        labels: A tensor with the corresponding labels.
    """
    features = {
        "label": tf.FixedLenFeature([2], tf.int64),  # terms are strings of varying lengths
        "img_raw": tf.FixedLenFeature([], tf.string)  # labels are 0 or 1
    }

    parsed_features = tf.parse_single_example(record, features)

    img_raw = parsed_features['img_raw']
    img_raw = tf.decode_raw(img_raw, tf.uint8)
    img_raw = tf.reshape(img_raw, [150, 150, 3])
    labels = parsed_features['label']

    return img_raw, labels


def my_input_fn(input_filenames, num_epochs=None, shuffle=False):
    # Same code as above; create a dataset and map features and labels.
    ds = tf.data.TFRecordDataset(input_filenames)
    ds = ds.map(_parse_function)

    if shuffle:
        ds = ds.shuffle(10000)

    # Our feature data is variable-length, so we pad and batch
    # each field of the dataset structure to whatever size is necessary.
    ds = ds.padded_batch(25, ds.output_shapes)

    ds = ds.repeat(num_epochs)

    # Return the next batch of data.
    features, labels = ds.make_one_shot_iterator().get_next()
    return features, labels


def weight_variable(shape):
    initial = tf.truncated_normal(shape, stddev=.1)
    return tf.Variable(initial)


def biases_variable(shape):
    initial = tf.constant(.1, shape=shape)
    return tf.Variable(initial)


def conv2d(x, w):
    return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding='SAME')


def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')


def accuracy(pred, ys):
    _bool = tf.equal(tf.argmax(pred, 1), tf.argmax(ys, 1))
    acc = tf.reduce_mean(tf.cast(_bool, tf.float32))
    return acc


train_path = my_input_fn('cats_and_dogs_train_onehot.tfrecords')
xs = train_path[0]
xs = tf.cast(xs, tf.float32)
x_input = xs/255
ys = train_path[1]
y_input = tf.cast(ys, tf.float32)


w_conv1 = weight_variable([3, 3, 3, 6])
b_conv1 = biases_variable([6])
h_conv1 = tf.nn.relu(conv2d(x_input, w_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
h_pool1_flat = tf.reshape(h_pool1, [-1, 75*75*6])
w_fc1 = weight_variable([75*75*6, 10])
b_fc1 = biases_variable([10])
h_fc1 = tf.nn.relu(tf.matmul(h_pool1_flat, w_fc1) + b_fc1)
w_fc2 = weight_variable([10, 2])
b_fc2 = biases_variable([2])
pred = tf.nn.softmax(tf.matmul(h_fc1, w_fc2) + b_fc2)


sess = tf.Session()
saver = tf.train.Saver()
saver.restore(sess, 'my_net/simple_cnn1.ckpt')
lst = []
for i in range(80):
        acc = accuracy(pred, y_input)
        lst.append(sess.run(acc))


print(lst)
print(np.mean(lst))
 
准确率相当不错， 我这里得到的是99.3%。
 
让我们改一下my_input_fn当中的地址，换成验证集的。
 
结果准确率降到了63%。
 
可见我们的CNN网络中存在严重的过拟合，泛化能力极差。
 
 
 
如何解决这个问题呢？ 我们下一篇文章开始讲解cnn过拟合和泛化的问题。

 
 
  

    
vgg 预处理
      
训练预处理
测试预处理
 
inception 预处理
      
训练预处理
测试预处理
 
 
 
 
 
 
 
看各种模型的 paper 发现，图片预处理是东一句西一句，有的干脆直接就说参考了前面某某某模型，搞得人晕头转向。下面就 Tensorflow 中对各个模型的预处理实现。（与对应模型论文描述的数据预处理有出入）
 
vgg 预处理
 
输入图片 height, width
 
RESIZE_SIDE_MIN = 256
 
RESIZE_SIDE_MAX = 512
 
R_MEAN = 123.68G_MEAN = 116.78B_MEAN = 103.94
 
训练预处理
 
scale = width < height ? small_size / width : small_size / height 其中 small_size 为 RESIZE_SIDE_MIN 到 RESIZE_SIDE_MAX 的随机数
new_width = width * scale new_height = height * scale
用二分插值法将 (height, width) 转为 (new_height, new_width)
将 new_height, new_width 的图片 crop 为 crop_height(224), crop_width(224) 其中必须满足 new_height >= crop_height, new_width >= crop_width
将图片左右翻转（50% 的概率会翻转）
RGB 分别减去其平均值，其中依次为 R_MEAN, G_MEAN B_MEAN
 
测试预处理
 
用二分插值法将 (height, width) 转为 (new_height, new_width) 其中 new_height = new_width = 256
从 crop 中心的 crop_height, crop_width
RGB 分别减去其平均值，其中依次为 R_MEAN, G_MEAN B_MEAN
 
采用上述预处理方法的模型
 
resnet_v1_50
resnet_v1_101
resnet_v1_152
resnet_v1_200
resnet_v2_50
resnet_v2_101
resnet_v2_152
resnet_v2_200
vgg
vgg_a
vgg_16
vgg_19
 
inception 预处理
 
训练预处理
 
对图片进行随机 crop, 使其与 bbox 的重叠部分大于 0.1，长宽比在 (0.75, 1.33) 之间，croped 之后的图片大小为原图的(0.05, 1.0)。
将 crop 之后的图片大小 resize 为 crop_height(224), crop_width(224)
将 crop 图片左右翻转（50% 的概率会翻转）
调整 crop 图片的亮度(32. / 255.)和饱和度(0.5, 1.5)
每个元素减去 0.5，再乘以 2.0
 
测试预处理
 
central crop
二分法插值，将图片变为 height, width 
每个元素减去 0.5，再乘以 2.0
 
采用上述预处理方法的模型
 
inception
inception_v1
inception_v2
inception_v3
inception_v4
inception_resnet_v2
mobilenet_v1
nasnet_mobile
nasnet_large
pnasnet_large,

先占个坑，国庆假期的时候来写。
 
10月16号，终于打开了CSDN，想起了还有一篇没写的博客
 
本文适合一些小白看，比较简单，稍微改一下别人的示例代码就行。
 
之前做了点肿瘤检测的工作，就是在图上把肿瘤的位置用边界框标出来，用自己的数据做成了VOC格式，然后训练了faster R-CNN，结果还行。下面要做的工作是在之前的基础上，还要把肿瘤勾画出来，所以就要用到mask R-CNN了，这时候数据就成了问题。用VOC的公开数据集训练mask R-CNN的时候就不太顺利，更不用说训练自己的数据了。于是直接转战COCO格式的数据，毕竟R-CNN一系列的很多模型都是用COCO数据集预训练的。
 
那么问题来了，该怎么制作自己的COCO数据集，看了很多博客，都没看懂，千辛万苦下，终于找到了一个有用的教程！！
 
参考https://patrickwasp.com/create-your-own-coco-style-dataset/
 
可以下载pycococreator-master这个python工具包。
 
这里展示了一个关于形状数据集的例子，是一个三分类的数据集，分别为三角，圆形，正方形。需要准备的就是原图和对应的mask，如图所示： shapes_train2018放的是原图，这里有两张图，annotations存放的就是对应的mask。
 
 
1001.jpeg里面有四个实例，所以它对应的mask就有四幅图。1001.jpeg和对应的mask如下所示：
 
         
 
然后图像的命名也有要求，1001.jpeg的mask的文件名中必须有1001，后面的circle，square就是类别的名字。准备好后，代码会根据你的命名来寻找对应图像的标签文件。
 
准备好自己的数据以及对应的标签后，就要运行工具包中的 shapes_to_coco.py 文件了
 
#!/usr/bin/env python3

import datetime
import json
import os
import re
import fnmatch
from PIL import Image
import numpy as np
from pycococreatortools import pycococreatortools

# 这里设置一些文件路径
ROOT_DIR = 'train' # 根目录
IMAGE_DIR = os.path.join(ROOT_DIR, "shapes_train2018") # 根目录下存放你原图的文件夹
ANNOTATION_DIR = os.path.join(ROOT_DIR, "annotations") # 根目录下存放mask标签的文件夹

# 这里就是填一些有关你数据集的信息
INFO = {
    "description": "Example Dataset",
    "url": "https://github.com/waspinator/pycococreator",
    "version": "0.1.0",
    "year": 2018,
    "contributor": "waspinator",
    "date_created": datetime.datetime.utcnow().isoformat(' ')
}

LICENSES = [
    {
        "id": 1,
        "name": "Attribution-NonCommercial-ShareAlike License",
        "url": "http://creativecommons.org/licenses/by-nc-sa/2.0/"
    }
]

# 这里是你数据集的类别，这里有三个分类，就是square, circle, triangle。制作自己的数据集主要改这里就行了
CATEGORIES = [
    {
        'id': 1,
        'name': 'square',
        'supercategory': 'shape',
    },
    {
        'id': 2,
        'name': 'circle',
        'supercategory': 'shape',
    },
    {
        'id': 3,
        'name': 'triangle',
        'supercategory': 'shape',
    },
]

def filter_for_jpeg(root, files):
    file_types = ['*.jpeg', '*.jpg']
    file_types = r'|'.join([fnmatch.translate(x) for x in file_types])
    files = [os.path.join(root, f) for f in files]
    files = [f for f in files if re.match(file_types, f)]
    
    return files

def filter_for_annotations(root, files, image_filename):
    file_types = ['*.png']
    file_types = r'|'.join([fnmatch.translate(x) for x in file_types])
    basename_no_extension = os.path.splitext(os.path.basename(image_filename))[0]
    file_name_prefix = basename_no_extension + '.*'
    files = [os.path.join(root, f) for f in files]
    files = [f for f in files if re.match(file_types, f)]
    files = [f for f in files if re.match(file_name_prefix, os.path.splitext(os.path.basename(f))[0])]

    return files

def main():

    coco_output = {
        "info": INFO,
        "licenses": LICENSES,
        "categories": CATEGORIES,
        "images": [],
        "annotations": []
    }

    image_id = 1
    segmentation_id = 1
    
    # filter for jpeg images
    for root, _, files in os.walk(IMAGE_DIR):
        image_files = filter_for_jpeg(root, files)

        # go through each image
        for image_filename in image_files:
            image = Image.open(image_filename)
            image_info = pycococreatortools.create_image_info(
                image_id, os.path.basename(image_filename), image.size)
            coco_output["images"].append(image_info)

            # filter for associated png annotations
            for root, _, files in os.walk(ANNOTATION_DIR):
                annotation_files = filter_for_annotations(root, files, image_filename)

                # go through each associated annotation
                for annotation_filename in annotation_files:
                    
                    print(annotation_filename)
                    class_id = [x['id'] for x in CATEGORIES if x['name'] in annotation_filename][0]

                    category_info = {'id': class_id, 'is_crowd': 'crowd' in image_filename}
                    binary_mask = np.asarray(Image.open(annotation_filename)
                        .convert('1')).astype(np.uint8)
                    
                    annotation_info = pycococreatortools.create_annotation_info(
                        segmentation_id, image_id, category_info, binary_mask,
                        image.size, tolerance=2)

                    if annotation_info is not None:
                        coco_output["annotations"].append(annotation_info)

                    segmentation_id = segmentation_id + 1

            image_id = image_id + 1

    with open('{}/instances_shape_train2018.json'.format(ROOT_DIR), 'w') as output_json_file:
        json.dump(coco_output, output_json_file)


if __name__ == "__main__":
    main()
 
最终生成的训练数据的json文件就是上面代码中的instances_shape_train2018.json，制作自己的数据集的时候，可以先准备一个空的.json文件放在那，程序执行完，就能把你的标注信息都写进去了。
 
然后我也展示一下自己的数据吧。文件结构如图：
 
 
训练数据和测试数据都生成了json文件。我的原图是81-1.png，mask文件是81-1tumor.png，因为我的图只有tumor一个类别，并且每一幅图中都只有一个tumor，所以对应的mask文件也只有一个。
 
下面是我的原图和标签图，左边是肺部的图，右边是肿瘤的mask。
 
 
 
看到生成的json文件里这些密密麻麻的坐标有木有很开心！mask R-CNN终于可以训练起来了。
 
另外：我也刚开始用医学图像做目标检测相关的工作，把dcm转成png做的，有做相关方向的同学可以一起讨论。