# 定义训练函数
def train_model(model, dataloaders, criterion, optimizer, mundde_epochs=25):
    since = time.time()  # 返回当前时间的时间戳（1970纪元后经过的浮点秒数）
    # state_dict变量存放训练过程中需要学习的权重和偏执系数，state_dict作为python的字典对象将每一层的参数映射成tensor张量，
    # 需要注意的是torch.nn.Module模块中的state_dict只包含卷积层和全连接层的参数
    best_model_wts = copy.deepcopy(model.state_dict())  # copy是一个复制函数
    best_acc = 0.0
    # 下面这个迭代就是一个进度条的输出，从0到9显示进度
    for epoch in range(num_epochs):
        print('Epoch {}/{}'.format(epoch, num_epochs - 1))
        print('-' * 10)
        # 下面这个迭代，范围就两个'train', 'val'，对应不执行不同的训练模式
        for phase in ['train', 'val']:

            if phase == 'train':
                model.train()
            else:
                model.eval()

            running_loss = 0.0
            running_corrects = 0.0


            for inputs, labels in dataloaders[phase]:
                # 下面这行代码的意思是将所有最开始读取数据时的tensor变量copy一份到device所指定的GPU或CPU上去，
                # 之后的运算都在GPU或CPU上进行
                inputs, labels = inputs.to(device), labels.to(device)

                optimizer.zero_grad()  # 模型梯度设为0

                # 接下来所有的tensor运算产生的新的节点都是不可求导的
                with torch.set_grad_enabled(phase == 'train'):
                    outputs = model(inputs)  # output等于把inputs放到指定设备上去运算
                    loss = criterion(outputs, labels)  # loss为outputs和labels的交叉熵损失
                    # 举例：output = torch.max(input, dim)
                    # 输入
                    # input是softmax函数输出的一个tensor
                    # dim是max函数索引的维度0 / 1，0是每列的最大值，1是每行的最大值
                    #  输出
                    # 函数会返回两个tensor，第一个tensor是每行的最大值，softmax的输出中最大的是1，所以第一个tensor是全1的tensor；
                    # 第二个tensor是每行最大值的索引。
                    _, preds = torch.max(outputs, 1)
                    if phase == 'train':
                        loss.backward()  # 反向传播计算得到每个参数的梯度值
                        optimizer.step()  # 通过梯度下降执行一步参数更新

                running_loss += loss.item() * inputs.size(0)
                running_corrects += (preds == labels).sum().item()
            epoch_loss = running_loss / len(dataloaders[phase].dataset)
            epoch_acc = running_corrects / len(dataloaders[phase].dataset)

            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))

    model.load_state_dict(best_model_wts)
    return model

继续往下看

# 定义优化器和损失函数
model = model.to(device)  # 前面解释过了
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
# optimizer = optim.Adam(model.classifier.parameters(), lr=0.0001)

# sched = optim.lr_scheduler.StepLR(optimizer, step_size=4, gamma=0.1)
criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数

optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9)
optimizer.zero_grad()
loss_fn(model(input), target).backward()
optimizer.step()  

params(iterable)：可用于迭代优化的参数或者定义参数组的dicts。
lr (float, optional) ：学习率(默认: 1e-3)
betas (Tuple[float, float], optional)：用于计算梯度的平均和平方的系数(默认: (0.9, 0.999))
eps (float, optional)：为了提高数值稳定性而添加到分母的一个项(默认: 1e-8)
weight_decay (float, optional)：权重衰减(如L2惩罚)(默认: 0)
step(closure=None)函数：执行单一的优化步骤
closure (callable, optional)：用于重新评估模型并返回损失的一个闭包