【CV实战】年轻人的第一个深度学习CV项目应该是什么样的？（支持13大深度学习开源框架）

1 项目背景

2 数据获取

import os

import sys

import cv2

import numpy as np

def listfiles(rootDir):

    list_dirs = os.walk(rootDir)

    for root, dirs, files in list_dirs:

        for d in dirs:

            print os.path.join(root,d)

        for f in files:

            fileid = f.split('.')[0] 

            filepath = os.path.join(root,f)

            try:

                src = cv2.imread(filepath,1)

                print "src=",filepath,src.shape

                os.remove(filepath)                          cv2.imwrite(os.path.join(root,fileid+".jpg"),src)

            except:

                os.remove(filepath)

                continue

listfiles(sys.argv[1]) ##输入文件夹即可

#coding:utf8

import cv2

import dlib

import numpy as np

import sys

import os

cascade_path='haarcascade_frontalface_default.xml'

cascade = cv2.CascadeClassifier(cascade_path)

images = os.listdir(sys.argv[1])

for image in images:

    im=cv2.imread(os.path.join(sys.argv[1],image),1)

    rects = cascade.detectMultiScale(im, 1.3,5)

    print "detected face",len(rects)

    if len(rects) == 0:

        cv2.namedWindow('Result',0)

        cv2.imshow('Result',im)

        os.remove(os.path.join(sys.argv[1],image))

        k =cv2.waitKey(0)

        if k == ord('q'):

            break

import cv2

import dlib

import numpy as np

import sys

import os

PREDICTOR_PATH = "shape_predictor_68_face_landmarks.dat"

predictor = dlib.shape_predictor(PREDICTOR_PATH)

cascade_path='haarcascade_frontalface_default.xml'

cascade = cv2.CascadeClassifier(cascade_path)

def get_landmarks(im):

    rects = cascade.detectMultiScale(im, 1.3,5)

    x,y,w,h =rects[0]

    rect=dlib.rectangle(x,y,x+w,y+h)

    return np.matrix([[p.x, p.y] for p in predictor(im, rect).parts()])

def annotate_landmarks(im, landmarks):

    im = im.copy()

    for idx, point in enumerate(landmarks):

        pos = (point[0, 0], point[0, 1])

        cv2.putText(im, str(idx), pos,

                    fontFace=cv2.FONT_HERSHEY_SCRIPT_SIMPLEX,

                    fontScale=0.4,

                    color=(0, 0, 255))

        cv2.circle(im, pos, 5, color=(0, 255, 255))

    return im

def getlipfromimage(im,landmarks):

    xmin = 10000

    xmax = 0

    ymin = 10000

    ymax = 0

    for i in range(48,67):

        x = landmarks[i,0]

        y = landmarks[i,1]

        if x < xmin:

            xmin = x

        if x > xmax:

            xmax = x

        if y < ymin:

            ymin = y

        if y > ymax:

            ymax = y

    print "xmin=",xmin

    print "xmax=",xmax

    print "ymin=",ymin

    print "ymax=",ymax

    roiwidth = xmax - xmin

    roiheight = ymax - ymin

    roi = im[ymin:ymax,xmin:xmax,0:3]

    if roiwidth > roiheight:

        dstlen = 1.5*roiwidth

    else:

        dstlen = 1.5*roiheight

    diff_xlen = dstlen - roiwidth

    diff_ylen = dstlen - roiheight

    newx = xmin

    newy = ymin

    imagerows,imagecols,channel = im.shape

    if newx >= diff_xlen/2 and newx + roiwidth + diff_xlen/2 < imagecols:

        newx  = newx - diff_xlen/2;

    elif newx < diff_xlen/2:

        newx = 0;

    else:

        newx =  imagecols - dstlen;

    if newy >= diff_ylen/2 and newy + roiheight + diff_ylen/2 < imagerows:

        newy  = newy - diff_ylen/2;

    elif newy < diff_ylen/2:

        newy = 0;

    else:

        newy =  imagecols - dstlen;

    roi = im[int(newy):int(newy+dstlen),int(newx):int(newx+dstlen),0:3]

    return roi

def listfiles(rootDir):

    list_dirs = os.walk(rootDir)

    for root, dirs, files in list_dirs:

        for d in dirs:

            print os.path.join(root,d)

        for f in files:

            fileid = f.split('.')[0]

            filepath = os.path.join(root,f)

            try:

                im = cv2.imread(filepath,1)

        landmarks = get_landmarks(im)

                roi = getlipfromimage(im,landmarks)

                roipath = filepath.replace('.jpg','_mouth.png')

                cv2.imwrite(roipath,roi)

            except:

                print "error"

                continue

listfiles(sys.argv[1])

3 模型训练

import torchvision

from torchvision import datasets, models, transforms

data_dir = './data' ##数据目录

## 创建数据预处理函数，训练预处理包括随机裁剪缩放、随机翻转、归一化，验证预处理包括中心裁剪，归一化

data_transforms = {

        'train': transforms.Compose([

            transforms.RandomSizedCrop(48),

            transforms.RandomHorizontalFlip(),

            transforms.ToTensor(),

            transforms.Normalize([0.5,0.5,0.5], [0.5,0.5,0.5])

        ]),

        'val': transforms.Compose([

            transforms.Scale(64),

            transforms.CenterCrop(48),

            transforms.ToTensor(),

            transforms.Normalize([0.5,0.5,0.5], [0.5,0.5,0.5])

        ]),

  }

 ## 使用torchvision的dataset ImageFolder接口读取数据

 image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),

                                              data_transforms[x]) for x in ['train', 'val']}

  ## 创建数据指针，设置batch大小，shuffle，多进程数量

  dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x],

                                                 batch_size=16,

                                                 shuffle=True,

                                                 num_workers=4) for x in ['train', 'val']}

data

├── train

│   ├── 0

│   ├── 1

│   ├── 2

│   └── 3

└── val

    ├── 0

    ├── 1

    ├── 2

    └── 3

imagefolder有3个成员变量。

self.classes：用一个list保存类名，就是文件夹的名字。

self.class_to_idx：类名对应的索引，可以理解为 0、1、2、3 等。

self.imgs：保存（imgpath，class），是图片和类别的数组。

## 3层卷积神经网络simpleconv3定义

## 包括3个卷积层，3个BN层，3个ReLU激活层，3个全连接层

class simpleconv3(nn.Module):

    ## 初始化函数

    def __init__(self,nclass):

        super(simpleconv3,self).__init__()

        self.conv1 = nn.Conv2d(3, 12, 3, 2) #输入图片大小为3*48*48，输出特征图大小为12*23*23，卷积核大小为3*3，步长为2

        self.bn1 = nn.BatchNorm2d(12)

        self.conv2 = nn.Conv2d(12, 24, 3, 2) #输入图片大小为12*23*23，输出特征图大小为24*11*11，卷积核大小为3*3，步长为2

        self.bn2 = nn.BatchNorm2d(24)

        self.conv3 = nn.Conv2d(24, 48, 3, 2) #输入图片大小为24*11*11，输出特征图大小为48*5*5，卷积核大小为3*3，步长为2

        self.bn3 = nn.BatchNorm2d(48)

        self.fc1 = nn.Linear(48 * 5 * 5 , 1200) #输入向量长为48*5*5=1200，输出向量长为1200

        self.fc2 = nn.Linear(1200 , 128) #输入向量长为1200，输出向量长为128

        self.fc3 = nn.Linear(128 , nclass) #输入向量长为128，输出向量长为nclass，等于类别数

    ## 前向函数

    def forward(self, x):

        ## relu函数，不需要进行实例化，直接进行调用

        ## conv，fc层需要调用nn.Module进行实例化

        x = F.relu(self.bn1(self.conv1(x)))

        x = F.relu(self.bn2(self.conv2(x)))

        x = F.relu(self.bn3(self.conv3(x)))

        x = x.view(-1 , 48 * 5 * 5) 

        x = F.relu(self.fc1(x))

        x = F.relu(self.fc2(x))

        x = self.fc3(x)

        return x

(1) simpleconv3(nn.Module)继承

继承nn.Module，Pytorch的网络层是包含在nn.Module 里，所以所有的网络定义，都需要继承该网络层，并实现super方法，如下：

(2) 网络结构定义

网络定义在nn包中，完整的接口如上，定义的第一个卷积层如下，输入通道为3，输出通道为12，卷积核大小为3，stride=2：

(3) forward方法

backward方法不需要自己实现，但是forward函数是必须要自己实现的，从上面可以看出，forward 函数也是非常简单，串接各个网络层就可以了。Pytorch已经提供了默认初始化，如果我们想实现自己的初始化，可以这么做：

它会对conv1的权重和偏置进行初始化。如果要对所有conv层使用 xavier 初始化呢？可以定义一个函数：

## 训练主函数

def train_model(model, criterion, optimizer, scheduler, num_epochs=25):

    for epoch in range(num_epochs):

        print('Epoch {}/{}'.format(epoch, num_epochs - 1))

        for phase in ['train', 'val']:

            if phase == 'train':

                scheduler.step()

                model.train(True)  ## 设置为训练模式

            else:

                model.train(False)  ## 设置为验证模式

            running_loss = 0.0 ## 损失变量

            running_accs = 0.0 ##精度变量

            ## 从dataloaders中获得数据

            for data in dataloaders[phase]:

                inputs, labels = data 

                if use_gpu:

                    inputs = inputs.cuda()

                    labels = labels.cuda()

                optimizer.zero_grad() ##清空梯度

                outputs = model(inputs) ##前向运行

                _, preds = torch.max(outputs.data, 1) ##使用max()函数对输出值进行操作，得到预测值索引

                loss = criterion(outputs, labels) ##计算损失

                if phase == 'train':

                    loss.backward() ##误差反向传播

                    optimizer.step() ##参数更新

                running_loss += loss.data.item()

                running_accs += torch.sum(preds == labels).item()

            ## 得到每一个epoch的平均损失与精度

            epoch_loss = running_loss / dataset_sizes[phase]

            epoch_acc = running_accs / dataset_sizes[phase]

            ## 收集精度和损失用于可视化

            if phase == 'train':

                writer.add_scalar('data/trainloss', epoch_loss, epoch)

                writer.add_scalar('data/trainacc', epoch_acc, epoch)

            else:

                writer.add_scalar('data/valloss', epoch_loss, epoch)

                writer.add_scalar('data/valacc', epoch_acc, epoch)

            print('{} Loss: {:.4f} Acc: {:.4f}'.format(

                phase, epoch_loss, epoch_acc))

    writer.close()

    return model

4 模型测试

#coding:utf8

# Copyright 2019 longpeng2008. All Rights Reserved.

# Licensed under the Apache License, Version 2.0 (the "License");

# If you find any problem,please contact us

#

#     longpeng2008to2012@gmail.com 

#

# or create issues

# =============================================================================

import sys

import numpy as np

import cv2

import os

import dlib

import torch

import torch.nn as nn

import torch.optim as optim

from torch.optim import lr_scheduler

from torch.autograd import Variable

import torchvision

from torchvision import datasets, models, transforms

import time

import os

from PIL import Image

import sys

import torch.nn.functional as F

## 全局变量

## sys.argv[1] 权重文件

## sys.argv[2] 图像文件夹

testsize = 48 ##测试图大小

from net import simpleconv3

net = simpleconv3(2) ## 定义模型

net.eval() ## 设置推理模式，使得dropout和batchnorm等网络层在train和val模式间切换

torch.no_grad() ## 停止autograd模块的工作，以起到加速和节省显存

## 载入模型权重

modelpath = sys.argv[1] 

net.load_state_dict(torch.load(modelpath,map_location=lambda storage,loc: storage))

## 定义预处理函数

data_transforms =  transforms.Compose([

            transforms.Resize(48),

            transforms.ToTensor(),

            transforms.Normalize([0.5,0.5,0.5], [0.5,0.5,0.5])])

## 读取3通道图片，并扩充为4通道tensor

imagepath = sys.argv[2]

image = Image.open(imagepath)

imgblob = data_transforms(image).unsqueeze(0)

## 获得预测结果predict，得到预测的标签值label

predict = net(imgblob)

index = np.argmax(predict.detach().numpy())

## print(predict)

## print(index)

总结

• 【CV春季划】2021年有三AI-CV春季划出炉，最后一届言有三手把手从零带学

• 【CV夏季划】告别入门，提升眼界，从掌握最有价值的那些CV方向开始
  

• 【CV秋季划】生成对抗网络GAN有哪些研究和应用，如何循序渐进地学习好？

• 【CV秋季划】模型优化很重要，如何循序渐进地学习好？

• 【CV秋季划】人脸算法那么多，如何循序渐进地学习好？

• 【CV秋季划】图像质量提升与编辑有哪些研究和应用，如何循序渐进地学习好？