深度学习实战——卷积神经网络CNN在图片识别中的应用以及原理

一、前言

随着人工智能和深度学习技术的迅猛发展，卷积神经网络（Convolutional Neural Networks，CNN）已经成为计算机视觉领域中最为重要的工具之一。无论是在图像分类、目标检测，还是在人脸识别、自动驾驶等应用中，CNN都展现出了其卓越的表现和广泛的应用前景。

本文旨在通过深入的实战案例，带领读者一步步理解并掌握CNN的核心原理及其在图片识别中的应用。我们将通过实际操作和代码演示，帮助读者将理论与实践相结合，全面提升在深度学习方向上的技能，为解决复杂的图像处理问题打下坚实的基础。

二、实战

2.1 下载Jupyter Notebook

# 切换成你想要的环境，这里我是默认base环境。 conda activate base # 生成notebook的配置 jupyter notebook --generate-config # 把这个配置打开并调整成你需要打开的默认文件 c.NotebookApp.notebook_dir = '/path/to/your/directory' vim ~/.jupyter/jupyter_notebook_config.py jupyter notebook

2.2 导入需要用到的工具包

# os 模块提供了一系列与操作系统交互的功能 import os # Python 中非常流行的绘图库 Matplotlib 的一个子模块，用于创建各种类型的图表和可视化。 import matplotlib.pyplot as plt # 是一个 IPython 魔法命令（magic command），通常用于 Jupyter Notebook 中。它的作用是使得 Matplotlib 绘制的图表直接嵌入在 Notebook 的输出单元中，而不是弹出一个单独的窗口显示图表。 %matplotlib inline # NumPy 是用于数值计算的强大库，主要用于处理多维数组、矩阵操作，以及提供了大量数学函数和工具，特别适合科学计算和数据处理。 import numpy as np # torch 是一个用于深度学习的开源框架，由 Facebook 开发。PyTorch 具有强大的张量运算能力和自动微分功能，并且广泛应用于构建和训练神经网络模型，特别是在研究和生产中的深度学习任务中使用非常流行。 import torch # 构建神经网络的工具 from torch import nn # 导入 PyTorch 的优化器模块 torch.optim。该模块包含了多种优化算法，用于训练神经网络时更新模型的参数。常见的优化器包括随机梯度下降（SGD）、Adam、RMSprop 等。 import torch.optim as optim # 它是 PyTorch 生态系统的一部分，专门为计算机视觉任务提供了便捷的工具和数据集。Torchvision 包含了预训练模型、数据集、数据预处理和数据增强等常用功能 import torchvision # transforms 图像处理与数据增强模块，提供如裁剪、翻转、旋转、缩放等操作。 # models 提供多种经典的卷积神经网络架构，如 ResNet、VGG、AlexNet、MobileNet 等，且支持加载预训练模型。 # datasets 常见的数据集加载模块，支持的数据集包括 CIFAR-10、MNIST、COCO、ImageNet 等。 from torchvision import transforms, models, datasets # imageio 是一个用于读取和写入图像、视频、GIF 和其他多媒体文件的 Python 库，支持多种格式（如 PNG、JPEG、TIFF、GIF、MP4 等），并且具有简单易用的接口。 import imageio # 提供时间相关的功能，如获取当前时间、延迟执行等。 import time # 用于发出警告消息，通常用于提示用户程序的潜在问题或使用不推荐的功能。 import warnings # 提供生成随机数的功能，包括整型、浮点型随机数以及随机选择等。 import random # 提供对 Python 解释器和环境的访问，包括系统参数、模块路径等。 import sys # 提供浅拷贝和深拷贝的功能，用于复制对象。 import copy # 用于处理 JSON 数据的编码和解码。 import json # 提供对图像的操作功能，包括打开、保存、转换图像格式等。PIL（Python Imaging Library）现在被 Pillow 取代，Pillow 是 PIL 的一个分支并提供了相同的接口。 from PIL import Image

2.3 数据读取与预处理操作

# 获取当前工作目录 current_directory = os.getcwd() # 使用相对路径拼接文件路径 relative_path = 'flower_data/' data_dir = os.path.join(current_directory, relative_path) train_dir = data_dir + '/train' valid_dir = data_dir + '/valid'

2.4 制作好数据源

data_transforms中指定了所有图像预处理操作ImageFolder假设所有的文件按文件夹保存好，每个文件夹下面存贮同一类别的图片，文件夹的名字为分类的名字。 data_transforms = { 'train': transforms.Compose([transforms.RandomRotation(45),#随机旋转，-45到45度之间随机选 transforms.CenterCrop(224),#从中心开始裁剪 transforms.RandomHorizontalFlip(p=0.5),#随机水平翻转 选择一个概率概率 transforms.RandomVerticalFlip(p=0.5),#随机垂直翻转 transforms.ColorJitter(brightness=0.2, contrast=0.1, saturation=0.1, hue=0.1),#参数1为亮度，参数2为对比度，参数3为饱和度，参数4为色相 transforms.RandomGrayscale(p=0.025),#概率转换成灰度率，3通道就是R=G=B transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])#均值，标准差 ]), 'valid': transforms.Compose([transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), } batch_size = 8 image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x]) for x in ['train', 'valid']} dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True) for x in ['train', 'valid']} dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'valid']} class_names = image_datasets['train'].classes

可以看看他们的结果集：

2.5 读取标签对应的实际名字

current_directory = os.getcwd() relative_path = 'cat_to_name.json' file_path = os.path.join(current_directory, relative_path) with open(file_path, 'r') as f: cat_to_name = json.load(f)

2.6 展示下数据

注意tensor的数据需要转换成numpy的格式，而且还需要还原回标准化的结果。 def im_convert(tensor): """ 将 Tensor 转换为可展示的图像 """ # 将 Tensor 转到 CPU 并复制一份，同时切断与计算图的关系 image = tensor.to("cpu").clone().detach() # 转换为 NumPy 数组并去掉批次维度 image = image.numpy().squeeze() # 转置维度以匹配 (H, W, C) 格式 image = image.transpose(1,2,0) # 反归一化图像 image = image * np.array((0.229, 0.224, 0.225)) + np.array((0.485, 0.456, 0.406)) # 将像素值限制在 [0, 1] 之间 image = image.clip(0, 1) return image

为了创建一个包含 8 张图像（2 行 4 列）的网格，显示从 dataloaders[‘valid’] 中获取的图像， 并在每个图像上方显示相应的标题。这是常用于深度学习中的数据可视化步骤，比如在 PyTorch 中查看图像和对应的分类标签。

# 创建一个图像，大小为 20x12 英寸 fig=plt.figure(figsize=(20, 12)) # 设置列数为 4 columns = 4 # 设置行数为 2 rows = 2 # 获取数据加载器的迭代器 dataiter = iter(dataloaders['valid']) # 获取下一批数据 (inputs 是图像, classes 是对应的标签) inputs, classes = dataiter.next() # 共8张图片 for idx in range (columns*rows): # 创建子图 ax = fig.add_subplot(rows, columns, idx+1, xticks=[], yticks=[]) # 设置子图的标题为类别名称 ax.set_title(cat_to_name[str(int(class_names[classes[idx]]))]) # 显示图像 plt.imshow(im_convert(inputs[idx])) # 显示整个图像 plt.show()

跑一下结果：

2.7 加载models中提供的模型，并且直接用训练好的权重当做初始化参数

第一次执行需要下载，可能会比较慢，我会提供给大家一份下载好的，可以直接放到相应路径 # 可选的比较多 ['resnet', 'alexnet', 'vgg', 'squeezenet', 'densenet', 'inception'] model_name = 'resnet' # 是否用人家训练好的特征来做 feature_extract = True # 是否用GPU训练 train_on_gpu = torch.cuda.is_available() if not train_on_gpu: print('CUDA is not available. Training on CPU ...') else: print('CUDA is available! Training on GPU ...') device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

set_parameter_requires_grad 函数用于设置模型的参数是否需要计算梯度，通常用于迁移学习中的 特征提取（feature extraction）。如果 feature_extracting 参数为 True，函数会将模型的所有参数的 requires_grad 属性设为 False，意味着这些参数在反向传播时不会被更新。

def set_parameter_requires_grad(model, feature_extracting): if feature_extracting: for param in model.parameters(): param.requires_grad = False

使用场景：

当你做迁移学习时，如果你只想更新模型的最后几层，而保持其他层的权重不变，可以使用这个函数将不需要更新的层冻结。例如在使用预训练的卷积神经网络（如 ResNet）进行图像分类时，常会冻结卷积层，只更新最后的全连接层。

老周这里在 CPU 上训练深度学习模型，尤其是像 ResNet-152 这样的大型模型，速度会非常慢，因为 ResNet-152 是一个非常深的网络，有 152 层卷积层和残差块，非常适合在 GPU 上运行。而 CPU 在处理深度神经网络时，特别是在大型数据集和复杂模型上，性能会明显下降。我这里选择 ResNet-18。

参数量：约 11M 参数。特点：相比 ResNet-152，ResNet-18 要浅很多，只有 18 层，但依然保留了 ResNet 的优点——残差连接结构。如果你需要一个比 ResNet-152 更轻量的网络，并且愿意牺牲部分性能，ResNet-18 是一个不错的选择。使用场景：小型数据集或需要在 CPU 上训练的场景。 model_ft = models.resnet18() model_ft

2.8 参考pytorch官网例子

根据指定的模型名称初始化不同的预训练模型，同时可以选择是否进行特征提取（即冻结部分参数）和更改最后的分类层，以适应不同的分类任务。这个函数涵盖了多种经典的卷积神经网络架构，比如 ResNet、AlexNet、VGG、SqueezeNet、DenseNet 和 Inception。

def initialize_model(model_name, num_classes, feature_extract, use_pretrained=True): # 选择合适的模型，不同模型的初始化方法稍微有点区别 model_ft = None input_size = 0 # Resnet152 if model_name == "resnet": model_ft = models.resnet152(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Sequential(nn.Linear(num_ftrs, 102), nn.LogSoftmax(dim=1)) input_size = 224 # Alexnet elif model_name == "alexnet": model_ft = models.alexnet(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes) input_size = 224 # VGG11_bn elif model_name == "vgg": model_ft = models.vgg16(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes) input_size = 224 # Squeezenet elif model_name == "squeezenet": model_ft = models.squeezenet1_0(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) model_ft.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1,1), stride=(1,1)) model_ft.num_classes = num_classes input_size = 224 # Densenet elif model_name == "densenet": model_ft = models.densenet121(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, num_classes) input_size = 224 # Inception v3 （Be careful, expects (299,299) sized images and has auxiliary output） elif model_name == "inception": model_ft = models.inception_v3(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) # Handle the auxilary net num_ftrs = model_ft.AuxLogits.fc.in_features model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes) # Handle the primary net num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs,num_classes) input_size = 299 else: print("Invalid model name, exiting...") exit() return model_ft, input_size

2.9 设置哪些层需要训练

# 初始化模型 model_ft, input_size = initialize_model(model_name, 102, feature_extract, use_pretrained=True) # GPU计算 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model_ft = model_ft.to(device) # 设置要训练的参数 params_to_update = model_ft.parameters() print("Params to learn:") # 如果 feature_extract=True，意味着你只会训练最后的分类层，之前的层保持冻结，避免更新权重。 if feature_extract: params_to_update = [] for name, param in model_ft.named_parameters(): if param.requires_grad: params_to_update.append(param) print("\t", name) # 如果 feature_extract=False，则意味着你希望训练所有层，因此无需修改 params_to_update。 else: for name, param in model_ft.named_parameters(): if param.requires_grad: print("\t", name)

2.10 优化器设置

# 优化器设置（使用 Adam 优化器，并设置了较高的学习率 1e-2） optimizer_ft = optim.Adam(params_to_update, lr=1e-2) # 学习率调度器（用了 StepLR 学习率调度器，每 7 个 epoch 后学习率衰减到原来的 1/10。） # 这种策略有助于在训练过程中逐步减小学习率，防止过拟合，同时也能让模型更稳定地收敛。 scheduler = optim.lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1) # 最后一层已经LogSoftmax()了，所以不能nn.CrossEntropyLoss()来计算了，nn.CrossEntropyLoss()相当于logSoftmax()和nn.NLLLoss()整合 # 这是针对对数概率分布的负对数似然损失函数： criterion = nn.NLLLoss()

2.11 训练模块

def train_model(model, dataloaders, criterion, optimizer, num_epochs=25, is_inception=False,filename=filename): since = time.time() best_acc = 0 """ checkpoint = torch.load(filename) best_acc = checkpoint['best_acc'] model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) model.class_to_idx = checkpoint['mapping'] """ model.to(device) val_acc_history = [] train_acc_history = [] train_losses = [] valid_losses = [] LRs = [optimizer.param_groups[0]['lr']] best_model_wts = copy.deepcopy(model.state_dict()) for epoch in range(num_epochs): print('Epoch {}/{}'.format(epoch, num_epochs - 1)) print('-' * 10) # 训练和验证 for phase in ['train', 'valid']: if phase == 'train': model.train() # 训练 else: model.eval() # 验证 running_loss = 0.0 running_corrects = 0 # 把数据都取个遍 for inputs, labels in dataloaders[phase]: inputs = inputs.to(device) labels = labels.to(device) # 清零 optimizer.zero_grad() # 只有训练的时候计算和更新梯度 with torch.set_grad_enabled(phase == 'train'): if is_inception and phase == 'train': outputs, aux_outputs = model(inputs) loss1 = criterion(outputs, labels) loss2 = criterion(aux_outputs, labels) loss = loss1 + 0.4*loss2 # resnet执行的是这里 else: outputs = model(inputs) loss = criterion(outputs, labels) _, preds = torch.max(outputs, 1) # 训练阶段更新权重 if phase == 'train': loss.backward() optimizer.step() # 计算损失 running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) epoch_loss = running_loss / len(dataloaders[phase].dataset) epoch_acc = running_corrects.double() / len(dataloaders[phase].dataset) time_elapsed = time.time() - since print('Time elapsed {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60)) print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc)) # 得到最好那次的模型 if phase == 'valid' and epoch_acc > best_acc: best_acc = epoch_acc best_model_wts = copy.deepcopy(model.state_dict()) state = { 'state_dict': model.state_dict(), 'best_acc': best_acc, 'optimizer' : optimizer.state_dict(), } torch.save(state, filename) if phase == 'valid': val_acc_history.append(epoch_acc) valid_losses.append(epoch_loss) scheduler.step(epoch_loss) if phase == 'train': train_acc_history.append(epoch_acc) train_losses.append(epoch_loss) print('Optimizer learning rate : {:.7f}'.format(optimizer.param_groups[0]['lr'])) LRs.append(optimizer.param_groups[0]['lr']) 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)) # 训练完后用最好的一次当做模型最终的结果 model.load_state_dict(best_model_wts) return model, val_acc_history, train_acc_history, valid_losses, train_losses, LRs

2.12 开始训练

model_ft, val_acc_history, train_acc_history, valid_losses, train_losses, LRs = train_model(model_ft, dataloaders, criterion, optimizer_ft, num_epochs=20, is_inception=(model_name=="inception"))

两轮Epoch花了1个多钟，因为我这里是CPU训练的，比较慢。我这里调整下num_epochs为2.

2.13 再继续训练所有层

for param in model_ft.parameters(): param.requires_grad = True # 再继续训练所有的参数，学习率调小一点 optimizer = optim.Adam(params_to_update, lr=1e-4) # # 确保optimizer使用的是所有参数 scheduler = optim.lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1) # 损失函数，确保最后一层是 LogSoftmax criterion = nn.NLLLoss() # 加载检查点 checkpoint = torch.load(filename) # 恢复最好的验证准确率 best_acc = checkpoint['best_acc'] # 恢复模型的状态字典 model_ft.load_state_dict(checkpoint['state_dict']) # 恢复优化器的状态字典 optimizer.load_state_dict(checkpoint['optimizer']) model_ft, val_acc_history, train_acc_history, valid_losses, train_losses, LRs = train_model(model_ft, dataloaders, criterion, optimizer, num_epochs=2, is_inception=(model_name=="inception"))

2.14 加载训练好的模型

# 初始化模型 model_ft, input_size = initialize_model(model_name, 102, feature_extract, use_pretrained=True) # GPU模式 model_ft = model_ft.to(device) # 保存文件的名字 filename = 'checkpoint.pth' # 加载模型 checkpoint = torch.load(filename) # 恢复最好的验证准确率 best_acc = checkpoint['best_acc'] # 加载模型权重 model_ft.load_state_dict(checkpoint['state_dict'])

2.15 测试数据预处理

测试数据处理方法需要跟训练时一致才可以crop操作的目的是保证输入的大小是一致的标准化操作也是必须的，用跟训练数据相同的mean和std,但是需要注意一点训练数据是在0-1上进行标准化，所以测试数据也需要先归一化最后一点，PyTorch中颜色通道是第一个维度，跟很多工具包都不一样，需要转换 def process_image(image_path): # 读取测试数据 img = Image.open(image_path) # Resize,thumbnail方法只能进行缩小，所以进行了判断 if img.size[0] > img.size[1]: img.thumbnail((10000, 256)) else: img.thumbnail((256, 10000)) # Crop操作 left_margin = (img.width-224)/2 bottom_margin = (img.height-224)/2 right_margin = left_margin + 224 top_margin = bottom_margin + 224 img = img.crop((left_margin, bottom_margin, right_margin, top_margin)) # 相同的预处理方法 img = np.array(img)/255 mean = np.array([0.485, 0.456, 0.406]) #provided mean std = np.array([0.229, 0.224, 0.225]) #provided std img = (img - mean)/std # 注意颜色通道应该放在第一个位置 img = img.transpose((2, 0, 1)) return img def imshow(image, ax=None, title=None): """展示数据""" if ax is None: fig, ax = plt.subplots() # 颜色通道还原 (H, W, C) image = np.array(image).transpose((1, 2, 0)) # 预处理还原（反向标准化） mean = np.array([0.485, 0.456, 0.406]) std = np.array([0.229, 0.224, 0.225]) image = std * image + mean # 确保数值在 [0, 1] 之间 image = np.clip(image, 0, 1) # 显示图像 ax.imshow(image) ax.set_title(title) # 隐藏坐标轴 ax.axis('off') return ax image_path = 'image_06621.jpg' img = process_image(image_path) imshow(img)

# 从验证集获取一个batch的数据 dataiter = iter(dataloaders['valid']) images, labels = next(dataiter) # 模型切换到评估模式 model_ft.eval() # 将输入传到模型 if train_on_gpu: # 如果在GPU上训练，输入数据也要搬到GPU上 output = model_ft(images.cuda()) else: output = model_ft(images)

output表示对一个batch中每一个数据得到其属于各个类别的可能性

output.shape torch.Size([2, 102])

2.16 得到概率最大的那个

# 获取预测的类别索引 _, preds_tensor = torch.max(output, 1) # 将张量移回 CPU 并转换为 NumPy 数组 if train_on_gpu: preds = preds_tensor.cpu().numpy() else: preds = preds_tensor.numpy() # 使用 np.squeeze() 去掉单个批次维度（将预测的结果去掉单一维度，保持数据维度的整洁。） preds = np.squeeze(preds) # 打印预测 print(preds) [71 89]

2.17 展示预测结果

fig = plt.figure(figsize=(20, 20)) columns = 2 rows = 1 for idx in range(columns * rows): ax = fig.add_subplot(rows, columns, idx+1, xticks=[], yticks=[]) # 显示图像 plt.imshow(im_convert(images[idx])) # 获取预测类别和真实类别的名称 pred_label = cat_to_name[str(preds[idx])] true_label = cat_to_name[str(labels[idx].item())] # 设置标题，颜色标记是否正确 ax.set_title("{} ({})".format(pred_label, true_label), color=("green" if pred_label == true_label else "red")) plt.show()

2.18 小结

可以看出上诉两张图片识别错误，这也很正常，老周这里只跑了两个批次batch_size，训练所有层的时候我把num_epochs=20调整成2，调整成2都跑了3个钟，所以训练模型还得拿GPU来跑！！！

三、论文解读

上诉代码可以看出，老周这里用的是resnet18的一个网络模型，只有18层，因为我这里用的CPU跑的，层数太深我这边跑不动，需要换GPU。

看其它网络模型，给我的直观感觉就是层数越多表现的效果越好，卷积越多越好吗？不一定，我们还是来看下论文里实践跑的效果。

论文地址：Deep Residual Learning for Image Recognition

可以看出，红色线是一个56层的网络，黄色线是一个20层的网络，从20层延伸到56层我们可以看到无论是 training error、test error，20层的都比56层的要好。所以，在神经网络当中，越深的神经网络没有我们想象的那么好，即网络层数也不能无限做深下去。我能不能把网络层数做多一些并且效果还很好的，这样网络层数更多并且效果要比浅层神经网络更好是我们的目标，那下面来看看作者是怎么设计的？

我们可以看到经过了一个卷积以后得到了一个结果，右边还有一条线直接拿过来。刚才我们上面说了卷积神经网络层数越多效果可能不好，在越多的时候其中那两层可能效果不好，右边那个直接拿过来就是以防那两层卷积效果不好，再不好的情况下直接拿上一层的效果最好的值。理解了这一点，我们再来看整体架构就简单了。

VGG-19我们就不看，我们来对比 34-layer plain（正常网络） 和 34-layer residua（残差网络），感觉没啥区别，参数都是一致的，但是右边的那个传参网络多了一条一条线，在整个神经网络中都加上一个个的小模块，每一层都是通过一个小模块相连的，这样的话就保证了一点，网络架构不会比原来更差的。不知道你有没有注意到，不同颜色连接处是用虚线连接的，不通颜色之间有啥不同？显而易见是特征图的个数不一样，虚线的作用就是做了一个1×1的卷积（把我们的特征图的个数进行翻倍）。

结论：右边残差网络34层比18层效果要更好，左边的普通网络没有呈现34层比18层效果要更好的趋势。

四、Resnet网络架构

从左到右看，input输入数据，再到ZERO PAD，也就是边缘上加几层0，让边界点利用的更加充分。我们再看stage 1,conv、Batch Norm、ReLU、MAX POOL，总之进行正常的卷积池化操作。主要来看下stage2（3、4、5一样），这些就是上面论文中介绍的一个模块，这一个个模块做了残差网络当中最核心的计算。

蓝色的是卷积模块，红色的是映射模块。如下图：

这里解释下identity_block模块，输入的特征图的大小以及个数（如：[32,32,64]）与下面经过了三次卷积完成之后的特征图的大小以及个数（如：[32,32,64]）要一致，这样才能进行相加操作。

我们再来看convolution_block模块，如果一直让特征图保持一样，那特征就没那么丰富了。比如第一个是[32,32,64]，第二个是[32,32,64]，第三个是[32,32,256]，那要想进行相加，上面那条线就得进行[1,1,256]的卷积得到[32,32,256]，这样才能和下面第三个的[32,32,256]进行相加。

理解了这两个模块，那残差网络架构的核心你也就知道了。