本文介绍了一个使用PyTorch框架构建的卷积神经网络（CNN），用于识别鞋类图像。该项目包含数据预处理、模型构建、训练和测试等环节，并对关键的nn.BatchNorm2d()函数进行了深入探讨，理解其在稳定网络性能中的作用。项目结构清晰，代码实现简洁，有助于理解CNN在图像识别领域的应用。

⚙️ 项目采用Python 3.10环境，PyCharm作为编译器，Pytorch作为深度学习框架，构建CNN模型。

📁 项目结构包括utils.py（数据预处理）、model.py（CNN模型定义）、config.py（配置参数）、main.py（训练和测试主程序）以及预测脚本。

📈 在main.py中，使用ImageFolder加载鞋类数据集，进行数据增强，定义了CNN模型结构，包括卷积层、批归一化层、ReLU激活函数、池化层和全连接层，并使用交叉熵损失函数和SGD优化器进行训练。

🔬 总结部分详细阐述了nn.BatchNorm2d()的作用和原理，强调其通过归一化处理来稳定网络训练，避免因数据过大导致性能不稳定的问题。

具体实现

（一）环境

语言环境：Python 3.10

编 译 器: PyCharm

框 架: Pytorch

（二）具体步骤

时间关系，代码很差......

1. utils.py

针对数据文件的目录情况进行了优化

import torch  import pathlib  import matplotlib.pyplot as plt  from torchvision.transforms import transforms      # 第一步：设置GPU  def USE_GPU():      if torch.cuda.is_available():          print('CUDA is available, will use GPU')          device = torch.device("cuda")      else:          print('CUDA is not available. Will use CPU')          device = torch.device("cpu")        return device    temp_dict = dict()  def recursive_iterate(path):      """      根据所提供的路径遍历该路径下的所有子目录，列出所有子目录下的文件      :param path: 路径      :return: 返回最后一级目录的数据      """    path = pathlib.Path(path)      for file in path.iterdir():          if file.is_file():              temp_key = str(file).split('\\')[-2]              if temp_key in temp_dict:                  temp_dict.update({temp_key: temp_dict[temp_key] + 1})              else:                  temp_dict.update({temp_key: 1})              # print(file)          elif file.is_dir():              recursive_iterate(file)        return temp_dict      def data_from_directory(directory, train_dir=None, test_dir=None, show=False):      """      提供是的数据集是文件形式的，提供目录方式导入数据，简单分析数据并返回数据分类      :param test_dir: 是否设置了测试集目录      :param train_dir: 是否设置了训练集目录      :param directory: 数据集所在目录      :param show: 是否需要以柱状图形式显示数据分类情况,默认显示      :return: 数据分类列表,类型: list      """    global total_image      print("数据目录：{}".format(directory))      data_dir = pathlib.Path(directory)        # for d in data_dir.glob('**/*'): # **/*通配符可以遍历所有子目录      #     if d.is_dir():      #         print(d)    class_name = []      total_image = 0      temp_sum = 0        if train_dir is None or test_dir is None:          data_path = list(data_dir.glob('*'))          class_name = [str(path).split('\\')[-1] for path in data_path]          print("数据分类: {}, 类别数量：{}".format(class_name, len(list(data_dir.glob('*')))))          total_image = len(list(data_dir.glob('*/*')))          print("图片数据总数: {}".format(total_image))      else:          temp_dict.clear()          train_data_path = directory + '/' + train_dir          train_data_info = recursive_iterate(train_data_path)          print("{}目录:{},{}".format(train_dir, train_data_path, train_data_info))            temp_dict.clear()          test_data_path = directory + '/' + test_dir          print("{}目录:{},{}".format(test_dir,  test_data_path, recursive_iterate(test_data_path)))          class_name = temp_dict.keys()        if show:          # 隐藏警告          import warnings          warnings.filterwarnings("ignore")  # 忽略警告信息          plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签          plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号          plt.rcParams['figure.dpi'] = 100  # 分辨率            for i in class_name:              data = len(list(pathlib.Path((directory + '\\' + i + '\\')).glob('*')))              plt.title('数据分类情况')              plt.grid(ls='--', alpha=0.5)              plt.bar(i, data)              plt.text(i, data, str(data), ha='center', va='bottom')              print("类别-{}:{}".format(i, data))              temp_sum += data          plt.show()        if temp_sum == total_image:          print("图片数据总数检查一致")      else:          print("数据数据总数检查不一致，请检查数据集是否正确！")      return class_name      def get_transforms_setting(size):      """      获取transforms的初始设置      :param size: 图片大小      :return: transforms.compose设置      """    transform_setting = {          'train': transforms.Compose([              transforms.Resize(size),              transforms.ToTensor(),              transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])          ]),          'test': transforms.Compose([              transforms.Resize(size),              transforms.ToTensor(),              transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])          ])      }        return transform_setting

**2.**model.py

将CNN网络模板写到一个单独文件里，方便调用。

import torch.nn as nn  import torchimport torch.nn.functional as Fclass Model_Shoes(nn.Module):      def __init__(self, classNames):          super(Model_Shoes, self).__init__()          self.conv1 = nn.Sequential(              nn.Conv2d(3, 12, kernel_size=5, padding=0),  # 12*220*220              nn.BatchNorm2d(12),              nn.ReLU())            self.conv2 = nn.Sequential(              nn.Conv2d(12, 12, kernel_size=5, padding=0),  # 12*216*216              nn.BatchNorm2d(12),              nn.ReLU())            self.pool3 = nn.Sequential(              nn.MaxPool2d(2))  # 12*108*108            self.conv4 = nn.Sequential(              nn.Conv2d(12, 24, kernel_size=5, padding=0),  # 24*104*104              nn.BatchNorm2d(24),              nn.ReLU())            self.conv5 = nn.Sequential(              nn.Conv2d(24, 24, kernel_size=5, padding=0),  # 24*100*100              nn.BatchNorm2d(24),              nn.ReLU())            self.pool6 = nn.Sequential(              nn.MaxPool2d(2))  # 24*50*50            self.dropout = nn.Sequential(              nn.Dropout(0.2))            self.fc = nn.Sequential(              nn.Linear(24 * 50 * 50, len(classNames)))        def forward(self, x):          batch_size = x.size(0)          x = self.conv1(x)  # 卷积-BN-激活          x = self.conv2(x)  # 卷积-BN-激活          x = self.pool3(x)  # 池化          x = self.conv4(x)  # 卷积-BN-激活          x = self.conv5(x)  # 卷积-BN-激活          x = self.pool6(x)  # 池化          x = self.dropout(x)          x = x.view(batch_size, -1)  # flatten 变成全连接网络需要的输入 (batch, 24*50*50) ==> (batch, -1), -1 此处自动算出的是24*50*50          x = self.fc(x)            return x

3. config.py

将训练的相关参数写到config.py中

import argparse    def get_options(parser=argparse.ArgumentParser()):      parser.add_argument('--workers', type=int, default=0, help='Number of parallel workers')      parser.add_argument('--batch-size', type=int, default=32, help='input batch size, default=32')      parser.add_argument('--lr', type=float, default=1e-4, help='learning rate, default=0.0001')      parser.add_argument('--epochs', type=int, default=50, help='number of epochs')      parser.add_argument('--seed', type=int, default=112, help='random seed')      parser.add_argument('--save-path', type=str, default='./models/', help='path to save checkpoints')        opt = parser.parse_args()        if opt:          print(f'num_workers:{opt.workers}')          print(f'batch_size:{opt.batch_size}')          print(f'learn rate:{opt.lr}')          print(f'epochs:{opt.epochs}')          print(f'random seed:{opt.seed}')          print(f'save_path:{opt.save_path}')        return opt    if __name__ == '__main__':      opt = get_options()

**4. main.py

from torch import nn  from torchvision import datasets    from Utils import USE_GPU, data_from_directory, get_transforms_setting  import torch  import os, PIL, pathlib  from model import Model_Shoes    import config    opt = config.get_options()  print(opt)    device = USE_GPU()    DATA_DIR = "./data/shoes"  classNames = data_from_directory(DATA_DIR, train_dir="train", test_dir="test")  print(list(classNames))    transforms_setting = get_transforms_setting([224, 224])  train_dataset = datasets.ImageFolder(DATA_DIR + "/train", transforms_setting['train'])  test_dataset = datasets.ImageFolder(DATA_DIR + "/test", transforms_setting['test'])  print(train_dataset.class_to_idx)    batch_size = opt.batch_size  train_dl = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)  test_dl = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=True)    for X, y in test_dl:      print("Shape of X[N, C, H, W]：", X.shape)      print("Shape of y", y.shape, y.dtype)      break      model = Model_Shoes(classNames).to(device)  print(model)    # 训练循环  def train(dataloader, model, loss_fn, optimizer):      size = len(dataloader.dataset)  # 训练集的大小      num_batches = len(dataloader)  # 批次数目, (size/batch_size，向上取整)        train_loss, train_acc = 0, 0  # 初始化训练损失和正确率        for X, y in dataloader:  # 获取图片及其标签          X, y = X.to(device), y.to(device)            # 计算预测误差          pred = model(X)  # 网络输出          loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失            # 反向传播          optimizer.zero_grad()  # grad属性归零          loss.backward()  # 反向传播          optimizer.step()  # 每一步自动更新            # 记录acc与loss          train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()          train_loss += loss.item()        train_acc /= size      train_loss /= num_batches        return train_acc, train_loss      def test(dataloader, model, loss_fn):      size = len(dataloader.dataset)  # 测试集的大小      num_batches = len(dataloader)  # 批次数目, (size/batch_size，向上取整)      test_loss, test_acc = 0, 0        # 当不进行训练时，停止梯度更新，节省计算内存消耗      with torch.no_grad():          for imgs, target in dataloader:              imgs, target = imgs.to(device), target.to(device)                # 计算loss              target_pred = model(imgs)              loss = loss_fn(target_pred, target)                test_loss += loss.item()              test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()        test_acc /= size      test_loss /= num_batches        return test_acc, test_loss    def adjust_learning_rate(optimizer, epoch, start_lr):      # 每 2 个epoch衰减到原来的 0.92    lr = start_lr * (0.92 ** (epoch // 2))      for param_group in optimizer.param_groups:          param_group['lr'] = lr    learn_rate = opt.lr # 初始学习率  optimizer  = torch.optim.SGD(model.parameters(), lr=learn_rate)    loss_fn = nn.CrossEntropyLoss()  # 创建损失函数  epochs = opt.epochs    train_loss = []  train_acc = []  test_loss = []  test_acc = []    for epoch in range(epochs):      # 更新学习率（使用自定义学习率时使用）      adjust_learning_rate(optimizer, epoch, learn_rate)        model.train()      epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, optimizer)      # scheduler.step() # 更新学习率（调用官方动态学习率接口时使用）        model.eval()      epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)        train_acc.append(epoch_train_acc)      train_loss.append(epoch_train_loss)      test_acc.append(epoch_test_acc)      test_loss.append(epoch_test_loss)        # 获取当前的学习率      lr = optimizer.state_dict()['param_groups'][0]['lr']        template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')      print(template.format(epoch + 1, epoch_train_acc * 100, epoch_train_loss,                            epoch_test_acc * 100, epoch_test_loss, lr))  print('Done')    import matplotlib.pyplot as plt  #隐藏警告  import warnings  warnings.filterwarnings("ignore")               #忽略警告信息  plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签  plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号  plt.rcParams['figure.dpi']         = 100        #分辨率    epochs_range = range(epochs)    plt.figure(figsize=(12, 3))  plt.subplot(1, 2, 1)    plt.plot(epochs_range, train_acc, label='Training Accuracy')  plt.plot(epochs_range, test_acc, label='Test Accuracy')  plt.legend(loc='lower right')  plt.title('Training and Validation Accuracy')    plt.subplot(1, 2, 2)  plt.plot(epochs_range, train_loss, label='Training Loss')  plt.plot(epochs_range, test_loss, label='Test Loss')  plt.legend(loc='upper right')  plt.title('Training and Validation Loss')  plt.show()    # 模型保存  MODEL_SAVE_NAME = "cnn-shoes.pth"  torch.save(model.state_dict(), opt.save_path + MODEL_SAVE_NAME)

**5. 预测指定图片

import torch    from model import Model_Shoes  from Utils import USE_GPU, get_transforms_setting  from PIL import Image    from PIL import Image    device = USE_GPU()  transform_setting = get_transforms_setting([224, 224])    classes = ['adidas', 'nike']  model = Model_Shoes(classes)  model.load_state_dict(torch.load('./models/cnn-shoes.pth', map_location=device))  model.to(device)    def predict_one_image(image_path, model, transform, classes):      test_img = Image.open(image_path).convert('RGB')      # plt.imshow(test_img)  # 展示预测的图片        test_img = transform(test_img)      img = test_img.to(device).unsqueeze(0)        model.eval()      output = model(img)        _, pred = torch.max(output, 1)      pred_class = classes[pred]      print(f'预测结果是：{pred_class}')    # 预测训练集中的某张照片  predict_one_image(image_path='./mydata/shoes/1.png',                    model=model,                    transform=transform_setting['train'],                    classes=classes)

（三）总结

本次学习对于构建CNN网络中的 nn.BatchNorm2d(）做了初步的了解，nn.BatchNorm2d(）进行数据的归一化处理，这使得数据在进行Relu之前不会因为数据过大而导致网络性能的不稳定，BatchNorm2d()函数数学原理如下：BatchNorm2d()内部的参数如下：

1.num_features：一般输入参数为batch_sizenum_featuresheight*width，即为其中特征的数量

2.eps：分母中添加的一个值，目的是为了计算的稳定性，默认为：1e-5

3.momentum：一个用于运行过程中均值和方差的一个估计参数（我的理解是一个稳定系数，类似于SGD中的momentum的系数）

4.affine：当设为true时，会给定可以学习的系数矩阵gamma和beta参考链接：blog.csdn.net/bigFatCat_T…