深入浅出Pytorch之机器视觉案例，学习总结

图像分类任务简介

图像分类神经网络基本结构就是：

• 卷积层
• 线性层
• Softmax层
  

目标检测任务简介

1. 回归框(Bounding Box)
2. 分类(Classification)

根据两个小任务的同步异步来分：

One-stage	Two-stage
SSD/ YOLO/ Retinanet	R-CNN
速度快，精度稍低	速度慢，精度高

• 分别用什么损失函数？
  
• 目标检测网络基本结构
  

总的方法论：

不同级别的卷积神经网络中提取不同尺寸的目标的特征信息

图像分割任务简介

1. 分割是针对 像素分类, 每一个像素分批一个类别
2. 转置卷积进行上采样，得到最后和原图大小一致的输出张量

图像生成任务简介

• 这次属于无监督任务！
• 给定图像数据集，通过深度学习模型训练，产生服从这些图像数据集分布的图像。

神经网络生成图像的先验分布，使用分布生成张量，然后通过转置卷积生成目标图像.

如何训练？

VAE	GAN
MSE（输入，输出）	交替输入真实图像和生成网络生成的图像，使得输出概率接近0.5

p=0.5等于判别器已经分不出来是真还是假了。

常用深度学习数据集

1 VOC

• 20 类

2 COCO

• 80 类

3 ImageNet

• 1000类

深度学习工程的结构

project/
	csrc/
	data.py
	utils.py
	model.py
	train,py
	inference.py

• csrv文件夹： 存放c/c++编写的库
• data.py： 数据载入包括Dataset和DataLoader类
• utils.py： 模型模块的预处理工具
• model.py
• train.py
• inference.py： 测试，推理

LeNet手把手

1 建立模型

import pytorch
import torch.nn as nn

class LeNet(nn.Module):
	def __init__(self):
		super().__init__()
		self.conv1= self.Sequential(
			nn.Conv2d(1,6,3),
			#nn.BatchNorm2d(6)
			nn.ReLu(inplace=True),
			nn.MaxPool2d(2,2))
			
		self.conv1= self.Sequential(
			nn.Conv2d(6,16,3),
			#nn.BatchNorm2d(6)
			nn.ReLu(inplace=True),
			nn.MaxPool2d(2,2) )
		
		self.fc1 = nn.Sequential(
			nn.Linear(16*6*6, 120,
			nn.ReLu(inplace=True) )
			
		seff.fc2 = nn.Sequential(
			nn.Linear(120, 184),
			nn.ReLu(inplace=True) )
			
		sefl.fc3 = nn.Linear(84, 10),
			
		
	def forward(self,x):
		x = self.conv1(x)
		x = self.conv2(x)
		x = self.fc1(x)
		x = self.fc2(x)
		x = self.fc3(x)
		return x
	

2 训练

import torch
import torch.nn as nn
from model import LeNet # 从model.py里导入LeNet

import torch.optim as optim

model = LeNet()
model.train() #训练形态

criterion = nn.CrossEntropyLoss() #自带softmax和one_hot encoding
optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, 
					weight_decay=5e-4)

for epoch in range(epoches):
	train_loss =0
	correct=0
	total=0
	for batch_idx ,(inputs,targets) in enumertate(data_train_loader):
		optimizer.zero_grad() #非常重要
		outputs = model(inputs)#计算输出
		loss = criterion(outputs, targets) #计算loss
		loss.backward()  #反向传播开始
		optimizer.step() #优化器通过梯度张量更新权重张量
	
		train_loss+=loss.item() #获得张量里面的内容用.item()
		_,predictd = outputs.max(1)
		total+=targets.size(0)
		correct+=predicted.eq(targets).sum().item)  #tensorl.eq()
		

3 测试inference

import torch
import torch.nn as nn
from model import LeNet

'''
save_info ={
"iter_num": iter_num, #迭代步数
"optimizer": optimizer.state_dict(), #优化器的状态字典
"model":mpdel.state_dict() # 模型的状态字典
}
'''

model_path = "./model.pth"
save_info = torch.load(model.path)
model = LeNet()
criterion = nn.CrossEntropyLoss()
model.load_state_dict(save_info["model"])

model.eval() # 切换到测试形态

test_loss=0
correct=0
total=0

with torch.no_grad():#关闭计算图，节省计算量，因为不需要计算梯度
	for batch_idx, (inputs,targets) in enumerate(test_data_loader):
		outputs = model(inputs)
		loss = criterion(outputs, targets)
		
		test_loss += loss.item()
		_,predicted = outputs.max(1)
		total+=targets.size(0)
		correct = predicted.eq(targets).sum().item()
		

命令行，argparse修改超参数

import argparse

parser = argparse.ArgumentParser(description="随意提示") #创建理解器实例

parser.add_argument('--lr',default=0.01, type=float, help="learning rate")
parser.add_argument('--batch_size','-b', default = 256, type=int)


args=parser.parse_args() #开始理解

SSD（Single Shot MultiBox Detector）

1. 特征提取骨架： VGG-16

2. VGG300 VGG500 模型特征提取，数字代表输入的大小

3. One-Stage算法

4. ImageNet图片大小输入为(N, 3, 224, 224)

5. Anchor Box 的选择和坐标转换

6. IOU代码，概念

7. NMS代码，概念

8. 损失函数

FCN

图像风格迁移

1. content loss

class ContentLoss(nn.Module):
	def __init__(self):
		super().__init__()
		self.target = target.detach()
		
	def forward(self,input):
		self.loss = F.mse_loss(input, self.target)
		return input
		

2. style loss

def gram_matrix(input):
	a,b,c,d = input.size()
	features = input.view(a*b,c*d)
	G = torch.mm(features, features.t()) # tensor.t(）表示转置
	return G.div(a*b,c*d)

class StyleLoss(nn.Module):
	def __init__(self, target_feature）：
		super.().__init__()
		self.target = gram_matrix(target_feature).detach()
	def forward(self,input):
		G=gram_matrix(input)
		self.loss = F.mse_loss(G, self.target)
		return input