以下是在人脸鉴伪任务中实现构建 `Conv2D+Norm+ReLU+FC` 基本网络，按批次加载数据输出真假判别结果，掌握损失函数、优化方法、学习率作用，保存和加载模型及测试图像的详细步骤及代码示例： ### 1. 构建基本网络 使用 PyTorch 构建包含 `Conv2D`、`Norm`（这里以 `BatchNorm2d` 为例）、`ReLU` 和 `FC`（全连接层）的网络。 ```python import torch import torch.nn as nn class FaceForgeryDetector(nn.Module): def __init__(self): super(FaceForgeryDetector, self).__init__() self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1) self.bn1 = nn.BatchNorm2d(16) self.relu1 = nn.ReLU() self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2) self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1) self.bn2 = nn.BatchNorm2d(32) self.relu2 = nn.ReLU() self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2) self.fc1 = nn.Linear(32 * 56 * 56, 128) self.relu3 = nn.ReLU() self.fc2 = nn.Linear(128, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): x = self.pool1(self.relu1(self.bn1(self.conv1(x)))) x = self.pool2(self.relu2(self.bn2(self.conv2(x)))) x = x.view(-1, 32 * 56 * 56) x = self.relu3(self.fc1(x)) x = self.sigmoid(self.fc2(x)) return x ``` ### 2. 按批次加载数据 使用 `torch.utils.data.DataLoader` 按批次加载数据。 ```python from torch.utils.data import DataLoader, Dataset import torchvision.transforms as transforms from PIL import Image import os class FaceDataset(Dataset): def __init__(self, root_dir, transform=None): self.root_dir = root_dir self.transform = transform self.data = [] for label in ['real', 'fake']: label_dir = os.path.join(root_dir, label) for img_name in os.listdir(label_dir): img_path = os.path.join(label_dir, img_name) self.data.append((img_path, 1 if label == 'fake' else 0)) def __len__(self): return len(self.data) def __getitem__(self, idx): img_path, label = self.data[idx] image = Image.open(img_path).convert('RGB') if self.transform: image = self.transform(image) return image, torch.tensor(label, dtype=torch.float32) transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) train_dataset = FaceDataset(root_dir='train_data', transform=transform) train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True) ``` ### 3. 定义损失函数、优化方法和学习率 ```python model = FaceForgeryDetector() criterion = nn.BCELoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) ``` - **损失函数（`nn.BCELoss`）**：用于二分类问题，计算预测值和真实标签之间的二元交叉熵损失。 - **优化方法（`torch.optim.Adam`）**：自适应矩估计优化器，结合了 AdaGrad 和 RMSProp 的优点，能自适应调整学习率。 - **学习率（`lr=0.001`）**：控制模型参数更新的步长，过大可能导致模型无法收敛，过小则会使训练速度变慢。 ### 4. 训练模型 ```python device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.to(device) num_epochs = 10 for epoch in range(num_epochs): running_loss = 0.0 for images, labels in train_loader: images, labels = images.to(device), labels.to(device) optimizer.zero_grad() outputs = model(images).squeeze() loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() print(f'Epoch {epoch + 1}, Loss: {running_loss / len(train_loader)}') ``` ### 5. 保存和加载模型 ```python # 保存模型 torch.save(model.state_dict(), 'face_forgery_detector.pth') # 加载模型 loaded_model = FaceForgeryDetector() loaded_model.load_state_dict(torch.load('face_forgery_detector.pth')) loaded_model.to(device) loaded_model.eval() ``` ### 6. 测试图像 ```python test_image = Image.open('test_image.jpg').convert('RGB') test_image = transform(test_image).unsqueeze(0).to(device) with torch.no_grad(): output = loaded_model(test_image).squeeze() prediction = 1 if output.item() > 0.5 else 0 print(f'Prediction: {"Fake" if prediction == 1 else "Real"}') ```