[人工智能]pytorch(2)

自定义损失函数

有时候我们可以将损失函数改成我们想要的，主要有以下两种方式

• 函数形式
  直接以函数形式定义即可

def my_loss(output, target): 
	loss = torch.mean((output - target)**2) 
	return loss

• 以类的方式定义
  需要继承自nn.Module类

class DiceLoss(nn.Module): 
	def __init__(self,weight=None,size_average=True): 
	super(DiceLoss,self).__init__() 
def forward(self,inputs,targets,smooth=1):
	 inputs = F.sigmoid(inputs) 
	 inputs = inputs.view(-1) 
	 targets = targets.view(-1) 
	 intersection = (inputs * targets).sum() 
	 dice = (2.*intersection + smooth)/(inputs.sum() + targets.sum() + smooth) 
	 return 1 - dice 
# 使用方法 
criterion = DiceLoss()
loss = criterion(input,targets)

动态调整学习率

学习速率设置过小，会极大降低收敛速度，增加训练时间；学习率太大，可能导致参数在最优解两侧来回振荡。但当选定了一个合适的学习率后，经过许多轮的训练后，可能会出现准确率震荡或loss不再下降等情况，说明当前学习率已不能满足模型调优的需求。此时可以通过一个适当的学习率衰减策略来改善这种现象，提高我们的精度。这种设置方式在PyTorch中被称为scheduler

• 直接使用官方api

# 选择一种优化器 
optimizer = torch.optim.Adam(...) 
# 选择上面提到的一种或多种动态调整学习率的方法 
scheduler1 = torch.optim.lr_scheduler.... 
scheduler2 = torch.optim.lr_scheduler....
 ... 
schedulern = torch.optim.lr_scheduler.... 
# 进行训练 
for epoch in range(100): 
	train(...) 
	validate(...) 
	optimizer.step() 
# 需要在优化器参数更新之后再动态调整学习率 
scheduler1.step() 
	...

• 自定义

def adjust_learning_rate(optimizer, epoch): 
	lr = args.lr * (0.1 ** (epoch // 30)) 
	for param_group in optimizer.param_groups: 
	param_group['lr'] = lr
optimizer = torch.optim.SGD(model.parameters(),lr = args.lr,momentum = 0.9) 
for epoch in range(10): 
	train(...) 
	validate(...) 
	adjust_learning_rate(optimizer,epoch)

模型微调

迁移学习的一大应用场景是模型微调（finetune）。简单来说，就是我们先找到一个同类的别人训练好的模型，把别人现成的训练好了的模型拿过来，换成自己的数据，通过训练调整一下参数。

• 传递 pretrained 参数
  通过 True 或者 False 来决定是否使用预训练好的权重，在默认状态下 pretrained = False ，意味着我们不使用预训练得到的权重，当 pretrained = True ，意味着我们将使用在一些数据集上预训练得到的权重。

import torchvision.models as models 
resnet18 = models.resnet18(pretrained=True) 
alexnet = models.alexnet(pretrained=True) 
squeezenet = models.squeezenet1_0(pretrained=True)

• 训练特定层
  在默认情况下，参数的属性 .requires_grad = True ，如果我们从头开始训练或微调不需要注意这里。但如果我们正在提取特征并且只想为新初始化的层计算梯度，其他参数不进行改变。那我们就需要通过设置 requires_grad = False 来冻结部分层。在PyTorch官方中提供了这样一个例程。

def set_parameter_requires_grad(model, feature_extracting): 
	if feature_extracting: 
		for param in model.parameters(): 
			param.requires_grad = False
import torchvision.models as models # 冻结参数的梯度 
feature_extract = True 
model = models.resnet18(pretrained=True) 
set_parameter_requires_grad(model, feature_extract) # 修改模型 
num_ftrs = model.fc.in_features 
model.fc = nn.Linear(in_features=512, out_features=4, bias=True)

之后在训练过程中，model仍会进行梯度回传，但是参数更新则只会发生在fc层。通过设定参数的requires_grad属性，我们完成了指定训练模型的特定层的目标，这对实现模型微调非常重要。

可视化

• 使用torchinfo可视化网络结构

import torchvision.models as models f
rom torchinfo import summary 
resnet18 = models.resnet18() # 实例化模型 
summary(model, (1, 3, 224, 224)) # 1：batch_size 3:图片的通道数 224: 图片的高宽

• 卷积核可视化

conv1 = dict(model.features.named_children())['3'] 
kernel_set = conv1.weight.detach() num = len(conv1.weight.detach()) 
print(kernel_set.shape) 
for i in range(0,num): 
	i_kernel = kernel_set[i] 
	plt.figure(figsize=(20, 17)) 
	if (len(i_kernel)) > 1: 
		for idx, filer in enumerate(i_kernel): 
			plt.subplot(9, 9, idx+1) 
			plt.axis('off') 
			plt.imshow(filer[ :, :].detach(),cmap='bwr')

• CNN特征图可视化
  与卷积核相对应，输入的原始图像经过每次卷积层得到的数据称为特征图，可视化卷积核是为了看模型提取哪些特征，可视化特征图则是为了看模型提取到的特征是什么样子的。
  在PyTorch中，提供了一个专用的接口使得网络在前向传播过程中能够获取到特征图，叫做hook。
• CNN class activation map可视化方法
  class activation map （CAM）的作用是判断哪些变量对模型来说是重要的，在CNN可视化的场景下，即判断图像中哪些像素点对预测结果是重要的。除了确定重要的像素点，人们也会对重要区域的梯度感兴趣，因此在CAM的基础上也进一步改进得到了Grad-CAM（以及诸多变种）

from pytorch_grad_cam import GradCAM,ScoreCAM,GradCAMPlusPlus,AblationCAM,XGradCAM,EigenCAM,FullGrad 
from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget 
from pytorch_grad_cam.utils.image 
import show_cam_on_image 
target_layers = [model.features[-1]] 
# 选取合适的类激活图，但是ScoreCAM和AblationCAM需要batch_size 
cam = GradCAM(model=model,target_layers=target_layers) 
targets = [ClassifierOutputTarget(preds)] 
# 上方preds需要设定，比如ImageNet有1000类，这里可以设为200 
grayscale_cam = cam(input_tensor=img_tensor, targets=targets) 
grayscale_cam = grayscale_cam[0, :] 
cam_img = show_cam_on_image(rgb_img, grayscale_cam, use_rgb=True) 
print(type(cam_img)) 
Image.fromarray(cam_img)

• 使用FlashTorch快速实现CNN可视化
  这是一个可以可视化的开源工具
  • 可视化梯度

  import matplotlib.pyplot as plt 
  import torchvision.models as models 
  from flashtorch.utils import apply_transforms, load_image 
  from flashtorch.saliency import Backprop 
  model = models.alexnet(pretrained=True) 
  backprop = Backprop(model) 
  image = load_image('/content/images/great_grey_owl.jpg') 
  owl = apply_transforms(image) 
  target_class = 24 
  backprop.visualize(owl, target_class, guided=True, use_gpu=True)
  

  • 可视化卷积核

  import torchvision.models as models 
  from flashtorch.activmax import GradientAscent 
  model = models.vgg16(pretrained=True) 
  g_ascent = GradientAscent(model.features) 
  # specify layer and filter info 
  conv5_1 = model.features[24] 
  conv5_1_filters = [45, 271, 363, 489] 
  g_ascent.visualize(conv5_1, conv5_1_filters, title="VGG16: conv5_1")
  

TensorBoard可视化

训练过程的可视化在深度学习模型训练中扮演着重要的角色。学习的过程是一个优化的过程，我们需要找到最优的点作为训练过程的输出产物。
我们需要使用命令行进行可视化

tensorboard --logdir=/path/to/logs/ --port=xxxx

下面是示例代码
SummaryWriter的作用就是，将数据以特定的格式存储到下面创建的文件夹（runs）中。

from tensorboardX import SummaryWriter 
writer = SummaryWriter('./runs')# 数据存在这里！！！！
writer.add_graph(model, input_to_model = torch.rand(1, 3, 224, 224)) 
writer.close()

• 对图像可视化

import torchvision from torchvision 
import datasets, transforms from torch.utils.data 
import DataLoader 
transform_train = transforms.Compose( [transforms.ToTensor()]) 
transform_test = transforms.Compose( [transforms.ToTensor()]) 
train_data = datasets.CIFAR10(".", train=True, download=True, transform=transform_train) 
test_data = datasets.CIFAR10(".", train=False, download=True, transform=transform_test) 
train_loader = DataLoader(train_data, batch_size=64, shuffle=True) 
test_loader = DataLoader(test_data, batch_size=64) 
images, labels = next(iter(train_loader)) # 仅查看一张图片 
writer = SummaryWriter('./pytorch_tb') 
writer.add_image('images[0]', images[0]) 
writer.close() # 将多张图片拼接成一张图片，中间用黑色网格分割 
# create grid of images
 writer = SummaryWriter('./pytorch_tb') 
 img_grid = torchvision.utils.make_grid(images) 
 writer.add_image('image_grid', img_grid) 
 writer.close() # 将多张图片直接写入 
 writer = SummaryWriter('./pytorch_tb') 
 writer.add_images("images",images,global_step = 0) 
 writer.close()