Datawhale AI 夏令营：从零入门CV图像竞赛(Deepfake攻防)----Task 2-CSDN博客

本文链接：https://blog.csdn.net/weixin_73040764/article/details/131933550

Task2：从baseline入门深度学习

原任务地址：https://datawhaler.feishu.cn/wiki/CsS2weZvgigEKok6IzycdiVunuy

任务目标是：开发一个基于深度学习的Deepfake检测模型。这个实践项目将涵盖从数据集准备、模型训练到性能评估的各个环节，全面展示如何利用深度学习技术检测Deepfake内容。学到的内容包括：

预训练模型的使用：学习如何加载和微调预训练模型，以加快训练过程并提高模型性能。
深度学习模型训练流程：掌握模型训练的各个步骤，包括前向传播、损失计算、反向传播和参数更新。
性能评估与优化：通过准确率等指标评估模型性能，并进行相应的优化。

Part1 深度学习是什么？

深度学习是机器学习的一个子领域，它基于人工神经网络的算法，特别是那些具有多层结构的网络，即所谓的“深度”网络。这些网络能够学习数据的复杂模式，并且通常在处理图像、声音和文本等非结构化数据时表现出色。

深度学习模型通常包含大量的参数，这些参数通过训练过程自动调整，以更好地适应训练数据。训练过程通常涉及将数据输入到网络中，然后通过网络的多个层进行前向传播，最后通过损失函数计算输出与目标值之间的差异，并通过反向传播算法调整网络的权重。

深度学习已经在多个领域取得了突破性的进展，包括但不限于图像识别、语音识别、自然语言处理、自动驾驶汽车和游戏AI等。这些模型的强大能力很大程度上归功于它们的深度架构，这使得它们能够捕捉到数据中的细微特征和复杂的非线性关系。

然而，深度学习模型也面临着一些挑战，如对大量数据的需求、计算资源的高消耗、模型的可解释性问题以及对过拟合的敏感性。研究人员正在不断探索新的算法和技术，以解决这些问题并进一步提升深度学习模型的性能和应用范围。

Part2 深度学习如何训练的？

深度学习模型的训练是一个迭代的过程，主要包括以下几个步骤：

初始化参数：在训练开始之前，模型中的所有权重和偏置会被随机初始化。这些参数将决定网络层之间的连接强度。
前向传播（Forward Propagation）：输入数据被送入网络，逐层经过多个神经元的处理，直到最后一层产生输出。每一层的输出都是下一层的输入。
计算损失（Loss Calculation）：模型的输出与真实标签（ground truth）之间的差异通过损失函数（如均方误差、交叉熵等）来计算。损失函数的选择取决于特定的任务（如分类或回归）。
反向传播（Backpropagation）：损失函数的结果用于计算每个参数的梯度，这个过程称为反向传播。梯度指示了损失函数对每个参数的敏感度，即参数如何影响当前的损失值。
参数更新（Parameter Update）：使用梯度下降或其变体（如Adam、RMSprop等）来更新模型的参数。学习率是控制每次更新步长的超参数。
迭代优化：重复上述步骤，直到模型在验证集上的性能不再提升，或者达到预设的迭代次数。
正则化和超参数调整：为了防止过拟合，可能会使用正则化技术（如L1、L2正则化）和Dropout。同时，超参数（如学习率、批量大小等）的调整也是训练过程中的关键部分。
评估和测试：在训练过程中，模型会在验证集上进行评估，以监控过拟合。训练完成后，模型会在测试集上进行最终评估，以测试其泛化能力。
微调（Fine-tuning）：在某些情况下，可能会对预训练模型进行微调，以适应特定的任务或数据集。

深度学习模型的训练是一个计算密集型的过程，通常需要使用GPU或TPU等硬件加速器来减少训练时间。随着模型的复杂度和数据集的大小增加，训练过程可能需要数小时甚至数天的时间。

Pytorch代码实现

实操代码地址：https://www.kaggle.com/code/finlay/deepfake-ffdi-ch2/

导入必要的库：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

定义模型：创建一个继承自nn.Module的类，并定义模型的结构。

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        # 定义网络层
        self.conv1 = nn.Conv2d(1, 32, kernel_size=5)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = x.view(-1, 32 * 7 * 7)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

初始化模型、损失函数和优化器：

model = MyModel()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

数据预处理：定义数据的加载和预处理方式。

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

训练模型：循环进行训练，包括前向传播、计算损失、反向传播和参数更新。

epochs = 5
for epoch in range(epochs):
    for data, target in train_loader:
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
    print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item()}')

测试模型：在测试集上评估模型的性能。

test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

correct = 0
total = 0
with torch.no_grad():
    for data, target in test_loader:
        output = model(data)
        _, predicted = torch.max(output.data, 1)
        total += target.size(0)
        correct += (predicted == target).sum().item()

print(f'Accuracy of the model on the 10000 test images: {100 * correct / total} %')

保存模型：保存训练好的模型以便以后使用。

torch.save(model.state_dict(), 'model.ckpt')

深度学习模型的训练是一个系统化的过程，涉及到数据的预处理、模型的构建、训练、评估和保存。PyTorch框架提供了灵活且强大的工具来实现这一过程。在PyTorch中，模型通常通过继承nn.Module类来定义，包括网络层的初始化和前向传播的逻辑。训练过程中，使用优化器（如Adam）来更新模型的参数，以最小化损失函数（如交叉熵损失）计算的误差。此外，数据加载器（DataLoader）用于批量处理和打乱数据，以提高训练效率和模型的泛化能力。最后，模型的性能在测试集上进行评估，并通过准确率等指标来衡量。训练完成后，模型的参数可以被保存，以便进行后续的部署或进一步分析。

以下是使用PyTorch实现上述过程的完整代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 定义模型
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=5)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = x.view(-1, 32 * 7 * 7)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 初始化模型、损失函数和优化器
model = MyModel()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# 训练模型
epochs = 5
for epoch in range(epochs):
    for data, target in train_loader:
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
    print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item()}')

# 测试模型
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

correct = 0
total = 0
with torch.no_grad():
    for data, target in test_loader:
        output = model(data)
        _, predicted = torch.max(output.data, 1)
        total += target.size(0)
        correct += (predicted == target).sum().item()

print(f'Accuracy of the model on the 10000 test images: {100 * correct / total} %')

# 保存模型
torch.save(model.state_dict(), 'model.ckpt')

Part3 深度学习与迁移学习

迁移学习是一种机器学习技术，它允许模型利用在一个任务上学习到的知识来解决另一个相关任务。这种方法特别适用于数据较少或计算资源有限的情况。

关键特点：

知识迁移：在一个任务上训练好的模型可以被重新用于另一个任务，而不需要从头开始训练。
灵活性：可以迁移模型的某些部分（如特征提取器）或整个模型。
效率：减少了训练新模型所需的时间和资源。

应用场景：

数据稀缺：在某些任务中，可能难以获得大量标注数据，迁移学习可以利用其他任务上训练好的模型。
快速部署：在需要快速开发新应用时，迁移学习可以加速模型的开发和部署。

迁移学习的实现方法

迁移学习是一种强大的技术，它允许我们将在一个任务上学到的知识应用到另一个相关任务上，尤其在数据稀缺或训练资源有限的情况下非常有用。以下是迁移学习在深度学习中的几种实现方法：

特征重用（Feature Reuse）：特征重用是迁移学习中一种简单而有效的方法。通过使用在源任务上训练好的模型作为特征提取器，将其应用于目标任务，然后在目标任务的数据上训练新的分类器或回归器。例如，可以使用预训练的VGG16模型作为特征提取器，然后在CIFAR-10数据集上训练新的分类器。
微调（Fine-Tuning）：微调是迁移学习中常用的方法之一，通过在目标任务的数据上继续训练预训练模型的部分或全部层，使模型适应目标任务的特性。例如，在解冻预训练模型的部分层后，使用较小的学习率重新编译模型，并继续训练模型。
使用预训练模型：在深度学习中，经常使用在大规模数据集（如ImageNet）上预训练的模型作为新任务的起点。这些模型已经在大量数据上训练，具备了强大的特征提取能力。例如，牛津的VGG模型、谷歌的Inception模型和微软的ResNet模型都是在ImageNet上训练的，可以作为迁移学习的起点。
零样本学习（Zero-shot Learning）：零样本学习是迁移学习的一个变体，它依赖于未标记的样本进行学习。这种学习方式在训练阶段进行了特殊设计，利用一些其他信息去理解未见数据。例如，在机器翻译等场景中，可能不需要标记的目标语言数据。
多任务学习（Multitask Learning）：多任务学习是迁移学习的一种形式，它涉及训练一个模型来同时执行多个任务。这种方法假设不同的任务可以共享一些潜在的特征表示，并通过这种方式提高模型的泛化能力。

通过这些方法，迁移学习能够在深度学习中实现高效的知识迁移，解决各种复杂的预测问题。

Part4 常见的图像分类网络

AlexNet

结构特点：

AlexNet是早期深度学习领域的开创性工作之一，其结构包含8层，其中5层是卷积层，2层是全连接层，还有3层是ReLU激活层。
它使用了最大池化层来降低特征的空间维度，并通过Dropout技术减少过拟合。
AlexNet的输入图像尺寸为224x224x3，经过多次卷积和池化操作后，最终输出一个1000维的向量，用于1000类分类任务。

创新点：

AlexNet是首个在大规模图像识别任务中取得显著成功的深度学习模型，其成功验证了深度学习在视觉识别中的潜力。
它引入了ReLU激活函数，有效解决了梯度消失问题，提高了训练的稳定性和速度。
通过Dropout技术，AlexNet减少了模型的过拟合，提高了模型的泛化能力。

ResNet

结构特点：

ResNet的核心是残差块（Residual Block），每个块包含两条路径：一条是卷积层的堆叠，另一条是输入的直接连接。
这些路径的输出在块的末尾相加，形成残差块的输出，这种设计使得网络能够学习输入和输出之间的残差映射。
ResNet通过这种结构解决了深层网络训练中的梯度消失问题，使得网络可以设计得更深而不损失训练效果。

创新点：

ResNet引入了“残差学习”的概念，允许网络学习输入和输出之间的残差，而不是直接学习输出。
这种设计使得网络在增加深度时，梯度能够更有效地传递到网络的深层，解决了深层网络训练中的难题。
ResNet的变种（如ResNet-50、ResNet-101）通过调整残差块的数量，进一步优化了网络的性能和效率。

EfficientNet

结构特点：

EfficientNet通过神经架构搜索（NAS）自动设计网络结构，优化了网络的深度、宽度和分辨率。
它采用复合缩放方法，同时扩展网络的深度和宽度，以及输入图像的分辨率，以提高模型的性能。
EfficientNet的结构设计使得它在保持较小模型尺寸的同时，能够实现更高的准确率。

创新点：

EfficientNet是首个通过NAS技术自动设计出高效网络结构的模型，其设计过程无需人工干预。
它通过复合缩放方法实现了网络性能和效率的最优平衡，特别适合在计算资源受限的设备上运行。
EfficientNet在多个基准测试中表现出色，证明了其设计方法的有效性，为后续的网络设计提供了新的思路。

这三种模型不仅在技术上具有创新性，而且在实际应用中也展示了卓越的性能，成为深度学习领域的重要参考和基准。

baseline的修改

赛事链接：https://www.kaggle.com/competitions/multi-ffdi

项目链接：https://www.kaggle.com/code/finlay/deepfake-ffdi-baseline/

在训练样本数限制为4000个样本时，各个模型的训练集准确率如下：

在4000个训练样本的条件下，这些深度学习模型的准确率表现可以更简洁地分析如下：

SE-ResNet50：在两次训练周期中，准确率显著提升，从接近75%提升到85%左右。这表明模型能够从有限的训练样本中有效学习，并逐步优化其性能。
EfficientNet：在第一个训练周期中准确率迅速提升至90%，但在第二个周期中有所下降至80%左右。这种波动可能暗示模型在小样本训练中对数据的敏感性，或者需要进一步调整以避免过拟合。
SE-ResNet18：展现了极高的初始准确率，接近100%，但在第二个周期中略有下降。这种下降可能是由于模型在小样本集上过拟合，或者训练数据的波动性。
ResNet50：从第一个周期的70%准确率提升至第二个周期的90%，显示出良好的学习趋势和泛化能力，尽管是在小样本集上。

综合分析

学习速度：所有模型在初期都显示出快速的学习速度，尤其是SEResNet18和EfficientNet，但EfficientNet在第二个周期中准确率有所下降，这可能需要进一步的调整。
泛化能力：尽管样本数量有限，ResNet50和SEResNet50的稳定提升表明它们可能具有较好的泛化能力。SEResNet18的高初始准确率和随后的下降则提示可能存在过拟合风险。
模型稳定性：ResNet50和SEResNet50在训练周期中表现出较高的稳定性，这对于小样本学习尤其重要。

在小样本训练中，模型的泛化能力和稳定性是关键因素。这些初步结果表明，尽管样本数量有限，但通过适当的训练策略和模型选择，仍然可以实现有效的学习。进一步的验证和调整将是优化这些模型性能的关键步骤。

各模型的训练准确率（4000个样本）
模型	epoch0		epoch1
	训练集	验证集	训练集	验证集
SE-ResNet18	81.57	59.7	81.95	59.7
EfficientNet	77.28	59.675	50.55	58.6
ResNet50	81.70	59.8	81.98	59.725
SE-ResNet50	81.02	53.8	81.73	59.3

SE-ResNet18和ResNet50在训练集上表现出较高的准确率，但验证集准确率相对较低，这可能表明模型在训练数据上过拟合。
EfficientNet在第1个epoch中准确率显著下降，这可能是由于模型对训练数据的敏感性或训练数据的波动性。
SE-ResNet50总体来看，模型在训练集上的表现较好，验证集准确率的提升幅度较小。

各模型的训练准确率（10000个样本）
模型	epoch0		epoch1
	训练集	验证集	训练集	验证集
SE-ResNet18	81.00	59.96	81.07	59.96
EfficientNet	78.07	59.96	80.45	63.52
ResNet50	80.95	59.95	82.04	61.10
SE-ResNet50	80.83	59.96	81.03	59.96

SE-ResNet18和SE-ResNet50在训练集上表现出较高的准确率，但验证集准确率的提升幅度较小，这可能表明模型在训练数据上有一定的过拟合风险。
EfficientNet和ResNet50在第1个epoch中验证集准确率有显著提升，这表明这些模型在新数据上的泛化能力较强。
EfficientNet在第1个epoch中验证集准确率提升至63.52%，是所有模型中最高的，显示出较好的泛化能力。

SE-ResNet50是在原有的ResNet50模型基础上添加了Squeeze-and-Excitation（SE）模块的变种。以下是对添加SE模块前后模型的一些分析和建议：

模型分析

ResNet50：
- ResNet50本身是一个深度残差网络，包含50层深度，其设计通过残差学习解决了深层网络训练中的梯度消失问题。
- 它在多种视觉识别任务中表现出色，但随着网络深度的增加，可能会遇到梯度消失和过拟合的问题。
SE-ResNet50：
- SE模块通过显式地建模通道间的关系，重新加权网络中的通道，增强了网络的表征能力。
- 通过在ResNet50中添加SE模块，可以进一步提升模型对特征的提取能力，尤其是在有限的训练样本下。