精华内容
下载资源
问答
  • 手撸神经网络 深度学习环境搭建与简单神经网络实现图片分类 文章目录手撸神经网络 深度学习环境搭建与简单神经网络实现图片分类手撸神经网络 全代码 如下官方安装教程WIN10安装CUDA10CUDA安装成功!WIN10安装...

    大家好,我是cv君 周小夏 从现在开始开启一个动手撸深度学习模块,和大家一起不做调包侠,自己全手撸神经网络,带领大家实现各种任务,解决各种问题,尤其是知道神经网络底层原理,让神经网络更可解释~ 我所有代码会开源到github以及各人公众号 :DeepAI 视界 ,并且我会提交所有的ppt和讲解视频,并且我的视频已上传,与一位朋友合作上传至其他平台。欢迎大家关注公众号,了解更多信息~

    cv君力挺的:最值得看的专栏系列:动手撸深度学习,学习完本系列,你能从调包侠到一个能独立打比赛的朋友周边的神!文章付费,不想让太多人白嫖!!!因为全部原创,珍很贵!!今天给大家来分享一下调参技巧,看完你会感谢我的~

    大家可以通过我的公众号视频详细了解:

    https://mp.weixin.qq.com/s/9HAuQl8MOcfjIBqn8kacvA

    先上ppt截图

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

    在这里插入图片描述

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

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

    手撸神经网络 全代码 如下

    # -*- coding: utf-8 -*-
    # cv君 周小夏
    import argparse
    from tqdm import tqdm
    import torch
    import torchvision
    from torchvision import datasets, transforms
    import numpy as np
    import matplotlib.pyplot as plt
    
    
    class mnist_cls():
        def __init__(self):
            pass
    
        # 1. 加载MNIST手写数字数据集数据和标签
        def load_data(self):
            """
            数据集较小时(小于2W)建议num_works不用管默认就行,因为用了反而比没用慢。
            当数据集较大时建议采用,num_works一般设置为(CPU线程数+-1)为最佳,
            可以用以下代码找出最佳num_works(注意windows用户如果要使用多核多线程
            必须把训练放在if __name__ == '__main__':下才不会报错)
            """
            transform = transforms.Compose([transforms.ToTensor(),
                                            transforms.Normalize((0.5,), (0.5,))])
            trainset = datasets.MNIST(root='./data', train=True,
                                      download=True, transform=transform)
            self.trainsetloader = torch.utils.data.DataLoader(trainset, batch_size=20000, shuffle=True, pin_memory=True)
    
            testset = datasets.MNIST(root='./data', train=True,
                                     download=True, transform=transform)
            self.testsetloader = torch.utils.data.DataLoader(testset, batch_size=20000, shuffle=True, pin_memory=True)
    
        """
        图片可视化
        """
    
        def show_images(self, trainsetloader):
            dataiter = iter(trainsetloader)
            images, labels = dataiter.next()
            plt.imshow(images[0].numpy().squeeze())
            plt.show()
            print(images.shape)
            print(labels.shape)
    
        def define_NN(self):
            # 2. 设计神经网络结构
            first_in, first_out, second_out = 28 * 28, 128, 10
            self.model = torch.nn.Sequential(
                torch.nn.Linear(first_in, first_out),
                torch.nn.ReLU(),
                torch.nn.Linear(first_out, second_out),
            ).to(args.device)
    
            # 3. 定义损失函数
            self.loss_fn = torch.nn.CrossEntropyLoss()
    
            # 4. 设置用于自动调节神经网络参数的优化器
            learning_rate = 1e-4  # 1.5e-4
            self.optimizer = torch.optim.Adam(self.model.parameters(), lr=learning_rate)
            # self.optimizer = torch.optim.SGD(self.model.parameters(), lr=learning_rate)
        # 5. 训练神经网络(10个epochs)
        def train(self):
            self.load_data()
            self.define_NN()
            tq = tqdm(range(args.epochs))
            best = 1000
            for t in tq:
                for i, one_batch in enumerate(self.trainsetloader, 60):
                    data, label = one_batch
                    data = data.to(args.device)
                    label = label.to(args.device)
                    data[0].view(1, 784)  # 将28x28的图片变成784的向量
                    data = data.view(data.shape[0], -1)
    
                    # 让神经网络根据现有的参数,根据当前的输入计算一个输出
                    model_output = self.model(data)
                    # 5.1 用所设计算损失(误差)函数计算误差
                    loss = self.loss_fn(model_output, label)
                    tq.set_description("Loss %.4f" % float(loss.item()))
                    tq.set_postfix({"Best_loss": best})
                    tq.update(1)
                    # if i% 500 == 0:
                    #     print('loss:', loss)
                    # 5.2 每次训练前清零之前计算的梯度(导数)
                    self.optimizer.zero_grad()
                    # 5.3 根据误差反向传播计算误差对各个权重的导数
                    loss.backward()
                    # 5.4 根据优化器里面的算法自动调整神经网络权重
                    self.optimizer.step()
    
                    # 保存下训练好的模型,省得下次再重新训练
                    if loss <= best:
                        best = loss.item()
                        torch.save(self.model.state_dict(), args.weights)
                        print('Best model saved! Epoch:', t)
    
        def detect(self):
            self.load_data()
            self.define_NN()
            self.model.load_state_dict(torch.load(args.weights))
    
            # 6. 用这个神经网络解决你的问题,比如手写数字识别,输入一个图片矩阵,然后模型返回一个数字
            testdataiter = iter(self.testsetloader)
            testimages, testlabels = testdataiter.next()
            plt.imshow(testimages[0].numpy().squeeze())
            plt.show()
            testimages = testimages.to(args.device)
            testlabels = testlabels.to(args.device)
            img_vector = testimages[0].squeeze().view(1, -1)
            # 模型返回的是一个1x10的矩阵,第几个元素值最大那就是表示模型认为当前图片是数字几
            result_digit = self.model(img_vector)
            print("该手写数字图片识别结果为:", result_digit.max(1)[1].item(), "标注的标签为:", testlabels[0].item())
    
    
    if __name__ == '__main__':
        parser = argparse.ArgumentParser()
        parser.add_argument('--epochs', default=300, help='training epochs')
        parser.add_argument('--method', default='test', help='train to run, test or val')
        parser.add_argument('--weights', default='./my_handwrite_recognize_model.pt', help='save the weight')
        parser.add_argument('--device',  default='cuda', help='cuda or cpu')
        args = parser.parse_args()
        mnist = mnist_cls()
        if 'test' in args.method:
            mnist.detect()
        elif 'train' in args.method:
            mnist.train()
        else:
            print('please check the argparse!')
    
    

    主要是使用的两层全连接,直接就能得到不错的准确率~ 我们目的是走一套简单完整的应用,实测可用,欢迎大家关注~

    数据会自动下载,如果觉得下载过慢,欢迎关注我的公众号下载:公众号回复:手撸神经网络 获取哦~

    另外附带一下详细的ppt介绍的内容~

    官方安装教程

    CUDA:https://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html
    cuDNN:https://docs.nvidia.com/deeplearning/sdk/cudnn-install/index.html#installwindows

    WIN10安装CUDA10

    CUDA Toolkit 10.0 Download:https://developer.nvidia.com/cuda-downloads
    按图下载
    按图下载。(可以离线安装[local],也可在线下载安装[network])。

    下载完成后,打开安装程序:
    安装路径可以默认也可以自定义。之后点击ok就行。
    img

    等待。。。。。。
    在这里插入图片描述
    继续等待。。。。。。
    在这里插入图片描述

    点击同意并继续
    在这里插入图片描述
    如果不知道怎么选,就选择精简安装。
    在这里插入图片描述
    我也不知道按那个,so 我全部安装??

    可以选择默认路径或者自定义安装路径,记下安装的路径。
    在这里插入图片描述

    最终“下一步”,然后“完成”就行。
    配置系统环境变量,选择path:
    如图:
    在这里插入图片描述

    检查是否有下图中的两个环境变量
    在这里插入图片描述
    验证安装:nvcc -V
    在这里插入图片描述

    CUDA安装成功!

    WIN10安装cuDNN

    cuDNN Download:https://developer.nvidia.com/rdp/cudnn-download
    (进入网页下载当然要注册账号,如果有就不用了)

    注意要打勾才显示下载列表,按照自己的需要下载安装:
    在这里插入图片描述
    下载后,将下载文件解压,然后 copy------》past
    按照自己的情况来,图中是我的解压和安装路径:(注意是路径中的文件)
    在这里插入图片描述
    添加环境变量:C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\lib\x64
    在这里插入图片描述

    cuDNN安装完成!!

    输入nvcc -V 测试即可

    其他内容请看视频~

    再上一张测试集:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NaIGQfQO-1611899164428)(D:\CSDN\pic_new\ai\1611898507185.png)]在这里插入图片描述

    老规矩了关注我的公众号,一起进入AI知识星球吧

    展开全文
  • CNN图片分类

    万次阅读 2018-08-21 17:03:53
    最近在阅读一些AI项目,写入markdown,持续更新,算是之后也能回想起...image classify(图片分类) CNN classify dogs and cats(猫狗二分类) Tutorial(教程):https://developers.google.com/machine-learning/pra...

    最近在阅读一些AI项目,写入markdown,持续更新,算是之后也能回想起做法

    项目 https://github.com/calssion/Fun_AI

    image classify(图片分类)

    CNN classify dogs and cats(猫狗二分类)

    Tutorial(教程):https://developers.google.com/machine-learning/practica/image-classification

    the training samples are just only two kinds:dog and cat(训练集只有两种图片:猫和狗)
    image

    1、basic CNN model with tensorflow.keras(简单的CNN模型)

    img_input = layers.Input(shape=(150, 150, 3))
    x = layers.Conv2D(16, 3,activation='relu')(img_input)
    x = layers.MaxPooling2D(2)(x)
    x = layers.Conv2D(32, 3, activation='relu')(x)
    x = layers.MaxPooling2D(2)(x)
    x = layers.Conv2D(64, 3, activation='relu')(x)
    x = layers.MaxPooling2D(2)(x)
    x = layers.Flatten()(x)
    x = layers.Dense(512, activation='relu')(x)
    output = layers.Dense(1, activation='sigmoid')(x)
    model = Model(img_input, output)

    the network architecture(网络结构)
    image

    using RMSprop for optimization algorithm(优化算法采用RMSprop),
    and there also use Data Augmentation(也用到数据增强),
    cause the training samples are not enough and it can help the network learn better(训练数据不足且有助于网络学得更好)。

    from tensorflow.keras.preprocessing.image import ImageDataGenerator

    Visualizing Intermediate Representations of erery layer of the CNN(可视化中间过程)
    image

    2、Reducing Overfitting(减缓过拟合)

    Data Augmentation(数据增强)

    datagen = ImageDataGenerator(
      rotation_range=40,
      width_shift_range=0.2,
      height_shift_range=0.2,
      shear_range=0.2,
      zoom_range=0.2,
      horizontal_flip=True,
      fill_mode='nearest')

    Adding Dropout(使用dropout)

    x = layers.Dropout(0.5)(x)

    3、Feature Extraction and Fine-Tuning(迁移学习和微调)

    use the Inception V3 model developed at Google(使用Inception V3模型),
    and pre-trained on ImageNet(已经预训练好的ImageNet)。

    from tensorflow.keras.applications.inception_v3 import InceptionV3
    local_weights_file ='/tmp/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5'
    pre_trained_model = InceptionV3( input_shape=(150, 150, 3), include_top=False, weights=None)
    pre_trained_model.load_weights(local_weights_file)

    won't update the weights of the pretrained model during training(固定前面网络层的参数(权值))

    for layer in pre_trained_model.layers:
      layer.trainable = False

    let's stick a fully connected classifier on top of last_output(添加属于自己的网络层用于输出)

    last_output = pre_trained_model.get_layer('mixed7').output
    x = layers.Flatten()(last_output)
    x = layers.Dense(1024, activation='relu')(x)
    x = layers.Dropout(0.2)(x)
    x = layers.Dense(1, activation='sigmoid')(x)
    model = Model(pre_trained_model.input, x)

    All we need to do to implement fine-tuning is to set the top layers of Inception V3 to be trainable, recompile the model (necessary for these changes to take effect), and resume training. Let's unfreeze all layers belonging to the mixed7 module—i.e., all layers found after mixed6—and recompile the model:(迁移学习的网络开放前面更多网络层进行训练,更好地拟合数据)

    for layer in pre_trained_model.layers:
      if unfreeze:
        layer.trainable = True
      if layer.name == 'mixed6':
        unfreeze = True

    finished!!!

    展开全文
  • 用yolov3进行图片分类

    千次阅读 2019-10-12 18:55:43
    使用yoloV3进行图片分类:一个待处理的Images文件夹,里面包含要处理的图片;一个目标文件personFile,我这里需要提取含有行人的图片;一个非目标的文件noPersonFile。实际功能是从Images一张一张的读取,使用yolo...

            使用yoloV3进行图片分类:一个待处理的Images文件夹,里面包含要处理的图片;一个目标文件personFile,我这里需要提取含有行人的图片;一个非目标的文件noPersonFile。实际功能是从Images一张一张的读取,使用yolo返回的结果查看该图片是否包含行人,有则把它写入personFile文件中,否则写入noPersonFile文件中,同时将该图片从Images删除(处理的图片有点多,怕突然中断又要重头开始)。

            运行该程序需要确保Images文件夹在当前工作目录,同时需要把yolomain.py拷贝到当前工作目录。

    yolomain.py

    # -*- coding: utf-8 -*-
    # Author:       weiz
    # Date:         2019/9/16 17:00
    # Name:         test_yolo
    # Description:  YOLOv3目标检测的代码,提供检测的接口;也可以单独运行
    import cv2
    import numpy as np
    
    class Yolo:
        def __init__(self, cfgPath, weightPath, labelNamesPath):
            self.cfgPath = cfgPath
            self.weightPath = weightPath
            self.labelNames = labelNamesPath
            self.yoloNet = cv2.dnn.readNet(self.cfgPath, self.weightPath)
            self.LABELS = open(labelNamesPath).read().strip().split("\n")
            self.nClass = len(self.LABELS)
            self.COLORS = np.random.randint(0, 255, size=(self.nClass, 3), dtype='uint8')
    
        def detect(self, img, confidThr=0.5, nmsThr=0.3, isDraw=False):
            (h, w) = img.shape[:2]
    
            # 获取YOLO输出层的名字
            ln = self.yoloNet.getLayerNames()
            ln = [ln[i[0] - 1] for i in self.yoloNet.getUnconnectedOutLayers()]
    
            # 将图片构建成一个blob,设置图片尺寸,然后执行一次
            # YOLO前馈网络计算,最终获取边界框和相应概率
            blob = cv2.dnn.blobFromImage(img, 1 / 255.0, (416, 416), swapRB=True, crop=False)
            self.yoloNet.setInput(blob)
            layerOutputs = self.yoloNet.forward(ln)
    
            # 初始化边界框,置信度(概率)以及类别
            boxes = []
            confidences = []
            classIDs = []
    
            # 迭代每个输出层,总共三个
            for output in layerOutputs:
                # 迭代每个检测
                for detection in output:
                    # 提取类别ID和置信度
                    scores = detection[5:]
                    classID = np.argmax(scores)
                    confidence = scores[classID]
    
                    # 只保留置信度大于某值的边界框
                    if confidence > confidThr:
                        # 将边界框的坐标还原至与原图片相匹配,记住YOLO返回的是
                        # 边界框的中心坐标以及边界框的宽度和高度
                        box = detection[0:4] * np.array([w, h, w, h])
                        (centerX, centerY, width, height) = box.astype("int")
    
                        # 计算边界框的左上角位置
                        x = int(centerX - (width / 2))
                        y = int(centerY - (height / 2))
    
                        # 更新边界框,置信度(概率)以及类别
                        boxes.append([x, y, int(width), int(height)])
                        confidences.append(float(confidence))
                        classIDs.append(classID)
    
            # 使用非极大值抑制方法抑制弱、重叠边界框
            idxs = cv2.dnn.NMSBoxes(boxes, confidences, confidThr, nmsThr)
            lab = []
            loc = []
            # 确保至少一个边界框
            if len(idxs) > 0:
                # 迭代每个边界框
                for i in idxs.flatten():
                    # 提取边界框的坐标
                    (x, y) = (boxes[i][0], boxes[i][1])
                    (w, h) = (boxes[i][2], boxes[i][3])
    
                    # 绘制边界框以及在左上角添加类别标签和置信度
                    text = '{}: {:.3f}'.format(self.LABELS[classIDs[i]], confidences[i])
                    if isDraw:
                        color = [int(c) for c in self.COLORS[classIDs[i]]]
                        cv2.rectangle(img, (x, y), (x + w, y + h), color, 2)
                        (text_w, text_h), baseline = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 2)
                        cv2.rectangle(img, (x, y - text_h - baseline), (x + text_w, y), color, -1)
                        cv2.putText(img, text, (x, y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 2)
    
                    text_inf = text + ' ' + '(' + str(x) + ',' + str(y) + ')' + ' ' + '宽:' + str(w) + '高:' + str(h)
                    loc.append([x, y, w, h])
                    #lab.append(text_inf)
                    lab.append(self.LABELS[classIDs[i]])
    
            return lab, img, loc
    
    
    labelPath = './cfg/coco.names'
    cfgPath = './cfg/yolov3_coco.cfg'
    weightPath = './cfg/yolov3.weights'
    yolo = Yolo(cfgPath, weightPath, labelPath)
    
    if __name__ == '__main__':
        cap = cv2.VideoCapture("./004.avi")
        while True:
            ret, img = cap.read()
            if ret is False:
                exit()
            lab, retImg, loc = yolo.detect(img, isDraw=True)
            cv2.imshow('video', retImg)
    
            if cv2.waitKey(1) & 0xFF == 27:
                cap.release()  # 关闭摄像头
                cv2.destroyAllWindows()
                break

    yolo接口代码,分类代码如下:

    # -*- coding: utf-8 -*-#
    # Author:       weiz
    # Date:         2019/10/12 14:18
    # Name:         detectImageIsPerson
    # Description:
    
    import os
    import sys
    import cv2 as cv
    import yolomain
    import copy
    
    def checkFileExist(fileName, isCreate=None):
        """
        检测当前工作目录下fileName文件是否存在,并根据isCreate是否创建
        :param fileName:文件夹名字
        :param isCreate:是否创建
        :return:不存在返回false,存在或者创建返回true
        """
        if isCreate == True:
            isCreate = True
        else:
            isCreate = False
        if os.path.exists(fileName):
            return True
        else:
            if isCreate:
                os.makedirs(fileName)
                return True
            else:
                return False
    
    if __name__ == '__main__':
        workSpace = os.getcwd()
        imagesFile = "Images"
        personFile = "personFile"
        noPersonFile = "noPersonFile"
    
        print("The workspace:{}".format(workSpace))
        print(checkFileExist(imagesFile))
        print(checkFileExist(personFile, True))
        print(checkFileExist(noPersonFile, True))
    
        imagesPath = os.path.join(workSpace, imagesFile)
        print("Reading pictures from {}".format(imagesPath))
        personPath = os.path.join(workSpace, personFile)
        noPersonPath = os.path.join(workSpace, noPersonFile)
        imagelist = os.listdir(imagesPath)
        if imagelist == []:
            print("The {} is not contain images".format(imagesPath))
            sys.exit(0)
    
        # 检测图片中是否存在person
        frame = 1
        for imgName in imagelist:
            print("Processing the {}th frame......".format(frame))
    
            imgPath = os.path.join(imagesPath, imgName)
            imgPath = os.path.abspath(imgPath)
    
            # 读取图片
            img = cv.imread(imgPath)
            retImg = copy.deepcopy(img)
            e1 = cv.getTickCount()
            _, _, out_classes = yolomain.yolo_ser(retImg)
            e2 = cv.getTickCount()
            time = (e2 - e1) / cv.getTickFrequency()
    
            # 写入图片
            personName = os.path.join(personPath, imgName)
            personName = os.path.abspath(personName)
            noPersonName = os.path.join(noPersonPath, imgName)
            noPersonName = os.path.abspath(noPersonName)
            isPerson = False
            for objectClass in out_classes:
                if objectClass == 'person':
                    isPerson = True
                    cv.imwrite(personName, img)
                    os.remove(imgPath)
                    break
            if not isPerson:
                cv.imwrite(noPersonName, img)
                os.remove(imgPath)
    
            print("It took {:.2f} seconds to complete the {}th frame picture.".format(time, frame))
            frame = frame + 1

    20201012-------更新

    更加完善的过滤,下面包含图片或视频数据的筛选:

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # @Time        :2020/10/10 10:30
    # @Author      :weiz
    # @ProjectName :pycharmProject
    # @File        :Personfilter.py
    import os
    import cv2
    import yolomain
    import copy
    
    
    def checkFileExist(fileName, isCreate=None):
        """
        检测当前工作目录下fileName文件是否存在,并根据isCreate是否创建
        :param fileName:文件夹名字
        :param isCreate:是否创建
        :return:不存在返回false,存在或者创建返回true
        """
        if isCreate == True:
            isCreate = True
        else:
            isCreate = False
        if os.path.exists(fileName):
            return True
        else:
            if isCreate:
                os.makedirs(fileName)
                return True
            else:
                print("the [{}] folder does not exist".format(fileName))
                return False
    
    
    
    def videosFilter(videosPath, gap, savePath, filterGarget):
        """
        分离视频中含有目标的图片
        :param videoPath:视频路径,只能处理一级图片
        :param gap:每隔多少帧才处理
        :param savePath:保存路径
        :param filterGarget:分离的目标类别
        :return:
        """
        checkFileExist(savePath, True)
    
        videoLists = os.listdir(videosPath)
        for videoName in videoLists:
            videoPath = os.path.join(videosPath, videoName)
            videoNamePrefix = videoName.split('.')[0]
            saveVideoPath = os.path.join(savePath, videoNamePrefix)
            checkFileExist(saveVideoPath, True)
            print(videoPath)
            cap = cv2.VideoCapture(videoPath)
            ret = True
            frames = 0
            while ret:
                ret, img = cap.read()
                saveImg = copy.deepcopy(img)
                labs = []
                if frames % gap == 0:
                    labs, _, _ = yolomain.yolo.detect(img, isDraw=True)
                else:
                    frames = frames + 1
                    continue
                for label in labs:
                    if label == filterGarget:
                        imgName = videoNamePrefix + '_' + "{:0>6d}".format(frames) + ".png"
                        imgName = os.path.join(saveVideoPath, imgName)
                        print(imgName)
                        cv2.imwrite(imgName, saveImg)
                    break
                cv2.imshow('video', img)
                #cv2.imshow("saveImg", saveImg)
    
                if cv2.waitKey(1) & 0xFF == 27:
                    cap.release()  # 关闭摄像头
                    cv2.destroyAllWindows()
                    break
                print(frames)
                frames = frames + 1
        cv2.destroyAllWindows()
    
    
    def imagesFilter(imagesFilePath, savePath, filterGarget):
        """
        分离图片中含有目标的图片
        :param imagesFilePath:
        :param savePath:
        :param filterGarget:
        :return:
        """
        workSpace = os.getcwd()
        if not checkFileExist(imagesFilePath):
            exit()
    
        checkFileExist(savePath, True)
        print("The workspace:{}".format(workSpace))
        print("Reading pictures from {}".format(imagesFilePath))
    
        targetFile = filterGarget + "File"
        nontargetFile = "no" + filterGarget + "File"
        targetFilePath = os.path.join(savePath, targetFile)
        nontargetFilePath = os.path.join(savePath, nontargetFile)
        checkFileExist(targetFilePath, True)
        checkFileExist(nontargetFilePath, True)
    
        fileLists = os.listdir(imagesFilePath)
        # print(fileLists)
        for fileList in fileLists:
            fileListPath = os.path.join(imagesFilePath, fileList)
    
            if os.path.isfile(fileListPath):  # 处理第一级的图片
                img = cv2.imread(fileListPath)
                e1 = cv2.getTickCount()
                lab, img, loc = yolomain.yolo.detect(img)
                e2 = cv2.getTickCount()
                time = (e2 - e1) / cv2.getTickFrequency()
                targetSaveName = os.path.join(targetFilePath, fileList)
                nontargetSaveName = os.path.join(nontargetFilePath, fileList)
                isPerson = False
                for objectClass in lab:
                    if objectClass == filterGarget:
                        isPerson = True
                        cv2.imwrite(targetSaveName, img)
                        break
                if not isPerson:
                    cv2.imwrite(nontargetSaveName, img)
                os.remove(fileListPath)
            else:  # 处理第二级的图片
                imgsNames = os.listdir(fileListPath)
                # print(imgsNames)
                targetFilePath_sub = os.path.join(targetFilePath, fileList)
                nontargetFilePath_sub = os.path.join(nontargetFilePath, fileList)
                checkFileExist(targetFilePath_sub, True)
                checkFileExist(nontargetFilePath_sub, True)
                for imgName in imgsNames:
                    imgNamePath = os.path.join(fileListPath, imgName)
                    # print(imgNamePath)
                    img = cv2.imread(imgNamePath)
                    e1 = cv2.getTickCount()
                    lab, img, loc = yolomain.yolo.detect(img)
                    e2 = cv2.getTickCount()
                    time = (e2 - e1) / cv2.getTickFrequency()
                    targetSaveName = os.path.join(targetFilePath_sub, imgName)
                    nontargetSaveName = os.path.join(nontargetFilePath_sub, imgName)
                    isPerson = False
                    for objectClass in lab:
                        if objectClass == filterGarget:
                            isPerson = True
                            cv2.imwrite(targetSaveName, img)
                            break
                    if not isPerson:
                        cv2.imwrite(nontargetSaveName, img)
                    os.remove(imgNamePath)
                print("The [{}] folder has been processed!".format(fileListPath))
    
    
    videosFilePath = "./videos"    # 视频文件夹,处理如下文件格式:
    #  ./videos
    #        001.avi
    #        002.avi
    imagesFilePath = "./images1"   # 图片文件夹,只能处理两级文件如下所示:
    #  ./images
    #        /001
    #            001.png
    #        000.png
    savePath = "./ret"
    filterGarget = "person"
    
    if __name__ == '__main__':
        videosFilter(videosFilePath, 11, savePath, filterGarget)
    
        #imagesFilter(imagesFilePath, savePath, filterGarget)

     

    展开全文
  • 图片分类-python

    千次阅读 热门讨论 2018-06-02 17:22:07
    目的:做一个简易的图片分类。 使用到的算法:hog、surf+svm 图片集:cifar-10、cifar-100、stl-10、自制图片集 分类完整代码链接 使用说明: 1.cifar-10、cifar-100和stl-10直接解压 2.自制图片集文件夹结构...

    目的:做一个简易的图片分类。
    使用到的算法:hog、surf+svm
    图片集cifar-10、cifar-100stl-10、自制图片集
    这里写图片描述
    分类完整代码链接

    使用说明
    1.cifar-10、cifar-100和stl-10直接解压
    2.自制图片集文件夹结构:
    ├─homemade
    │ ├─标签1
    │ ├─标签2
    │ ├─标签3
    │ ├─标签4
    │ ├─标签5
    │ └─标签6
    每个“标签N”里面是存储的属于该标签的图片,图片名为“标签名+数字”
    自制图片全是百度爬取自己筛选的
    3.依赖库
    文件说明
    categoriesGUI.py:gui界面
    categoriesGUI.spec:用于Pyinstaller生成exe
    config.py:读取配置参数
    modelTrain.py:模型训练
    picCategories.py:图片集分类,利用的是modelTrain.py训练保存的模型
    config/config.cfg:配置参数,部分参数和python中算法的参数相对应

    结果总结
    1.hog是利用梯度变换提取特征,并且缺少旋转和尺度不变性。
    2.surf是SIFT角点检测算法的改进版,速度提升比较大。
    3.相同图片集,对比hog+LinearSVC和surf+LinearSVC,hog效果要好一些(这里不知道为什么)
    4.不同图片集,各类别中的图片数量越多,hog识别效果越好
    5.还可以优化部分分别是:
    a.surf读取图片改为读取每一张图片就进行surf特征提取,在释放掉图片内存,这样可以减小内存。
    b.模型训练采取的是LinearSVC,采取其他的效果应该要好些。
    c.在surf+LinearSVC中使用的是MiniBatchKMeans,速度比kmeans快,效果差距不大
    d.自己调参数,这里可以提高一些识别率。
    6.surf由于提取特征大小不同,所以采用了词袋的方法。

    展开全文
  • 迁移学习CNN图像分类模型 - 花朵图片分类

    万次阅读 多人点赞 2018-01-31 19:30:24
    为了能够快速地训练好自己的花朵图片分类器,我们可以使用别人已经训练好的模型参数,在此基础之上训练我们的模型。这个便属于迁移学习。本文提供训练数据集和代码下载。 原理:卷积神经网络模型总体上可以分为...
  • 使用PyTorch对cifar-10图片分类

    千次阅读 2018-03-25 17:36:52
    使用PyTorch对cifar-10图片分类 前言 最近刚学习了PyTorch,主要是在PyTorch主页教程里面学习。不过这个教程是英文的,学习起来比较费劲。 因此我自己对PyTorch对cifar-10图片分类这一部分进行了总结,因为光对着...
  • ImageNet-ResNet_50 图片分类平台

    千次阅读 2018-08-15 14:00:53
    最近公司要在AI领域发力,基于此,研究了Resnet50的图片分类,网络上有很多的例子,但是都没有做成平台化,提供一个组件一样供各个业务平台使用,基于此,在Resnet50的基础上,扩展了登陆,图片类别添加,上传图片,...
  • AI challenger 2018图片分类比赛—农作物病害检测

    万次阅读 多人点赞 2018-12-16 15:21:13
    我使用的是Keras,以TensorFlow为后端,手动实现了DenseNet用于图片分类 由于Kaggle现在可以免费使用GPU,所以采用将数据上传至Kaggle的私人Dataset上,在其上创建Kernel进行模型训练 (上传需要翻墙,有梯子最好...
  • 11.CNN实现真实猫狗图片分类

    千次阅读 2020-12-04 09:56:39
    CNN实现真实猫狗图片分类 个人认为,和上一节的mnist数据集里面的手写数字图片不同之处就是,真实的图片更加复杂,像素点更多。因此在对应的图片预处理方面会稍微麻烦一些。但是这个例子能让我们可以处理自己遇到的...
  • tensorflow_二分类之多张图片分类

    千次阅读 2018-05-15 10:25:05
    在单张图片分类的基础上文章进一步研究多张图片的分类:1)新建predictmultipy.py,输入以下内容import tensorflow as tfimport numpy as npimport os,glob,cv2import sys,argparsefrom utils.copy import get_file_...
  • 本篇博文主要讲解来自2014年ICLR的经典图片分类、定位物体检测overfeat算法:《OverFeat: Integrated Recognition, Localization and Detection using Convolutional Networks》,至今为止这篇paper,已然被引用了几...
  • 使用卷积神经网络进行图片分类 4

    千次阅读 2017-06-20 09:47:17
    利用训练好的模型开发图片分类程序 一、实验介绍 1.1 实验内容 在snapshot目录下已经有我们训练好的模型的参数,为了利用我们的卷积神经网络模型和这些参数去对图像进行分类,我们这次实验就来编写代码实现一个...
  • python学习(18)--图片分类

    万次阅读 2017-06-17 12:09:36
    图片分类学习动机.在这一节中我们会引入图片分类为题。这也是从一个合适的集合中分配给图片一个标记的任务。这是计算机视觉的核心问题之一。鉴于它的简单性,有一大批实用应用。更多的是,我们可以在以后的章节中...
  • 尽管没有 GPU,但还是很想在个人笔记本的 CPU 上试试图片分类,有木有?如果你想试试,那就来吧。我们都知道,深度学习在图片分类方面已经取得了很大的成就,大家对于常见的神经网络,如 CNN,VGG 等也非常熟悉,...
  • 用java做一个图片分类软件

    千次阅读 2019-08-26 21:43:51
    用java做一个图片分类软件 目前仅仅打包成了可执行jar包。执行图如下: //初始数据 private static final long serialVersionUID = 1L; private JPanel contentPane; private JTextField tf_yuan; ...
  • 使用卷积神经网络进行图片分类 1

    万次阅读 2017-06-20 09:43:18
    然后动手使用caffe深度学习框架训练一个卷积神经网络模型,并用训练好的模型进行图片分类。 学习本课程之前,请先学习课程814 使用python实现深度神经网络以了解必要的基本概念,本实验中涉及到的深度学习基本概念...
  • 我做的参考项目我完成了一个简单了android上的图片分类相册,tf部分已经正常工作了,你可以参考,项目github这里有几篇博客你可以参考博客零,忽略docker部分,用bazel训练一个pc可用的图片分类模型博客一,将上面的...
  • 这篇文章主要给不知道计算机视觉...用k-近邻进行图片分类 5.1 k近邻分类原理 5.2 超参数的选取 小结一下最近邻和k近邻 1.图像分类 1.1 图像分类的原理 计算机视觉中的核心问题是给定一张图片的类别,新来一张图片,
  • “华为云杯”2020深圳开放数据应用创新大赛·生活垃圾图片分类 链接 https://blog.csdn.net/weixin_38208912/article/details/103817188 https://zhuanlan.zhihu.com/p/96033452 目标检测模型 实战过程 数据增强 ...
  • 亲测真正好用的WordPress媒体库图片分类插件
  • python实现用SIFT+K-MEANS+SVM图片分类

    万次阅读 热门讨论 2017-03-28 10:52:10
    用python实现图片分类过程: 1. 按图片类别抽取训练集中所有图片的SIFT特征; 2. 将每一类图片的SIFT特征聚类为K类,构成该类的visual vocabulary(其size为K); 3. 对于训练集中的每一张图片,统计vocabulary中K个...
  • Caffe图片分类

    千次阅读 2016-10-27 19:29:28
    现在我把这0~9,A~Z文件夹内的图片分类分别保存到/home/schao/sc_tmp/caffe/caffe-master/examples/numlet/sglimgbak这个目录下0~9,A~Z目录中 则代码改成如上形式并且编译后执行下述命令::: ./...
  • 利用TensorFlow实现对花朵数据集的图片分类 提示:以下是本篇文章正文内容,下面案例可供参考 一、数据集 数据集是五个分别存放着对应类别花朵图片的五个文件夹,包括daisy(雏菊)633张;dandelion(蒲公英)898张...
  • Pytorch 实现自己的残差网络图片分类器 本文主要讨论网络的代码实现,不对其原理进行深究。 一、项目模块包导入。 import sys import getopt import argparse import os import shutil import time import ...
  • 我的代码:参考上述代码逻辑进行我自己的图片分类,修改点:1、修改读取数据的接口,来读取自己的数据集,数据集结构和mnist的数据集结构完全一致,2、修类别又10修改为47,将IMAGE_SIZE修改为1920(图片的大小为...
  • 图片分类

    千次阅读 2016-03-28 16:40:38
    大量图像中,需要将图片进行分类,比如有两种类型的图片各若干张(汽车,恐龙) 通过分析这些图片的特征,进行处理,再输入图像,就能判断该图像的所属分类。 目前,图片的识别正确率为97%左右,假如有需要...
  • 因最近需要用到图片分类的应用,但是找来找去没有用的比较顺手的,所以就自己找到了EasyDL平台进行一个简单的图片分类开发,今天就说一下用python实现对EasyDL平台训练好的模型进行API调用。 1、首先贴上总代码方便...
  • EfficientNet B0 训练 汽车图片分类(对比ResNet34) 近期google发布了新的model,不仅让整个参数量大幅的降低, 主要利用同时调整模型的width, depth, resolution来让训练过程跟结果达到比较高效的目的, 大概也...
  • 用Tensorflow实现图片分类+详细注解

    万次阅读 多人点赞 2018-06-03 22:21:25
    使用tensorflow实现花卉分类,训练样本用的是网上的花卉数据集,测试样本是在网上重新下载的各种花的图片,代码如下。   from skimage import io,transform #skimage模块下的io transform(图像的形变与缩放)模块 ...
  • 用Keras构建网络并使用其提供的预训练权重进行简单的图像分类. ...使用InceptionV3进行图片分类 #!/usr/bin/python # coding:utf8 from keras.applications.inception_v3 import InceptionV3 from k...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 339,021
精华内容 135,608
关键字:

图片分类