精华内容
下载资源
问答
  • 1. CK数据集-ck,ck+表情识别 2. cnn文本分类-cnews 注释:百度云链接
  • CNN-人群密度检测-密度图制作-数据集-标注工具等,这里的内容主要是本人在学习过程中在网络上收集所得。也有部分自己的改写。费了半天劲儿整理。绝对物超所值。
  • 凯斯西储大学轴承数据处理+自制CNN数据集

    万次阅读 热门讨论 2019-05-29 11:25:34
    对于凯斯西储大学轴承数据的下载,现在网上随便一个帖子都可以下载到。 在下载数据的时候,发现里面分了正常数据、驱动端、风扇端等类别,然后在具体的某一类,比如驱动端里面又区分了不同类别的故障数据。具体可以...

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

    展开全文
  • CNN分类数据集下载,动物十分类
  • 本篇文章了tensorflow训练自己的数据集实现CNN图像分类,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 资源实现了多种适合MNIST数据集CNN网络,包含自己设计的DenseCNN,著名的LeNet5、AlexNet、ZFNet和VGGNet16。实验结果的可视化包含损失和准确度随迭代次数的变化。模型可下载后直接运行。
  • CNN一般用来做图像数据处理,比较少见用于做普通数据预估。写了3个例子分享给大家参考参考。环境python37
  • 本课程将手把手地教大家使用VIA图像标注工具制作自己的数据集,并使用Mask R-CNN训练自己的数据集,从而能开展自己的图像分割应用。 本课程有三个项目案例实践: (1) balloon实例分割 :对图像中的气球做检测和分割 ...
  • 2、RML2016.10a_dict.pkl:官方数据集,这里传不了我放网盘上,链接: https://pan.baidu.com/s/1ODWI_U72tjT47re6UIftYQ 密码: 0otu; 3、Convolutional Radio Modulation Recognition Networks:网络对应的论文; ...
  • 基于CNN的口罩数据集

    2020-07-06 21:02:47
    基于CNN的笑脸识别,并在此基础上进行口罩识别。(仿照猫狗识别),需要训练模型的数据集,该数据集需要自己进行分类,mask和nomask的。
  • DeepMind Q&A Dataset: CNN/Daily Mail Stories 文本摘要数据集 百度云 https://cs.nyu.edu/~kcho/DMQA/
  • 这次我们并没有给出制作好的数据集,而是只有放在两个不同文件夹内的猫和狗的图片。 我们第一步先用PIL把图片格式统一一下,我们这里将像素改为(150*150)。 import os from PIL import Image base_dir = './...

    数据集地址,这份数据集是猫的图片和狗的图片,是谷歌摘取了一部分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过拟合和泛化的问题。

    展开全文
  • 这个CNN工具箱只用改一两个地方就可以对自己的数据集分类了 比github上的deeplearning的工具箱里的CNN改动要简单
  • 本文实例为大家分享了tensorflow使用CNN分析mnist手写体数字数据集,供大家参考,具体内容如下 import tensorflow as tf import numpy as np import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' from tensorflow....
  • 主要介绍了pytorch + visdom CNN处理自建图片数据集的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 卷积神经网络用到的数据集图片、训练好的权重等参数文件
  • 用于简单的cnn 图像识别,包含数据集
  • CNN对Cifar10进行分类,初始算法准确度为79%; 第二种使用图像加强,精确度可到84%左右; 第三种使用正则化第四种使用双CPU,精确度提升到86%。
  • 基于GTSRB数据集CNN,卷积神经网络交通标志识别
  • cnn-dailymail, 获取 cnn/daily邮件数据集( 非匿名)的代码 这里代码生成 cnn/daily邮件摘要数据集的非匿名版本,如 ACL 2017论文所使用的 指针发生器网络 。 它将数据集处理为代码所期望的二进制格式的二进制格式。...
  • 完整的MNIST CNN手写体识别数据集加代码,深度学习入门好资源!
  • 使用MATLAB对minist手写数据集进行分类,能够达到较高的准确率,可以运行。
  • CNN 数据集预处理

    千次阅读 2018-05-11 00:08:49
    vgg 预处理 训练预处理 测试预处理 inception 预处理 训练预处理 测试预处理 ...看各种模型的 paper 发现,图片预处理是...(与对应模型论文描述的数据预处理有出入) vgg 预处理 输入图片 height, width RESIZ...

    看各种模型的 paper 发现,图片预处理是东一句西一句,有的干脆直接就说参考了前面某某某模型,搞得人晕头转向。下面就 Tensorflow 中对各个模型的预处理实现。(与对应模型论文描述的数据预处理有出入)

    vgg 预处理

    输入图片 height, width

    RESIZE_SIDE_MIN = 256

    RESIZE_SIDE_MAX = 512

    R_MEAN = 123.68G_MEAN = 116.78B_MEAN = 103.94

    训练预处理

    1. scale = width < height ? small_size / width : small_size / height 其中 small_size 为 RESIZE_SIDE_MIN 到 RESIZE_SIDE_MAX 的随机数
    2. new_width = width * scale new_height = height * scale
    3. 用二分插值法将 (height, width) 转为 (new_height, new_width)
    4. 将 new_height, new_width 的图片 crop 为 crop_height(224), crop_width(224) 其中必须满足 new_height >= crop_height, new_width >= crop_width
    5. 将图片左右翻转(50% 的概率会翻转)
    6. RGB 分别减去其平均值,其中依次为 R_MEAN, G_MEAN B_MEAN

    测试预处理

    1. 用二分插值法将 (height, width) 转为 (new_height, new_width) 其中 new_height = new_width = 256
    2. 从 crop 中心的 crop_height, crop_width
    3. 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 预处理

    训练预处理

    1. 对图片进行随机 crop, 使其与 bbox 的重叠部分大于 0.1,长宽比在 (0.75, 1.33) 之间,croped 之后的图片大小为原图的(0.05, 1.0)。
    2. 将 crop 之后的图片大小 resize 为 crop_height(224), crop_width(224)
    3. 将 crop 图片左右翻转(50% 的概率会翻转)
    4. 调整 crop 图片的亮度(32. / 255.)和饱和度(0.5, 1.5)
    5. 每个元素减去 0.5,再乘以 2.0

    测试预处理

    1. central crop
    2. 二分法插值,将图片变为 height, width
    3. 每个元素减去 0.5,再乘以 2.0

    采用上述预处理方法的模型

    • inception
    • inception_v1
    • inception_v2
    • inception_v3
    • inception_v4
    • inception_resnet_v2
    • mobilenet_v1
    • nasnet_mobile
    • nasnet_large
    • pnasnet_large,
    展开全文
  • CNN flower数据集和模型

    2019-04-03 21:11:38
    用于Tensor CNN训练的花的数据集和已经训练好模型的压缩包
  • 制作自己的COCO数据集,训练mask R-CNN

    千次阅读 2019-09-29 11:05:52
    先占个坑,国庆假期的时候来写。 10月16号,终于打开了CSDN,想起了还有一篇没写的博客 本文适合一些小白看,...下面要做的工作是在之前的基础上,还要把肿瘤勾画出来,所以就要用到mask R-CNN了,这时候数据就...

    先占个坑,国庆假期的时候来写。

    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做的,有做相关方向的同学可以一起讨论。

     

     

     

     

     

    展开全文
  • 亲测好用 基于Tensorflow用CNN(卷积神经网络)处理kdd99数据集,代码包括预处理代码和分类代码,准确率99.6%以上,并且快速收敛至最优值。 (Based on Tensorflow (convolutional neural network) processing KDD99...
  • 数据集相对来说较大,所以代码中 并没有完全应用全部数据,只是从中选取了一部分。大家在做的时候可以进行选取,也可以全部应用 但是要处理测试集数据。
  • PyTorch创建的CNN网络,并使用MNIST数据集训练网络,适用于Pytorch新手以及刚接触CNN的朋友

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,624
精华内容 30,649
关键字:

如何制作cnn数据集