精华内容
下载资源
问答
  • 作为车辆类型识别的补充数据集,之前的数据集中只出现了一张图片对应一辆车的情况,而对一张图片中出现多辆车的情况未做数据集,是的训练出的模型只能识别大型的车子,而对小型的目标检测不到,该数据集只有100张...
  • 自己整理的车辆类型数据集 一共1500张图片,共分7个类 分别为Bus、Car,SportsCar,MicroBus,Truck,SUV,Jeep,是VOC格式的数据集,用LabelImg工具进行标注,可以转成TFRecord格式的数据集
  • MIT-CBCL Car Database,麻省理工学院提供的车辆分类数据集,可以用来训练分类器,官网数据集下载地址已失效,上传到这里供大家使用。 128 × 128 PPM 格式图像 516个文件 17.8 MB已压缩:24.8 MB未压缩
  • 汽车分类数据集

    2018-04-09 17:19:27
    对奔驰G系列和奔驰c系列进行分类。。。。。。。。。。
  • 用于开发,评估和比较学习方法的数据收集 066c695f141f27ea881df8af5a827c99.jpg 7fe25c5c90c4f447fe3fa10adf4232cd.jpg 6739b35e5a470fdb37862fb2bc5251ef.jpg c1adb1337eba00e584e3704af99d291c.jpg cf042dd7...
  • voc数据集,不同车辆分类数据集; voc数据集,不同车辆分类数据集
  • 行人和车辆分类——数据集分类

    千次阅读 2020-06-09 19:34:21
    车辆的宽高比为2:1。所以人的height为1.6m高,小汽车的尺寸为3.4m宽,1.6m高和宽。 200m处,小汽车像素为72*36 300m处,小汽车像素为48*24 400m处,小汽车像素为36*18 500m处,小汽车像素为28*14 600m处,小...

    考虑因素:没有考虑骑自行车的、两轮摩托车、三轮摩托车的等。这些因素都是要排列组合叠加的,然后这样准备数据。

    • 目的:都是为了让训练出来的模型泛化能力更强,能够应对各种实际情况!

    行人数据集的考虑因素

    1. 距离:200m~1km,体现在像素上就是pixel height
    2. 天气:
      1. 晴天
      2. 阴天
      3. 雨天
      4. 夜晚
    3. 密集行人和遮挡

    车辆数据集的考虑因素:

    1. 距离:200m~1km,体现在像素上就是pixel height
    2. 天气:
      1. 晴天
      2. 阴天
      3. 雨天
      4. 夜晚
    3. 拍摄角度
      1. 正前方
      2. 正后方
      3. 侧前方
      4. 侧后方
    4. 遮挡和拥堵
    5. 车辆类型
      1. 小汽车
      2. 大客车
      3. 火车

    梳理逻辑:

     

    前面有行人的heght与距离的对比,行人宽高比为1:2。而车辆的宽高比为2:1。所以人的height为1.6m高,小汽车的尺寸为3.4m宽,1.6m高和宽。

    • 200m处,小汽车像素为72*36
    • 300m处,小汽车像素为48*24
    • 400m处,小汽车像素为36*18
    • 500m处,小汽车像素为28*14
    • 600m处,小汽车像素为24*12
    • 1200m处,小汽车像素为12*6

     

     
    展开全文
  • 无论是在作分类任务或者是目标检测任务都需要数据集的处理,一种是txt文件保存标签的信息,另一种只有图片如下图的形式,这一步也是学会faster-rcnn的关键点 分为训练和验证的照片 | 每个分类的类别 一种是猫的...
  • 深度学习训练自己的数据集车辆图像识别分类

    万次阅读 多人点赞 2018-12-28 12:35:30
    鉴于有很多人来询问我数据集(我翻箱倒柜找了一下= =放在这里了,有需要自取) 链接:https://pan.baidu.com/s/1Fjgs_MMiIDO9-wFKs6QJSg 提取码:1efk 复制这段内容后打开百度网盘手机App,操作更方便哦 一、...

    鉴于有很多人来询问我数据集(我翻箱倒柜找了一下= =放在这里了,有需要自取)

    链接:https://pan.baidu.com/s/1Fjgs_MMiIDO9-wFKs6QJSg 
    提取码:1efk 
    复制这段内容后打开百度网盘手机App,操作更方便哦

     

    一、实验目的

    考核各位同学使用较小的模型和小规模的训练数据下的模型设计和训练的能力。需要同学充分利用迁移学习等方法,以解决训练数据少的问题,同时需要思考和解决深度学习中过拟合的问题。所提供的场景定义为比较单一的车辆场景,一定程度上平衡了难度系数。

     

    二、实验内容

    使用提供的2000张标注了的车辆场景分类信息的高分辨率图片,建立并训练模型,并将此模型运用于测试数据集的图像分类标注。

    标签信息:

    0,巴士,bus

    1,出租车,taxi

    2,货车,truck

    3,家用轿车,family sedan

    4,面包车,minibus

    5,吉普车,jeep

    6,运动型多功能车,SUV

    7,重型货车,heavy truck

    8,赛车,racing car

    9,消防车,fire engine

    三、实验内容

    1、实验平台:

     WIN10+annaconda+tensorflow

    安装教程:https://blog.csdn.net/qq_30611601/article/details/79067982

    2、实验流程:

    代码利用卷积网络完成一个图像分类的功能。训练完成后,模型保存在model文件中,可直接使用模型进行线上分类。同一个代码包括了训练和测试阶段,通过修改train参数为True和False控制训练和测试。显示实验结果,再根据结果做微小调整。

    数据处理->导入相关库->配置信息->数据读取->定义placeholder(容器)->定义卷积网络(卷积和Pooling部分)->定义全连接部分->定义损失函数和优化器(这里有一个技巧,没有必要给Optimizer传递平均的损失,直接将未平均的损失函数传给Optimizer即可)->定义模型保存器/载入器->进入训练/测试执行阶段

    3、实验代码

    整体代码参考的如下网址:
    https://blog.csdn.net/wills798/article/details/80890990

    需要修改的两点:

    1、由于参考代码训练的是32X32图片,而且图片名字也是标签名+序号,所以我们想要直接用的话,就必须做修改工作

        分为:rename、resize两个步骤

    2、参考代码训练和测试的数据集是同一个,而我们这里有区分,所以要把源代码分为train.py,test.py

    修改图片:

    在项目根目录新建以下空文件夹

    移入源数据(这里的测试集用的是val,用test还要修改代码懒得弄)

    运行renas.py(注意,这里运行一次就可以了,因为运行完,默认将train内源数据删除)

    运行结果:

    代码:

    #coding=utf-8
    from PIL import Image
    import os
    import os.path
    import glob
    
    def rename(rename_path,outer_path,folderlist):
    #列举文件夹
        for folder in folderlist:
            if os.path.basename(folder)=='bus':
                foldnum = 0
            elif os.path.basename(folder)=='taxi':
                foldnum = 1
            elif os.path.basename(folder)=='truck':
                foldnum = 2
            elif os.path.basename(folder)=='family sedan':
                foldnum = 3
            elif os.path.basename(folder)=='minibus':
                foldnum = 4
            elif os.path.basename(folder)=='jeep':
                foldnum = 5
            elif os.path.basename(folder)=='SUV':
                foldnum = 6
            elif os.path.basename(folder)=='heavy truck':
                foldnum = 7
            elif os.path.basename(folder)=='racing car':
                foldnum = 8
            elif os.path.basename(folder)=='fire engine':
                foldnum = 9 	
            inner_path = os.path.join(outer_path, folder) 
            total_num_folder = len(folderlist)       #文件夹的总数
            # print 'total have %d folders' % (total_num_folder)   #打印文件夹的总数
            filelist = os.listdir(inner_path)        #列举图片
            i = 0
            for item in filelist:
                total_num_file = len(filelist)       #单个文件夹内图片的总数
                if item.endswith('.jpg'):
                    src = os.path.join(os.path.abspath(inner_path), item)           #原图的地址
                    dst = os.path.join(os.path.abspath(rename_path), str(foldnum) + '_' + str(i) + '.jpg')        #新图的地址(这里可以把str(folder) + '_' + str(i) + '.jpg'改成你想改的名称)
                try:
                    os.rename(src, dst)
                    # print 'converting %s to %s ...' % (src, dst)
                    i += 1
                except:
                    continue
    #训练集
    rename_path1 = 'E:/Tensorflow-CNN-VehicleIdentification/renametrain'
    outer_path1 = 'E:/Tensorflow-CNN-VehicleIdentification/train'
    folderlist1 = os.listdir(r"E:/Tensorflow-CNN-VehicleIdentification/train")
    rename(rename_path1,outer_path1,folderlist1)
    print("train totally rename ! ! !")
    #测试集
    rename_path2 = 'E:/Tensorflow-CNN-VehicleIdentification/renametest'
    outer_path2 = 'E:/Tensorflow-CNN-VehicleIdentification/val'
    folderlist2 = os.listdir(r"E:/Tensorflow-CNN-VehicleIdentification/val")
    rename(rename_path2,outer_path2,folderlist2)
    print("test totally rename ! ! !")
    
    #修改图片尺寸
    def convertjpg(jpgfile,outdir,width=32,height=32):
        img=Image.open(jpgfile)
        img=img.convert('RGB')
        img.save(os.path.join(outdir,os.path.basename(jpgfile)))
        new_img=img.resize((width,height),Image.BILINEAR)   
        new_img.save(os.path.join(outdir,os.path.basename(jpgfile)))
    #训练集
    for jpgfile in glob.glob("E:/Tensorflow-CNN-VehicleIdentification/renametrain/*.jpg"):
        convertjpg(jpgfile,"E:/Tensorflow-CNN-VehicleIdentification/data")
    print("train totally resize ! ! !")
    #测试集
    for jpgfile in glob.glob("E:/Tensorflow-CNN-VehicleIdentification/renametest/*.jpg"):
        convertjpg(jpgfile,"E:/Tensorflow-CNN-VehicleIdentification/test")
    
    print("test totally resize ! ! !")
    

    修改源代码:

    train.py

    #coding=utf-8
    
    import os
    #图像读取库
    from PIL import Image
    #矩阵运算库
    import numpy as np
    import tensorflow as tf
    
    
    # 数据文件夹
    data_dir = "E:/Tensorflow-CNN-VehicleIdentification/data"
    # 训练还是测试True False
    train = True
    # 模型文件路径
    model_path = "model/image_model"
    
    # 从文件夹读取图片和标签到numpy数组中
    # 标签信息在文件名中,例如1_40.jpg表示该图片的标签为1
    def read_data(data_dir):
        datas = []
        labels = []
        fpaths = []
        for fname in os.listdir(data_dir):
            fpath = os.path.join(data_dir, fname)
            fpaths.append(fpath)
            image = Image.open(fpath)
            data = np.array(image) / 255.0
            label = int(fname.split("_")[0])
            datas.append(data)
            labels.append(label)
    
        datas = np.array(datas)
        labels = np.array(labels)
    
        print("shape of datas: {}\tshape of labels: {}".format(datas.shape, labels.shape))
        return fpaths, datas, labels
    
    
    fpaths, datas, labels = read_data(data_dir)
    
    # 计算有多少类图片
    num_classes = len(set(labels))
    
    
    # 定义Placeholder,存放输入和标签
    datas_placeholder = tf.placeholder(tf.float32, [None, 32, 32, 3])
    labels_placeholder = tf.placeholder(tf.int32, [None])
    
    # 存放DropOut参数的容器,训练时为0.25,测试时为0
    dropout_placeholdr = tf.placeholder(tf.float32)
    
    # 定义卷积层, 20个卷积核, 卷积核大小为5,用Relu激活
    conv0 = tf.layers.conv2d(datas_placeholder, 20, 5, activation=tf.nn.relu)
    # 定义max-pooling层,pooling窗口为2x2,步长为2x2
    pool0 = tf.layers.max_pooling2d(conv0, [2, 2], [2, 2])
    
    # 定义卷积层, 40个卷积核, 卷积核大小为4,用Relu激活
    conv1 = tf.layers.conv2d(pool0, 40, 4, activation=tf.nn.relu)
    # 定义max-pooling层,pooling窗口为2x2,步长为2x2
    pool1 = tf.layers.max_pooling2d(conv1, [2, 2], [2, 2])
    
    
    # 定义卷积层, 60个卷积核, 卷积核大小为3,用Relu激活
    conv2 = tf.layers.conv2d(pool0, 60, 3, activation=tf.nn.relu)
    # 定义max-pooling层,pooling窗口为2x2,步长为2x2
    pool2 = tf.layers.max_pooling2d(conv2, [2, 2], [2, 2])
    
    
    # 将3维特征转换为1维向量
    flatten = tf.layers.flatten(pool2)
    
    # 全连接层,转换为长度为100的特征向量
    fc = tf.layers.dense(flatten, 400, activation=tf.nn.relu)
    
    # 加上DropOut,防止过拟合
    dropout_fc = tf.layers.dropout(fc, dropout_placeholdr)
    
    # 未激活的输出层
    logits = tf.layers.dense(dropout_fc, num_classes)
    
    predicted_labels = tf.arg_max(logits, 1)
    
    
    # 利用交叉熵定义损失
    losses = tf.nn.softmax_cross_entropy_with_logits(
        labels=tf.one_hot(labels_placeholder, num_classes),
        logits=logits
    )
    # 平均损失
    mean_loss = tf.reduce_mean(losses)
    
    # 定义优化器,指定要优化的损失函数
    optimizer = tf.train.AdamOptimizer(learning_rate=1e-2).minimize(losses)
    n=0
    
    # 用于保存和载入模型
    saver = tf.train.Saver()
    
    with tf.Session() as sess:
    
        if train:
            print("训练模式")
            # 如果是训练,初始化参数
            sess.run(tf.global_variables_initializer())
            # 定义输入和Label以填充容器,训练时dropout为0.25
            train_feed_dict = {
                datas_placeholder: datas,
                labels_placeholder: labels,
                dropout_placeholdr: 0.5
            }
            for step in range(150):
                _, mean_loss_val = sess.run([optimizer, mean_loss], feed_dict=train_feed_dict)
    
                if step % 10 == 0:
                    print("step = {}\tmean loss = {}".format(step, mean_loss_val))
            saver.save(sess, model_path)
            print("训练结束,保存模型到{}".format(model_path))
        else:
            print("测试模式")
            # 如果是测试,载入参数
            saver.restore(sess, model_path)
            print("从{}载入模型".format(model_path))
            # label和名称的对照关系
            label_name_dict = {
                0: "巴士",
                1: "出租车",
                2: "货车",
                3: "家用轿车",
                4: "面包车",
                5: "吉普车",
                6: "运动型多功能车",
                7: "重型货车",
                8: "赛车",
                9: "消防车"
            }
            # 定义输入和Label以填充容器,测试时dropout为0
            test_feed_dict = {
                datas_placeholder: datas,
                labels_placeholder: labels,
                dropout_placeholdr: 0
            }
            predicted_labels_val = sess.run(predicted_labels, feed_dict=test_feed_dict)
            # 真实label与模型预测label
            for fpath, real_label, predicted_label in zip(fpaths, labels, predicted_labels_val):
                # 将label id转换为label名
                real_label_name = label_name_dict[real_label]
                predicted_label_name = label_name_dict[predicted_label]
                print("{}\t{} => {}".format(fpath, real_label_name, predicted_label_name))
    
           

    test.py

    #coding=utf-8
    
    import os
    #图像读取库
    from PIL import Image
    #矩阵运算库
    import numpy as np
    import tensorflow as tf
    
    
    # 数据文件夹
    data_dir = "E:/Tensorflow-CNN-VehicleIdentification/test"
    # 训练还是测试True False
    train = False
    # 模型文件路径
    model_path = "model/image_model"
    
    
    # 从文件夹读取图片和标签到numpy数组中
    # 标签信息在文件名中,例如1_40.jpg表示该图片的标签为1
    def read_data(data_dir):
        datas = []
        labels = []
        fpaths = []
        for fname in os.listdir(data_dir):
            fpath = os.path.join(data_dir, fname)
            fpaths.append(fpath)
            image = Image.open(fpath)
            data = np.array(image) / 255.0
            label = int(fname.split("_")[0])
            datas.append(data)
            labels.append(label)
    
        datas = np.array(datas)
        labels = np.array(labels)
    
        print("shape of datas: {}\tshape of labels: {}".format(datas.shape, labels.shape))
        return fpaths, datas, labels
    
    
    fpaths, datas, labels = read_data(data_dir)
    
    # 计算有多少类图片
    num_classes = len(set(labels))
    
    
    # 定义Placeholder,存放输入和标签
    datas_placeholder = tf.placeholder(tf.float32, [None, 32, 32, 3])
    labels_placeholder = tf.placeholder(tf.int32, [None])
    
    # 存放DropOut参数的容器,训练时为0.25,测试时为0
    dropout_placeholdr = tf.placeholder(tf.float32)
    
    # 定义卷积层, 20个卷积核, 卷积核大小为5,用Relu激活
    conv0 = tf.layers.conv2d(datas_placeholder, 20, 5, activation=tf.nn.relu)
    # 定义max-pooling层,pooling窗口为2x2,步长为2x2
    pool0 = tf.layers.max_pooling2d(conv0, [2, 2], [2, 2])
    
    # 定义卷积层, 40个卷积核, 卷积核大小为4,用Relu激活
    conv1 = tf.layers.conv2d(pool0, 40, 4, activation=tf.nn.relu)
    # 定义max-pooling层,pooling窗口为2x2,步长为2x2
    pool1 = tf.layers.max_pooling2d(conv1, [2, 2], [2, 2])
    
    # 定义卷积层, 60个卷积核, 卷积核大小为3,用Relu激活
    conv2 = tf.layers.conv2d(pool0, 60, 3, activation=tf.nn.relu)
    # 定义max-pooling层,pooling窗口为2x2,步长为2x2
    pool2 = tf.layers.max_pooling2d(conv2, [2, 2], [2, 2])
    
    
    # 将3维特征转换为1维向量
    flatten = tf.layers.flatten(pool2)
    
    # 全连接层,转换为长度为100的特征向量
    fc = tf.layers.dense(flatten, 400, activation=tf.nn.relu)
    
    # 加上DropOut,防止过拟合
    dropout_fc = tf.layers.dropout(fc, dropout_placeholdr)
    
    # 未激活的输出层
    logits = tf.layers.dense(dropout_fc, num_classes)
    
    predicted_labels = tf.arg_max(logits, 1)
    
    
    # 利用交叉熵定义损失
    losses = tf.nn.softmax_cross_entropy_with_logits(
        labels=tf.one_hot(labels_placeholder, num_classes),
        logits=logits
    )
    # 平均损失
    mean_loss = tf.reduce_mean(losses)
    
    # 定义优化器,指定要优化的损失函数
    optimizer = tf.train.AdamOptimizer(learning_rate=1e-2).minimize(losses)
    
    # 用于保存和载入模型
    saver = tf.train.Saver()
    
    with tf.Session() as sess:
    
        if train:
            print("训练模式")
            # 如果是训练,初始化参数
            sess.run(tf.global_variables_initializer())
            # 定义输入和Label以填充容器,训练时dropout为0.25
            train_feed_dict = {
                datas_placeholder: datas,
                labels_placeholder: labels,
                dropout_placeholdr: 0.5
            }
            for step in range(150):
                _, mean_loss_val = sess.run([optimizer, mean_loss], feed_dict=train_feed_dict)
    
                if step % 10 == 0:
                    print("step = {}\tmean loss = {}".format(step, mean_loss_val))
            saver.save(sess, model_path)
            print("训练结束,保存模型到{}".format(model_path))
        else:
            print("测试模式")
            # 如果是测试,载入参数
            saver.restore(sess, model_path)
            print("从{}载入模型".format(model_path))
            # label和名称的对照关系
            label_name_dict = {
                0: "巴士",
                1: "出租车",
                2: "货车",
                3: "家用轿车",
                4: "面包车",
                5: "吉普车",
                6: "运动型多功能车",
                7: "重型货车",
                8: "赛车",
                9: "消防车"
            }
            # 定义输入和Label以填充容器,测试时dropout为0
            test_feed_dict = {
                datas_placeholder: datas,
                labels_placeholder: labels,
                dropout_placeholdr: 0
            }
            predicted_labels_val = sess.run(predicted_labels, feed_dict=test_feed_dict)
            # 真实label与模型预测label
            for fpath, real_label, predicted_label in zip(fpaths, labels, predicted_labels_val):
                # 将label id转换为label名
                real_label_name = label_name_dict[real_label]
                predicted_label_name = label_name_dict[predicted_label]
                print("{}\t{} => {}".format(fpath, real_label_name, predicted_label_name))
    
            # 正确次数
            correct_number=0
            # 计算正确率
            for  fpath, real_label, predicted_label in zip(fpaths, labels, predicted_labels_val):
                if real_label==predicted_label:
                    correct_number+=1
    
            correct_rate=correct_number/200
            print('正确率: {:.2%}'.format(correct_rate))
                    
    

    四、实验结果

    dropout=0.25

     

    drop=0.5

     

     

    正确率不高,因为用的模型就是基础的神经网络,想要准确度更好,可以试试RESNET,DENSENET等迁移模型。

    或者直接进pytorch官网https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html有现成的模型可以套

     

    展开全文
  • 内华达大学里诺分校的自主机器人实验室收集并标记了黑暗中车辆分类数据集。 杰克·柯里(Jack Currie),布伦达·潘(Brenda Penn)和达斯蒂·巴恩斯(Dusty Barnes) 1.地面真相 gt10913.txt中的数据按以下方式...
  • 车辆检测数据集

    热门讨论 2013-11-10 17:42:28
    汽车数据,可用来分类学习,和分类识别中,各种视角,各种车型,非常好的一个数据
  • 多标签数据集.zip

    2020-08-14 10:44:35
    这里有两组可用于多标签分类实验的数据集,scene(场景)和emotions(情感),两个都是图片类型的数据集,可直接在MATLAB和python上使用,不需要在进行处理。
  • 车辆重新识别的数据集和论文及代码的集合
  • 这些汽车数据集包含用于组建模型的出色培训和测试集,可以相互区分汽车。 Stanford Cars Dataset_datasets.txt Stanford Cars Dataset01_datasets.zip Stanford Cars Dataset02_datasets.zip Stanford Cars ...
  • 汽车品牌与车辆外形小型数据集ZnCar

    热门讨论 2017-01-21 11:15:15
    一个小型的多标签分类数据集,内含3种品牌,2种汽车外型
  • 文章目录(一)实验任务(二)...手写二维卷积的实现,并在车辆分类数据集上完成分类任务 数据集包含三个文件夹,里面分别是car、bus和truck的车辆图片,需要对数据集进行处理并且划分数据集。 (二)数据处理 数据形式

    (一)实验任务

    手写二维卷积的实现,并在车辆分类数据集上完成分类任务
    数据集包含三个文件夹,里面分别是car、bus和truck的车辆图片,需要对数据集进行处理并且划分数据集。

    (二)数据处理

    数据形式如下
    在这里插入图片描述
    在这里插入图片描述

    1、读取和划分数据集

    使用PIL读取图片。

    import os
    import torch.nn.functional as F
    from PIL import Image
    import matplotlib.pyplot as plt
    import numpy as np
    import torch
    from torch.utils.data import Dataset
    from torchvision import transforms
    import random
    
    
    num_classes = 3  # 分类数量
    batch_size = 256
    num_epochs = 10  # 训练轮次
    lr = 0.02
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
    # 读取并展示图片
    
    file_root = "D:/1MyProjects/python/pytorch_1/实验三数据集/车辆分类数据集"
    classes = ['bus', 'car', 'truck']  # 分别对应0,1,2
    nums = [218, 779, 360]  # 每种类别的个数
    
    def read_data(path):
        file_name = os.listdir(path)  # 获取所有文件的文件名称
        train_data = []
        train_labels = []
        test_data = []
        test_labels = []
        # 每个类别随机抽取20%作为测试集
        train_num = [int(num * 4 / 5) for num in nums]
        test_num = [nums[i] - train_num[i] for i in range(len(nums))]
    
        for idx, f_name in enumerate(file_name):  # 每个类别一个idx,即以idx作为标签
            im_dirs = path + '/' + f_name
            im_path = os.listdir(im_dirs)  # 每个不同类别图像文件夹下所有图像的名称
    
            index = list(range(len(im_path)))
            random.shuffle(index)  # 打乱顺序
            im_path_ = list(np.array(im_path)[index])
            test_path = im_path_[:test_num[idx]]  # 测试数据的路径
            train_path = im_path_[test_num[idx]:]  # 训练数据的路径
    
            for img_name in train_path:
                # 会读到desktop.ini,要去掉
                if img_name == 'desktop.ini':
                    continue
                img = Image.open(im_dirs + '/' + img_name)  # img shape: (120, 85, 3) 高、宽、通道
                # 对图片进行变形
                img = img.resize((32, 32), Image.ANTIALIAS)  # 宽、高
                train_data.append(img)
                train_labels.append(idx)
    
            for img_name in test_path:
                # 会读到desktop.ini,要去掉
                if img_name == 'desktop.ini':
                    continue
                img = Image.open(im_dirs + '/' + img_name)  # img shape: (120, 85, 3) 高、宽、通道
                # 对图片进行变形
                img = img.resize((32, 32), Image.ANTIALIAS)  # 宽、高
                test_data.append(img)
                test_labels.append(idx)
    
        print('训练集大小:', len(train_data), ' 测试集大小:', len(test_data))
    
        return train_data, train_labels, test_data, test_labels
    
    # 一次性读取全部的数据
    train_data, train_labels, test_data, test_labels = read_data(file_root)
    

    2、创建Dataset

    首先需要定义一个Transform操作,将PIL格式的数据转为Tensor并且归一化标准化。

    # 定义一个Transform操作
    transform = transforms.Compose(
        [transforms.ToTensor(),  # 变为tensor
         # 对数据按通道进行标准化,即减去均值,再除以方差, [0-1]->[-1,1]
         transforms.Normalize(mean=[0.4686, 0.4853, 0.5193], std=[0.1720, 0.1863, 0.2175])
         ]
    )
    

    然后自定义Dataset类,每次取出样本都要先经过Transform转为Tensor。

    
    # 自定义Dataset类实现每次取出图片,将PIL转换为Tensor
    class MyDataset(Dataset):
        def __init__(self, data, label, trans):
            self.len = len(data)
            self.data = data
            self.label = label
            self.trans = trans
    
        def __getitem__(self, index):  # 根据索引返回数据和对应的标签
            return self.trans(self.data[index]), self.label[index]
    
        def __len__(self):
            return self.len
    
    
    # 调用自己创建的Dataset
    train_dataset = MyDataset(train_data, train_labels, transform)
    test_dataset = MyDataset(test_data, test_labels, transform)
    
    

    最后生成data_loader

    # 生成data loader
    train_iter = torch.utils.data.DataLoader(
        dataset=train_dataset,
        batch_size=batch_size,
        shuffle=True,
        num_workers=0
    )
    test_iter = torch.utils.data.DataLoader(
        dataset=test_dataset,
        batch_size=batch_size,
        shuffle=False,
        num_workers=0
    )
    

    (三)手写实现二维卷积

    1、卷积操作的实现

    def conv2d(X, K):
        '''
        :param X: 样本输入,shape(batch_size,H,W)
        :param K: 卷积核,shape(k_h,k_w)
        :return: Y 卷积结果,shape(batch_size, H-k_h+1, W-k_w+1)
        '''
        batch_size, H, W = X.shape
        k_h, k_w = K.shape
        # 初始化 Y
        Y = torch.zeros((batch_size, H - k_h + 1, W - k_w + 1)).to(device)
        for i in range(Y.shape[1]):
            for j in range(Y.shape[2]):
                Y[:, i, j] = (X[:, i: i + k_h, j:j + k_w] * K).sum(dim=2).sum(dim=1)
        return Y
    

    2、多通道输入的卷积实现

    def conv2d_multi_in(X, K):
        '''
        :param X: (batch_size, C_in,H,W)代表有C个输入通道
        :param K: (C_in, k_h, k_w)
        :return: (batch_size, H_out, W_out)
        '''
        res = conv2d(X[:, 0, :, :], K[0, :, :])
        for i in range(1, X.shape[1]):  # 多个通道的结果相加
            res += conv2d(X[:, i, :, :], K[i, :, :])
        return res
    

    3、多通道输入输出的卷积实现

    # 实现多输出通道
    # 输出通道数 = 卷积核个数
    def conv2d_multi_in_out(X, K):
        '''
        :param X: (batch_size, C_in,H,W)代表有C个输入通道
        :param K: (K_num, C_in, k_h, k_w) k_num表示卷积核的个数
        :return: (batch_size, K_num, H_out, W_out)
        '''
        return torch.stack([conv2d_multi_in(X, k) for k in K], dim=1)
    

    4、将卷积运算封装成卷积层

    class MyConv2D(torch.nn.Module):
        def __init__(self, in_channels, out_channels, kernel_size):
            super(MyConv2D, self).__init__()
            # 初始化卷积层2个参数:卷积核、偏差
            if isinstance(kernel_size, int):  # 如果kernel size是一个数
                kernel_size = (kernel_size, kernel_size)
            # weight的shape:(卷积核个数/输出通道数,输入通道数,卷积核高,卷积核宽)
            # torch.randn:返回一个符合均值为0,方差为1的正态分布(标准正态分布)中填充随机数的张量
            self.weight = torch.nn.Parameter(torch.randn((out_channels, in_channels) + kernel_size))
            self.bias = torch.nn.Parameter(torch.randn(out_channels, 1, 1))
    
        def forward(self, x):
            '''
            :param x:
            :return:
            '''
            return conv2d_multi_in_out(x, self.weight) + self.bias
    

    5、二维卷积神经网络模型的构建

    class MyConvModule(torch.nn.Module):
        def __init__(self):
            super(MyConvModule, self).__init__()
            # 定义一层卷积
            self.conv = torch.nn.Sequential(
                MyConv2D(in_channels=3, out_channels=32, kernel_size=3),
                torch.nn.BatchNorm2d(32),
                torch.nn.ReLU(inplace=True)  # inplace=True表示计算出来的结果会替换掉原来的Tensor
            )
            # 输出层,将输出通道数变为分类数量
            self.fc = torch.nn.Linear(32, num_classes)
    
        def forward(self, X):
            # 图片经过一层卷积,输出(batch_size,C_out, H, W)
            out = self.conv(X)
            # 使用平均池化层将图片大小变为1*1(图片原大小32*32,卷积后为30*30
            out = F.avg_pool2d(out, 30)
            # 将out从shape batch_size*32*1*1变为batch_size*32
            out = out.squeeze()  # squeeze的用法:
            # 输入到全连接层
            out = self.fc(out)
            return out
    
    
    net = MyConvModule()
    net.to(device)
    # 损失函数和优化器
    loss = torch.nn.CrossEntropyLoss()  # 交叉熵损失函数
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)
    

    (四)模型训练与测试

    1、模型训练

    def train(net, data_loader, device):
        net.train()  # 指定为训练模式
        train_batch_num = len(data_loader)
        total_loss = 0.0
        correct = 0  # 记录共有多少个样本被正确分类
        sample_num = 0
    
        # 遍历每个batch进行训练
        for data, target in data_loader:
            # 将图片和标签放入指定的device中
            data = data.to(device)
            target = target.to(device)
            # 将当前梯度清零
            optimizer.zero_grad()
            # 使用模型计算出结果
            y_hat = net(data)
            # 计算损失
            loss_ = loss(y_hat, target)
            # 进行反向传播
            loss_.backward()
            optimizer.step()
            total_loss += loss_.item()
            cor = (torch.argmax(y_hat, 1) == target).sum().item()
            correct += cor
            # 累加当前的样本总数
            sample_num += target.shape[0]
            print('loss: %.4f  acc: %.4f' % (loss_.item(), cor/target.shape[0]))
        # 平均loss和准确率
        loss_ = total_loss / train_batch_num
        acc = correct / sample_num
        return loss_, acc
    

    2、测试

    # 测试
    def test(net, data_loader, device):
        net.eval()  # 指定当前模式为测试模式(针对BN层和dropout层)
        test_batch_num = len(data_loader)
        total_loss = 0
        correct = 0
        sample_num = 0
        # 指定不进行梯度计算(没有反向传播也会计算梯度,增大GPU开销
        with torch.no_grad():
            for data, target in data_loader:
                data = data.to(device)
                target = target.to(device)
                output = net(data)
                loss_ = loss(output, target)
                total_loss += loss_.item()
                correct += (torch.argmax(output, 1) == target).sum().item()
                sample_num += target.shape[0]
        loss_ = total_loss / test_batch_num
        acc = correct / sample_num
        return loss_, acc
    
    # 模型训练与测试
    train_loss_list = []
    train_acc_list = []
    test_loss_list = []
    test_acc_list = []
    
    
    for epoch in range(num_epochs):
        # 在训练集上训练
        train_loss, train_acc = train(net, data_loader=train_iter, device=device)
        # 测试集上验证
        test_loss, test_acc = test(net, data_loader=test_iter, device=device)
    
        train_loss_list.append(train_loss)
        train_acc_list.append(train_acc)
        test_loss_list.append(test_loss)
        test_acc_list.append(test_acc)
        print('epoch %d, train loss: %.4f, train acc: %.3f' % (epoch+1, train_loss, train_acc))
        print('test loss: %.4f, test acc: %.3f' % (test_loss, test_acc))
    

    3、绘制acc和loss曲线

    # 绘制函数
    def draw_(x, train_Y, test_Y, ylabel):
        plt.plot(x, train_Y, label='train_' + ylabel, linewidth=1.5)
        plt.plot(x, test_Y, label='test_' + ylabel, linewidth=1.5)
        plt.xlabel('epoch')
        plt.ylabel(ylabel)
        plt.legend()  # 加上图例
        plt.show()
    
    
    # 绘制loss曲线
    x = np.linspace(0, len(train_loss_list), len(train_loss_list))
    draw_(x, train_loss_list, test_loss_list, 'loss')
    draw_(x, train_acc_list, test_acc_list, 'accuracy')
    
    

    (五)实验结果

    训练期间输出:

    epoch 8, train loss: 0.9420, train acc: 0.574
    test loss: 1.0830, test acc: 0.574
    loss: 0.9440  acc: 0.5820
    loss: 0.9627  acc: 0.5430
    loss: 0.9615  acc: 0.5703
    loss: 0.9169  acc: 0.6094
    loss: 0.9855  acc: 0.5410
    epoch 9, train loss: 0.9541, train acc: 0.574
    test loss: 1.0850, test acc: 0.574
    loss: 0.9088  acc: 0.6211
    loss: 0.9370  acc: 0.5703
    loss: 0.9487  acc: 0.5781
    loss: 0.9783  acc: 0.5391
    loss: 0.9872  acc: 0.5246
    epoch 10, train loss: 0.9520, train acc: 0.574
    test loss: 1.0850, test acc: 0.574
    

    训练和测试的acc曲线和loss曲线
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 车辆分类检测正样本图片资源,共100张图片,已经按照顺序命名好。如需更多图片,可以留言。
  • 车辆信息检测数据集收集汇总

    万次阅读 多人点赞 2019-09-02 10:25:33
    车辆信息检测数据集收集汇总 目录: UA-DETRAC 车牌数据集 自动驾驶数据集 车辆类型数据集 综合汽车(CompCars)数据集 汽车数据集(检测用) OpenData V11.0-车辆重识别数据集 VRID Stanford Cars ...

    搜集过程中,一些数据集的原始来源可能没找到,以网盘形式存的。如果有人找到一些本文没有标注原始出处的数据集的来源,可以分享一下,便于以后大家在某些场合使用的时候进行引用之类的。

    1.UA-DETRAC

    http://detrac-db.rit.albany.edu/

    在这里插入图片描述
    UA-DETRAC是一个具有挑战性的真实世界多目标检测和多目标跟踪基准。该数据集包括在中国北京和天津的24个不同地点使用Cannon EOS 550D相机拍摄的10小时视频。视频以每秒25帧(fps)的速度录制,分辨率为960×540像素。UA-DETRAC数据集中有超过14万个帧,手动注释了8250个车辆,总共有121万个标记的对象边界框。我们还对目标检测和多目标跟踪中的最新方法以及本网站中详述的评估指标进行基准测试。
    效果图:
    在这里插入图片描述

    2.车牌数据集

    链接:https://pan.baidu.com/s/1MU285jmYISul0owewyZdZw
    提取码:lueb
    如图:
    在这里插入图片描述
    在这里插入图片描述

    3.自动驾驶数据集

    目前它是自动驾驶AI的最大数据集,包含超过100,000个视频,包括一天中不同时间超过1,100小时的驾驶事件以及不同的天气条件。数据集中的带注释图像来自纽约和旧金山地区。包含提供标签的7481张训练集,还有未提供标签的7518张测试集,用于官方评测算法。参考博客

    https://bdd-data.berkeley.edu/

    如图:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    4.车辆类型数据集

    链接:https://pan.baidu.com/s/1fATRXoj2ga_x-RCVOsu74g
    提取码:jmha
    如图:
    在这里插入图片描述
    在这里插入图片描述

    5.综合汽车(CompCars)数据集

    http://mmlab.ie.cuhk.edu.hk/datasets/comp_cars/index.html

    在这里插入图片描述
    描述:综合汽车(CompCars)数据集包含来自两个场景的数据,包括来自网络性质和监视性质的图像。网络自然数据包含163辆汽车,1,716辆车型。共有136,726张图像捕获整个汽车,27,618张图像捕捉汽车零件。完整的汽车图像标有边界框和视点。**每个车型都标有五个属性,包括最大速度,排量,车门数量,座椅数量和汽车类型。**监视性质数据包含在前视图中捕获的50,000个汽车图像。有关详细信息,请参阅我们的论文

    6.汽车数据集(检测用)

    在这里插入图片描述

    http://ai.stanford.edu/~jkrause/cars/car_dataset.html

    7.OpenData V11.0-车辆重识别数据集 VRID

    http://www.openits.cn/opendata4/748.jhtml

    描述:
    开放的车辆重识别的数据来自某城市卡口车辆图像,由326个高清摄像头拍摄,时间覆盖日间14天,分辨率从400×424到990×1134不等。数据集中包含最常见的10种车辆款式,共10000张图像,如表1所列。为了模拟同款车辆对车辆重识别的影响,每个车辆款式里各有100个不同的车辆ID,即100个不同的车辆。在同一车辆款式里的100个车辆ID,它们的外观近乎相同,差异大部分只在于车窗部分的个性化标识,如年检标志等。此外,每个车辆ID包含有10张图像,这10张图像拍摄于不同的道路卡口,光照、尺度以及姿态均不尽相同,相应的同一车辆也可能会具有不同的外观。
    车辆重识别数据集的车辆字段属性如表2所示,其中车辆品牌表示车辆品牌信息,车牌号码用于数据库里同一车辆的关联,车窗位置代表图像里的车窗所在区域的坐标,车身颜色表示的是图像里的车辆颜色信息。这些信息使得数据库不仅能用于车辆重识别研究,也可用于车辆品牌精细识别,车辆颜色识别等研究。
    在这里插入图片描述

    8.Stanford Cars Dataset

    https://www.kaggle.com/jessicali9530/stanford-cars-dataset

    描述:16,185 images and 196 classes of all the cars you’ll ever dream of
    大小:2G
    如图:
    在这里插入图片描述

    9.N-CARS数据集

    https://www.prophesee.ai/dataset-n-cars/

    N-CARS数据集是用于汽车分类的大型真实世界事件数据集。它由12,336辆汽车样品和11,693辆非汽车样品(背景)组成。 使用安装在汽车挡风玻璃后面的ATIS相机记录数据。数据来自各种驾驶课程。该数据集分为7940辆汽车和7482件背景训练样品,4396辆汽车和4211件背景测试样品。每个例子持续100毫秒。

    10.汽车评估数据集

    https://archive.ics.uci.edu/ml/datasets/car+evaluation

    该模型根据以下概念结构评估汽车:

    。汽车可接受性
    。价格总体价格
    。买入价
    。维护的价格
    。TECH技术特点
    。舒适的舒适
    。门门数
    。人员携带能力
    。lug_boot行李箱的大小
    。安全性估计汽车的安全性

    11.更多关于自动驾驶的数据集(50个)

    https://blog.cambridgespark.com/50-free-machine-learning-datasets-self-driving-cars-d37be5a96b28

    12.19个其他与汽车有关的数据集

    https://data.world/datasets/cars

    展开全文
  • 文章目录交通标志、信号灯相关的数据集1. 国内数据集1. Chinese Traffic Sign Database (好像是长沙理工大学的)2. Tsinghua-Tencent 100K Tutorial(信号标志,没有灯的)3. 一个游戏中的交通标志数据集;4. 滴滴...
  • 16个车辆信息检测数据集收集汇总(简介及链接) 转载自:https://blog.csdn.net/u014546828/article/details/109089621?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_baidulandingword-1&spm=1001...
  • 16个车辆信息检测数据集收集汇总 1. UA-DETRAC http://detrac-db.rit.albany.edu/ UA-DETRAC是一个具有挑战性的现实世界多目标检测和多目标跟踪基准。数据集由 Cannon EOS 550D摄像头在中国北京和天津24个不同...
  • KITTI数据集处理

    2018-08-10 19:50:00
    采用python3,对KITTI数据集进行处理,可以修改txt以及相对应的image文件名,可以删除分类KITTI数据集类别,并生产训练以及验证的LMDB数据库。具体操作可参考链接:...
  • 数据集包含使用 Matterport Pro 相机在 90 个属性中捕获的数据。 该存储库包括数据集的原始数据以及派生数据、带注释的数据和用于多个场景理解任务的脚本/模型。 访问主要更新和浏览数据。 纸 如果您使用 Matterport...
  • BIT-Vehicle Dataset - 车辆车型识别数据集 http://iitlab.bit.edu.cn/mcislab/vehicledb/ Dataset info The BIT-Vehicle dataset contains 9,850 vehicle images. There are images with sizes of 1600*1200 and ...
  • MSTAR 10类数据集

    2019-08-13 11:43:18
    MSTAR10类数据集,并且已经将其文件夹分类,形成csv文件。
  • 医疗图像更多的是小样本学习,那么如何选择一个小样本数据集来针对各个算法进行比较,从而选择最好的算法,故整理了小样本学习相关的数据,也就是常用的细粒度分类数据 本文内容主要来自于:...
  • 车辆各个角度图片样本,可直接拿来训练分类器,。全部为正样本,归一化到33*33大小,总共大于4302张。
  • 图像分类数据集

    千次阅读 2019-10-19 12:04:24
    第5章图像分类数据集 不是简单罗列所有的数据集,而是详细讲解了每个数据集的特点,应用场景,发展历史。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,250
精华内容 4,100
关键字:

车辆分类数据集