前言

本文的内容是来自教程视频的第十五集，个人感觉，这个教程是有点虎头蛇尾，就是前面开始的教程，是非常惊人的好，但到这里，就有点水了，可以说就是把代码一铺，然后简单介绍一遍，很多细节都没有讲，所以，我在学习的时候，也是没办法从视频中直接学习，要先自学了代码后，再看的视频教程.

概念

前面已经解释了神经网络和卷积神经网络，本文要介绍残差网络。在学习之前，我们要先学习几个概念.

迁移学习 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学习—全集 。

---

注：此文章为原创，任何形式的转载都请联系作者获得授权并注明出处！ 。

---

---

若您觉得这篇文章还不错，请点击下方的【推荐】，非常感谢！ 。

https://www.cnblogs.com/kiba/p/18572640 。

最后此篇关于零基础学习人工智能—Python—Pytorch学习（十）的文章就讲到这里了,如果你想了解更多关于零基础学习人工智能—Python—Pytorch学习（十）的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。