零基础学习人工智能—Python—Pytorch学习（十）
前言
本文的内容是来自教程视频的第十五集，个人感觉，这个教程是有点虎头蛇尾，就是前面开始的教程，是非常惊人的好，但到这里，就有点水了，可以说就是把代码一铺，然后简单介绍一遍，很多细节都没有讲，所以，我在学习的时候，也是没办法从视频中直接学习，要先自学了代码后，再看的视频教程。
概念
前面已经解释了神经网络和卷积神经网络，本文要介绍残差网络。在学习之前，我们要先学习几个概念。
迁移学习 Transfer learning
Transfer learning 迁移学习，是旨在利用在一个或多个源任务（source tasks）上已经学习到的知识（例如模型参数、特征表示等），来帮助在目标任务（target task）上进行更高效的学习，使得目标任务能够在较少的标注数据、较短的训练时间等情况下，达到较好的学习效果。
残差网络
残差网络（Residual Network，简称 ResNet）是2015年提出的[深度卷积神经网络（CNN）架构]，旨在解决深层神经网络训练中的退化问题。ResNet引入了一个非常重要的概念——残差学习（Residual Learning），使得网络能够训练非常深的网络，同时避免了传统深度网络中梯度消失或爆炸等问题。
ResNet-18
ResNet-18（Residual Network 18）是一个深度卷积神经网络（CNN），属于 ResNet（残差网络） 系列的一种，具有 18 层。它是由微软研究院（Microsoft Research）提出的，主要解决深层神经网络训练中的退化问题，并且在很多计算机视觉任务中表现非常出色。
ResNet-18 是 ResNet 系列中的一个较小的模型，它包含 18 层（包括卷积层、批归一化层、ReLU 激活函数等）。与更深的 ResNet 模型（如 ResNet-34、ResNet-50、ResNet-101 等）相比，ResNet-18 相对较小，适用于计算资源有限或者需要较快速训练的任务。
ResNet-18 的架构大致如下：
输入层：通常输入为大小为 (224, 224, 3) 的 RGB 图像（比如 ImageNet 数据集中的图像），也可以根据任务调整输入尺寸。
卷积层：ResNet-18 包含初始卷积层和多个残差块（Residual Block）。每个残差块中使用了所谓的“跳跃连接”，即输入会绕过某些卷积层，直接与某些层的输出相加，从而帮助缓解训练中的梯度消失和梯度爆炸问题。
残差连接（Skip Connection）：通过引入 跳跃连接，每个残差块的输入都会与通过一系列卷积层后的输出相加，这样的设计能有效解决网络深度增加带来的性能退化问题。
全连接层：经过卷积和池化操作后的特征图会展平，并通过全连接层进行分类。
python和tensor基础学习
python字典推导式：
{key_expression: value_expression for item in iterable if condition}
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
# 使用字典推导式将列表转为字典
age_dict = {names[i]: ages[i] for i in range(len(names))}
print(age_dict)
python的文件夹
在python中【../】表示向上一级目录。
ImageFolder
ImageFolder 会自动产生标签，所以可以配合DataLoader，作为入参使用。
#==========================transforms对象===================================================
# 在 ../pytorchTutorial/data/hymenoptera_data 下有两个子文件夹 train 和 val，每个文件夹中包含不同类别的图像文件。
# 目录结构如下：
# hymenoptera_data/
# ├── train/
# │ ├── ants/
# │ └── bees/
# └── val/
# ├── ants/
# └── bees/
# 在这种结构下，ImageFolder 会自动为 ants 和 bees 文件夹分配标签（例如，ants 可能对应标签 0，bees 对应标签 1）。
# 每个图像会被转换为一个 PIL （Python Imaging Library）图像对象，经过预处理后转化为 Tensor。
data_dir = '../pytorchTutorial/data/hymenoptera_data'# ../表示向上一级目录
#导入图片
image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),
data_transforms[x])
for x in ['train', 'val']}
上图中1=0就是这个图片的标签。
DataLoader使用ImageFolder
data_dir = '../pytorchTutorial/data/hymenoptera_data'# ../表示向上一级目录
#导入图片
image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),
data_transforms[x])
for x in ['train', 'val']}
#图片导入进dataloader shuffle=True启用了数据洗牌
dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4,
shuffle=True, num_workers=0)
for x in ['train', 'val']}
#取出图片的train和val文件夹图片的数量
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# 标签名
class_names = image_datasets['train'].classes
# 标签值
class_to_idx = image_datasets['train'].class_to_idx
print('标签值',class_to_idx) # {'ants': 0, 'bees': 1}
print('标签名',class_names) # ['ants', 'bees']
print('train-dataset_sizes',dataset_sizes['train']) #train-dataset_sizes 244
print('val-dataset_sizes',dataset_sizes['val']) #val-dataset_sizes 153
模型参数
model.state_dict()是参数模型，就是权重值和偏移量，就是前面讲到的y=wx+b的w和b。
print('查看模型的参数')
model = nn.Sequential(
nn.Linear(2, 3),
nn.ReLU(),
nn.Linear(3, 1)
)
# 查看模型的参数
print(model.state_dict())
# 输出将是模型每一层的权重和偏置：
# OrderedDict([('0.weight', tensor([[ 0.3356, 0.5206], [-0.4083, 0.3680], [-0.4225, -0.5568]])),
# ('0.bias', tensor([-0.5880, -0.6807, -0.4809])),
# ('2.weight', tensor([[-0.2668, 0.5349, 0.2408]])),
# ('2.bias', tensor([-0.3686]))])
调整张量的列顺序
print('使用tensor调整表格顺序')
#========使用tensor调整表格顺序
# 假设 images 是一个形状为 (B, C, H, W) 的图像 Tensor
# B 是批量大小（即图像的数量）。
# C 是图像的通道数（例如，RGB 图像的通道数是 3）。
# H 和 W 分别是图像的高度和宽度。
# 创建一个假设的图像数据：6 张 3 通道（RGB），28x28 大小的图像
images = torch.randn(6, 3, 28, 28)
# 将图像们排列成网格,grid_img 就是将 6 张图片拼接后的网格图像
# torchvision.utils.make_grid() 函数生成的网格图像，它的形状是 (C, H, W)
grid_img = torchvision.utils.make_grid(images)
print("grid_img.shape",grid_img.shape) # grid_img.shape torch.Size([3, 32, 182])
# 显示这个网格图像
# PyTorch 张量默认的图像格式是 (C, H, W)，也就是说：通道、图像高度和宽度。
# 这里传0 2 1是在调整grid_img的3列的顺序，让(C, H, W)调整为(H, W, C)，这符合 Matplotlib 显示图像时的标准要求
plt.imshow(grid_img.permute(1, 2, 0)) # 由于 grid_img 的形状是 (C, H, W)，需要将其转为 (H, W, C)
plt.show()
print('使用numpy调整表格顺序')
#========使用numpy调整表格顺序
def imshow(img):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0))) # 调整tensor列顺序
plt.show()
imshow(torchvision.utils.make_grid(images))
torch.max使用
print('torch.max使用')
#======== torch.max
# 假设模型输出 (3个样本, 4个类别)
outputs = torch.tensor([[1.2, 2.5, 0.3, 4.1],
[3.1, 0.2, 1.8, 2.5],
[0.5, 0.1, 2.2, 1.3]])
# 找到每行的最大值及其索引
_, predicted = torch.max(outputs, 1)
print("Predicted class indices:", predicted)
# Predicted class indices: tensor([3, 0, 2])
损失函数直接使用
print('损失函数直接使用')
loss = nn.CrossEntropyLoss()
Y= torch.tensor([0]) #这y是一行一列矩阵，但值0表示类别，如0=猫，1=狗，2=兔子
#nsamples x nclasses=1x3 1行3列
Y_pred_good = torch.tensor([[2.0,1.0, 0.1]]) # 这个预测的y里，2最大，2的索引是0.所以，这个预测的y最可能是猫
l1 = loss(Y_pred_good, Y)
print('输出损失精度的值',l1.item()) # 输出损失精度的值
torch.sum使用
print('torch.sum使用')
preds = torch.tensor([0, 1, 2, 1]) # 模型的预测
labels = torch.tensor([0, 1, 1, 1]) # 实际标签
preds == labels.data # 返回: tensor([True, True, False, True])
running_corrects = torch.sum(preds == labels.data) # 返回: 3（表示有 3 个预测正确）
print('计算当前批次的正确预测数量',running_corrects)
残差模型训练和使用
残差模型训练和使用的代码如下。
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
import numpy as np
import torchvision
from torchvision import datasets, models, transforms
import matplotlib.pyplot as plt
import time
import os
import copy
print('===========启动==========')
mean = np.array([0.5, 0.5, 0.5])
std = np.array([0.25, 0.25, 0.25])
data_transforms = {
'train': transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean, std)
]),
'val': transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean, std)
]),
}
data_dir = 'data/hymenoptera_data'
#导入图片
image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),
data_transforms[x])
for x in ['train', 'val']}
#图片导入进dataloader
dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4,
shuffle=True, num_workers=0)
for x in ['train', 'val']}
#取出图片的train和val文件夹下图片的数量
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
class_names = image_datasets['train'].classes
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print('标签名',class_names) #class_names ['ants', 'bees']
print('train-dataset_sizes',dataset_sizes['train']) #train-dataset_sizes 244
print('val-dataset_sizes',dataset_sizes['val']) #val-dataset_sizes 153
def imshow(inp, title):
"""Imshow for Tensor."""
inp = inp.numpy().transpose((1, 2, 0))
inp = std * inp + mean
inp = np.clip(inp, 0, 1)
plt.imshow(inp)
plt.title(title)
plt.show()
# Get a batch of training data
#next等价于 dataiter = iter(dataloaders['train']) inputs, classes =dataiter.__next__()
inputs, classes = next(iter(dataloaders['train']))
print("inputs.shape",inputs.shape)
# Make a grid from batch
out = torchvision.utils.make_grid(inputs)
imshow(out, title=[class_names[x] for x in classes])
def train_model(model, criterion, optimizer, scheduler, num_epochs=25):
since = time.time()
# model.state_dict()返回的是 模型的参数（权重和偏置） 的集合
best_model_wts = copy.deepcopy(model.state_dict())
best_acc = 0.0
for epoch in range(num_epochs):
print('Epoch {}/{}'.format(epoch, num_epochs - 1))
print('-' * 10)
# Each epoch has a training and validation phase
for phase in ['train', 'val']:
if phase == 'train':
model.train() # Set model to training mode resnet18的模型开启【训练】模式
else:
model.eval() # Set model to evaluate mode resnet18的模型开启【评估】模式
running_loss = 0.0
running_corrects = 0
# Iterate over data.
for inputs, labels in dataloaders[phase]:
inputs = inputs.to(device)
labels = labels.to(device)
print("inputs.shape",inputs.shape) # inputs.shape torch.Size([4, 3, 224, 224])
# track history if only in train
# set_grad_enabled是个类，不是函数，构造函数入参是ture，所以使用phase == 'train'传参
# 用途是开启梯度计算，是通过改变全局的tensor的requires_grad属性来实现的
with torch.set_grad_enabled(phase == 'train'):
# forward——前向传播
outputs = model(inputs)
print("outputs.shape",outputs.shape)
# 设置model的最后的全连接层是model.fc = nn.Linear(num_ftrs, 2)，outputs输出的2列
# outputs输出的2列是 logits(原始得分)，它是指经过神经网络最后一层计算后得到的值，但这些值并没有经过任何激活函数（如 Softmax 或 Sigmoid）的归一化处理。
# torch.max(outputs, 1) 会在 outputs 的每一行中找到最大值的索引。然后组层新的张量
_, preds = torch.max(outputs, 1)
print("predictions.shape", preds.shape) #predictions.shape torch.Size([4]),因为1批是4个，所以这个是个4行1列的数组，没一行代表logits(原始得分)最高的索引，即他是哪个类别
loss = criterion(outputs, labels)
# backward + optimize only if in training phase
if phase == 'train':
optimizer.zero_grad()
loss.backward()
optimizer.step()
# loss.item()=损失值
# inputs.size(0)返回inputs 的第一个维度的大小，这里inputs.size(0)=4,因为dataloaders定义的时候batch=4，所以使用next取值的时候，一组（一批）就是4个（图片）
# running_loss=批次的总损失
running_loss += loss.item() * inputs.size(0)
print('计算批次的总损失',running_loss)
# 计算当前批次的正确预测数量
running_corrects += torch.sum(preds == labels.data)
print('计算当前批次的正确预测数量',running_corrects)
if phase == 'train':
scheduler.step()
# epoch_loss=训练模型中的平均损失，epoch_loss反映了模型在整个训练或验证阶段的学习效果。通常，训练过程中的损失应该逐渐减小，表明模型在逐渐学习并减少错误。
# dataset_sizes[phase]=样本总数（train的dataset_sizes=244，val的dataset_sizes=153）
epoch_loss = running_loss / dataset_sizes[phase] # 平均损失
# 准确率越高，表示模型在分类任务中的表现越好
epoch_acc = running_corrects.double() / dataset_sizes[phase] # 平均准确率
print('{} Loss: {:.4f} Acc: {:.4f}'.format( phase, epoch_loss, epoch_acc))
# 当验证准确率超过历史最优时，更新权重和偏置
if phase == 'val' and epoch_acc > best_acc:
best_acc = epoch_acc
best_model_wts = copy.deepcopy(model.state_dict())
print()
time_elapsed = time.time() - since
print('Training complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
print('Best val Acc: {:4f}'.format(best_acc))
# load best model weights
# 重新导入权重和偏置
model.load_state_dict(best_model_wts)
return model
# ==============================================================================================================================
# 完整地加载了预训练的 ResNet-18，并且 所有的参数都是可训练的。
#### Finetuning the convnet ####
# Load a pretrained model and reset final fully connected layer.
# 创建一个预训ResNet-18 模型 ImageNet 数据集 上预训练过的 ResNet-18 模型
# ResNet-18 在 ImageNet 数据集上进行了训练，ImageNet 是一个包含 1000 个类别、约 120 万张图像的大型视觉分类数据集。（Microsoft Research 的研究团队训练的）
model = models.resnet18(pretrained=True)
#fc 是最后一个全连接层（Fully Connected Layer）。
#对于 ResNet-18 来说，fc 层的输入特征数是 512，这是因为在 ResNet-18 中，最后一个卷积层的输出经过全局平均池化（Global Average Pooling）后，输出了一个大小为 512 的特征向量。因此，in_features 是 512。
num_ftrs = model.fc.in_features
# Here the size of each output sample is set to 2.
# Alternatively, it can be generalized to nn.Linear(num_ftrs, len(class_names)).
model.fc = nn.Linear(num_ftrs, 2)
# *** 上面几行是把resnet-18里最后一个全连接层重新定义一下，因为原来的输出列数，不是我们需要的，我们就需要蜜蜂和蚂蚁俩类别，所以，我们输出是2，输入我们不知道，所以要先取出来最后一个全连接层，然后读取他的输入列。
model = model.to(device) #移动到设备上计算，有gpu用gpu计算，没有用cpu计算
criterion = nn.CrossEntropyLoss() #交叉熵损失函数
# Observe that all parameters are being optimized
optimizer = optim.SGD(model.parameters(), lr=0.001)
# StepLR Decays the learning rate of each parameter group by gamma every step_size epochs
# Decay LR by a factor of 0.1 every 7 epochs
# Learning rate scheduling should be applied after optimizer’s update
# e.g., you should write your code this way:
# for epoch in range(100):
# train(...)
# validate(...)
# scheduler.step()
# lr_scheduler.StepLR：是 PyTorch 中的一种学习率调度器，它可以在训练过程中动态调整学习率。
# optimizer：传入需要调节学习率的优化器。
# step_size=7：每训练 7 个 epoch 后，学习率将被调整。
# gamma=0.1：每次调整时，学习率将乘以 0.1，即每 7 个 epoch 后，学习率减少 10%。
# 就是在优化七次后，在将学习率乘以0.1
step_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)
# train_model是个函数，内部会读取图片训练
model = train_model(model, criterion, optimizer, step_lr_scheduler, num_epochs=25)
# ==============================================================================================================================
# 冻结卷积层通常是因为你希望利用 预训练的卷积特征（已经从大数据集上训练过），而只希望通过训练 全连接层 来适应你的特定任务。
#### ConvNet as fixed feature extractor ####
# Here, we need to freeze all the network except the final layer.
# We need to set requires_grad == False to freeze the parameters so that the gradients are not computed in backward()
model_conv = torchvision.models.resnet18(pretrained=True)
for param in model_conv.parameters():
param.requires_grad = False
# Parameters of newly constructed modules have requires_grad=True by default
num_ftrs = model_conv.fc.in_features
model_conv.fc = nn.Linear(num_ftrs, 2)
model_conv = model_conv.to(device)
criterion = nn.CrossEntropyLoss()
# Observe that only parameters of final layer are being optimized as
# opposed to before.
optimizer_conv = optim.SGD(model_conv.fc.parameters(), lr=0.001, momentum=0.9)
# Decay LR by a factor of 0.1 every 7 epochs
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_conv, step_size=7, gamma=0.1)
model_conv = train_model(model_conv, criterion, optimizer_conv,
exp_lr_scheduler, num_epochs=25)
这段代码还是比较难理解，不过如果理解了，那就基本上证明，前面的神经网络和卷积神经网络你都掌握了。
这样我们迁移学习——残差网络就学完了。
传送门：
零基础学习人工智能—Python—Pytorch学习—全集
注：此文章为原创，任何形式的转载都请联系作者获得授权并注明出处！
若您觉得这篇文章还不错，请点击下方的【推荐】，非常感谢！