训练面部识别模型以区分真实面部图像和生成的面部图像的python代码

以下是使用PyTorch框架搭建的训练面部识别模型的代码，用于区分真实面部图像和生成的面部图像：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
from torchvision.transforms import transforms
from PIL import Image

# 定义数据预处理
data_transforms = transforms.Compose([
    transforms.Resize((64, 64)),
    transforms.ToTensor(),
])

# 创建面部数据集类
class FaceDataset(Dataset):
    def __init__(self, real_image_path, fake_image_path):
        self.real_image_path = real_image_path
        self.fake_image_path = fake_image_path
        
        self.real_images = os.listdir(real_image_path)
        self.fake_images = os.listdir(fake_image_path)
        
        self.real_len = len(self.real_images)
        self.fake_len = len(self.fake_images)
        
    def __getitem__(self, index):
        if index < self.real_len:
            img = Image.open(os.path.join(self.real_image_path, self.real_images[index]))
            label = torch.tensor([1])
        else:
            img = Image.open(os.path.join(self.fake_image_path, self.fake_images[index - self.real_len]))
            label = torch.tensor([0])
            
        img = data_transforms(img)
        return img, label
    
    def __len__(self):
        return self.real_len + self.fake_len

# 定义卷积神经网络模型
class FaceModel(nn.Module):
    def __init__(self):
        super(FaceModel, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=2, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1)
        self.conv4 = nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1)
        self.fc1 = nn.Linear(256*4*4, 512)
        self.fc2 = nn.Linear(512, 1)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()
        
    def forward(self, x):
        x = self.relu(self.conv1(x))
        x = self.relu(self.conv2(x))
        x = self.relu(self.conv3(x))
        x = self.relu(self.conv4(x))
        x = x.view(-1, 256*4*4)
        x = self.relu(self.fc1(x))
        x = self.sigmoid(self.fc2(x))
        return x

# 创建训练集和测试集
train_dataset = FaceDataset(real_image_path='real_images', fake_image_path='fake_images')
test_dataset = FaceDataset(real_image_path='test_real_images', fake_image_path='test_fake_images')

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=True)

# 定义损失函数和优化器
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
model = FaceModel()
for epoch in range(10):
    for i, (inputs, labels) in enumerate(train_loader):
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels.float())
        loss.backward()
        optimizer.step()
        if i % 50 == 0:
            print('Epoch: {}, Batch: {}, Loss: {}'.format(epoch, i, loss.item()))

# 测试模型
correct = 0
total = 0
for inputs, labels in test_loader:
    outputs = model(inputs)
    predicted = torch.round(outputs)
    total += labels.size(0)
    correct += (predicted == labels).sum().item()

print('Accuracy: {}%'.format(100 * correct / total))

其中real_image_path和fake_image_path分别为真实面部图像和生成的面部图像的路径，可以根据实际情况进行修改。训练模型的过程中，将真实面部图像和生成的面部图像作为正样本和负样本，使用交叉熵损失函数进行训练。测试模型时，使用测试集进行模型测试，并计算模型的准确率。