这个函数接收数据加载器、模型、损失函数作为参数。它使用AverageMeter和ProgressMeter来监控和报告验证过程中的时间、损失和精度。模型被设置为评估模式（model.eval()），禁用梯度计算以节省内存和加速处理（with torch.no_grad():）。遍历验证集的每一个批次，计算模型的输出和损失，更新精度和损失的统计数据。计算每个批次的耗时并更新时间计量器。最终，函数返回验证集上的平均精度。

predict 函数

这个函数用于模型预测，特别是在测试集上。它也接收数据加载器和模型作为参数，并可选地接受一个tta参数，即测试时增强（Test Time Augmentation）的次数。模型同样被设置为评估模式。对于每一次增强，遍历测试集的所有批次，计算模型的输出，并应用softmax函数以获得概率分布。输出结果被累积，最终返回平均预测结果。

train 函数

这个函数用于模型的训练过程，接收训练数据加载器、模型、损失函数、优化器和当前训练轮次作为参数。它同样使用AverageMeter和ProgressMeter来监控训练过程中的时间、损失和精度。模型被设置为训练模式（model.train()），允许模型内部的如dropout和BN层正常工作。遍历训练集的每一个批次，计算模型的输出和损失，更新精度和损失的统计数据。计算梯度，执行优化器的参数更新步骤（optimizer.step()）。计算每个批次的耗时并更新时间计量器。每100个批次，使用ProgressMeter打印当前的训练状态。

三个函数的对应代码：

def validate(val_loader, model, criterion):

batch_time = AverageMeter('Time', ':6.3f')

losses = AverageMeter('Loss', ':.4e')

top1 = AverageMeter('Acc@1', ':6.2f')

progress = ProgressMeter(len(val_loader), batch_time, losses, top1)

# switch to evaluate mode

model.eval()

with torch.no_grad():

end = time.time()

for i, (input, target) in tqdm_notebook(enumerate(val_loader), total=len(val_loader)):

input = input.cuda()

target = target.cuda()

# compute output

output = model(input)

loss = criterion(output, target)

# measure accuracy and record loss

acc = (output.argmax(1).view(-1) == target.float().view(-1)).float().mean() * 100

losses.update(loss.item(), input.size(0))

top1.update(acc, input.size(0))

# measure elapsed time

batch_time.update(time.time() - end)

end = time.time()

# TODO: this should also be done with the ProgressMeter

print(' * Acc@1 {top1.avg:.3f}'

.format(top1=top1))

return top1

def predict(test_loader, model, tta=10):

# switch to evaluate mode

model.eval()

test_pred_tta = None

for _ in range(tta):

test_pred = []

with torch.no_grad():

end = time.time()

for i, (input, target) in tqdm_notebook(enumerate(test_loader), total=len(test_loader)):

input = input.cuda()

target = target.cuda()

# compute output

output = model(input)

output = F.softmax(output, dim=1)

output = output.data.cpu().numpy()

test_pred.append(output)

test_pred = np.vstack(test_pred)

if test_pred_tta is None:

test_pred_tta = test_pred

else:

test_pred_tta += test_pred

return test_pred_tta

def train(train_loader, model, criterion, optimizer, epoch):

batch_time = AverageMeter('Time', ':6.3f')

losses = AverageMeter('Loss', ':.4e')

top1 = AverageMeter('Acc@1', ':6.2f')

progress = ProgressMeter(len(train_loader), batch_time, losses, top1)

# switch to train mode

model.train()

end = time.time()

for i, (input, target) in enumerate(train_loader):

input = input.cuda(non_blocking=True)

target = target.cuda(non_blocking=True)

# compute output

output = model(input)

loss = criterion(output, target)

# measure accuracy and record loss

losses.update(loss.item(), input.size(0))

acc = (output.argmax(1).view(-1) == target.float().view(-1)).float().mean() * 100

top1.update(acc, input.size(0))

# compute gradient and do SGD step

optimizer.zero_grad()

loss.backward()

optimizer.step()

# measure elapsed time

batch_time.update(time.time() - end)

end = time.time()

if i % 100 == 0:

progress.pr2int(i)

Step3：加载模型

import timm

model = timm.create_model('resnet18', pretrained=True, num_classes=2)

model = model.cuda()

#从timm库中创建一个预训练的resnet18模型，并将其分类头的输出单元数设置为2（真实和伪造两类），然后将模型转移到GPU上

train_loader = torch.utils.data.DataLoader(

FFDIDataset(train_label['path'].head(1000), train_label['target'].head(1000),

transforms.Compose([

transforms.Resize((256, 256)),

transforms.RandomHorizontalFlip(),

transforms.RandomVerticalFlip(),

transforms.ToTensor(),

transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])

])

), batch_size=40, shuffle=True, num_workers=4, pin_memory=True

)

# 使用训练集的前一千条数据，使用随机水平翻转和垂直翻转等数据增强技术，并进行标准化和尺寸调整。

val_loader = torch.utils.data.DataLoader(

FFDIDataset(val_label['path'].head(1000), val_label['target'].head(1000),

transforms.Compose([

transforms.Resize((256, 256)),

transforms.ToTensor(),

transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])

])

), batch_size=40, shuffle=False, num_workers=4, pin_memory=True

)

# 使用测试集的前一千条数据，并进行标准化和尺寸调整

criterion = nn.CrossEntropyLoss().cuda() #移动到GPU上

optimizer = torch.optim.Adam(model.parameters(), 0.005) # 使用Adam优化器，学习率为0.005。

scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=4, gamma=0.85)

best_acc = 0.0

for epoch in range(2): #只训练了2个epoch，这可能不足以让模型收敛

scheduler.step() # 学习率在每个epoch开始时通过scheduler.step()进行更新。

print('Epoch: ', epoch)

train(train_loader, model, criterion, optimizer, epoch)

val_acc = validate(val_loader, model, criterion)

if val_acc.avg.item() > best_acc:

best_acc = round(val_acc.avg.item(), 2)

torch.save(model.state_dict(), f'./model_{best_acc}.pt')

#在2个epoch内训练模型，每个epoch结束后在验证集上评估模型，并根据验证集上的准确率决定是否保存模型的权重

test_loader = torch.utils.data.DataLoader(

FFDIDataset(val_label['path'], val_label['target'],

transforms.Compose([

transforms.Resize((256, 256)),

transforms.ToTensor(),

transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])

])

), batch_size=40, shuffle=False, num_workers=4, pin_memory=True

)

val_label['y_pred'] = predict(test_loader, model, 1)[:, 1]

val_label[['img_name', 'y_pred']].to_csv('submit.csv', index=None)

        在这部分主要的运行代码中，影响loss大小的主要就是训练集和测试集的训练数和epoch的学习轮数，以及学习率等，更多的数据和减小学习率的值会增大运算时间，增加训练轮数可能会导致过拟合，所以每一步修改都要谨而慎之，既要尽可能减小loss，提高分数，又要防止过拟合，导致模型不可用。

        这这一次中，我将训练集和测试集的数量提升至2000，再增加epoch的轮数到10轮，最终在kaggle上获得的分数由初始的0.539提升到0.751，说明了增加样本数和训练次数对提升模型精度是由帮助的。

        之后的日子里，我也会继续跟进学习进阶技术，尽快提升自己的能力。