零基础学习人工智能—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 = # 使用字典推导式将列表转为字典age_dict = {names: ages 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) 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) for x in ['train', 'val']}#图片导入进dataloadershuffle=True启用了数据洗牌dataloaders = {x: torch.utils.data.DataLoader(image_datasets, batch_size=4, shuffle=True, num_workers=0) for x in ['train', 'val']}#取出图片的train和val文件夹图片的数量dataset_sizes = {x: len(image_datasets) 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_idxprint('标签值',class_to_idx) # {'ants': 0, 'bees': 1}print('标签名',class_names) #['ants', 'bees']print('train-dataset_sizes',dataset_sizes['train']) #train-dataset_sizes 244print('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()# 显示这个网格图像# 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([, , ])# 找到每行的最大值及其索引_, predicted = torch.max(outputs, 1)print("Predicted class indices:", predicted)# Predicted class indices: tensor()损失函数直接使用
print('损失函数直接使用')loss = nn.CrossEntropyLoss()Y= torch.tensor() #这y是一行一列矩阵，但值0表示类别，如0=猫，1=狗，2=兔子#nsamples x nclasses=1x31行3列Y_pred_good = torch.tensor([]) # 这个预测的y里，2最大，2的索引是0.所以，这个预测的y最可能是猫 l1 = loss(Y_pred_good, Y) print('输出损失精度的值',l1.item()) # 输出损失精度的值torch.sum使用
print('torch.sum使用')preds = torch.tensor()# 模型的预测labels = torch.tensor()# 实际标签preds == labels.data# 返回: tensor() running_corrects = torch.sum(preds == labels.data)# 返回: 3（表示有 3 个预测正确）print('计算当前批次的正确预测数量',running_corrects)残差模型训练和使用
残差模型训练和使用的代码如下。
import torchimport torch.nn as nnimport torch.optim as optimfrom torch.optim import lr_schedulerimport numpy as npimport torchvisionfrom torchvision import datasets, models, transformsimport matplotlib.pyplot as pltimport timeimport osimport copyprint('===========启动==========')mean = np.array()std = np.array()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) for x in ['train', 'val']}#图片导入进dataloaderdataloaders = {x: torch.utils.data.DataLoader(image_datasets, batch_size=4, shuffle=True, num_workers=0) for x in ['train', 'val']}#取出图片的train和val文件夹下图片的数量dataset_sizes = {x: len(image_datasets) for x in ['train', 'val']}class_names = image_datasets['train'].classesdevice = 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 244print('val-dataset_sizes',dataset_sizes['val']) #val-dataset_sizes 153def 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 batchout = torchvision.utils.make_grid(inputs)imshow(out, title= 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: inputs = inputs.to(device) labels = labels.to(device) print("inputs.shape",inputs.shape) # inputs.shape torch.Size() # 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(),因为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=样本总数（train的dataset_sizes=244，val的dataset_sizes=153） epoch_loss = running_loss / dataset_sizes# 平均损失 # 准确率越高，表示模型在分类任务中的表现越好 epoch_acc = running_corrects.double() / dataset_sizes # 平均准确率 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 optimizedoptimizer = 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.1step_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 defaultnum_ftrs = model_conv.fc.in_featuresmodel_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 epochsexp_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)这段代码还是比较难理解，不过如果理解了，那就基本上证明，前面的神经网络和卷积神经网络你都掌握了。
<hr>这样我们迁移学习——残差网络就学完了。
<hr>传送门：
零基础学习人工智能—Python—Pytorch学习—全集
<hr>注：此文章为原创，任何形式的转载都请联系作者获得授权并注明出处！
<hr>
<hr>若您觉得这篇文章还不错，请点击下方的【推荐】，非常感谢！
https://www.cnblogs.com/kiba/p/18572640
页:
[1]