当前位置：首页 > news >正文

（十三）计算机视觉中的深度学习：特征表示、模型架构与视觉认知原理

news 来源：原创 2025/6/13 7:00:29

1 计算机视觉简介

计算机视觉（Computer Vision）是一门使计算机能够从图像或视频中获取、处理和理解视觉信息的学科。它结合了信号处理、机器学习和深度学习等领域的技术，以实现对图像和视频内容的自动分析和理解。

1.1 计算机视觉的任务

计算机视觉的任务多种多样，以下是一些常见的任务：

图像分类（Image Classification）：
- 定义：将图像分为预定义的类别。
- 应用场景：自动照片标注、医学图像诊断。
- 示例：将图像分类为猫、狗或其他动物。
目标检测（Object Detection）：
- 定义：在图像中识别和定位一个或多个目标对象，并标注其位置（通常使用边界框）。
- 应用场景：自动驾驶、监控系统。
- 示例：在图像中检测出所有车辆和行人，并绘制边界框。
语义分割（Semantic Segmentation）：
- 定义：将图像的每个像素分类为预定义的类别。
- 应用场景：卫星图像分析、医学图像分割。
- 示例：将图像中的每个像素标注为道路、建筑物、树木等。
实例分割（Instance Segmentation）：
- 定义：不仅将图像的每个像素分类，还要区分同一类别的不同实例。
- 应用场景：机器人视觉、交互式图像编辑。
- 示例：在图像中区分不同的汽车实例。
目标跟踪（Object Tracking）：
- 定义：在视频序列中跟踪一个或多个目标对象的运动。
- 应用场景：视频监控、运动分析。
- 示例：在视频中跟踪一个特定的行人。
图像生成（Image Generation）：
- 定义：生成新的图像或对现有图像进行编辑。
- 应用场景：艺术创作、虚拟现实。
- 示例：生成一个不存在的场景或修改图像中的某些元素。

1.2 计算机视觉的应用领域

计算机视觉广泛应用于各个领域，以下是一些典型的应用领域：

自动驾驶：通过摄像头和传感器获取环境信息，识别道路、车辆和行人，实现自动驾驶。
医疗影像分析：分析X光、CT、MRI等医学影像，辅助医生进行诊断。
工业检测：在生产线上检测产品质量，识别缺陷和异常。
监控系统：实时分析监控视频，检测异常行为和事件。
增强现实（AR）：将虚拟信息叠加在现实世界中，增强用户体验。
机器人视觉：为机器人提供视觉感知能力，使其能够在复杂环境中导航和操作。

1.3 计算机视觉的挑战

尽管计算机视觉技术取得了显著进步，但仍面临许多挑战：

数据的多样性和复杂性：现实世界的图像和视频数据具有高度的多样性和复杂性，包括不同的光照条件、视角、遮挡等。
计算资源的需求：计算机视觉任务通常需要大量的计算资源，尤其是在处理高分辨率图像和视频时。
模型的泛化能力：模型需要在不同的数据分布和场景中保持良好的泛化能力。
实时性要求：许多应用场景（如自动驾驶、监控系统）对实时性有很高的要求。

通过深入学习计算机视觉的基础知识和各种任务，你可以更好地理解和应用这些技术来解决实际问题。

2 图像分类

图像分类是计算机视觉中的一个基本任务，目标是将图像自动分类到预定义的类别中。深度学习模型，尤其是卷积神经网络（CNN），在图像分类任务中表现出色。以下是关于图像分类的详细介绍：

图像分类的定义

图像分类任务是将图像分为预定义的类别。例如，将图像分类为猫、狗、汽车、飞机等。每个图像属于一个类别，模型需要学习从图像中提取特征并进行分类。

2.1 数据集和预处理

在进行图像分类之前，需要准备合适的数据集并对数据进行预处理。以下是一些常见的数据集和预处理步骤：

常见数据集：
- MNIST：手写数字数据集，包含 60,000 张训练图像和 10,000 张测试图像。
- CIFAR-10：包含 10 个类别的彩色图像数据集，每个类别有 6,000 张图像。
- ImageNet：大规模图像数据集，包含超过 14,000,000 张图像，分为 10,000 多个类别。
数据预处理：
- 归一化：将像素值归一化到 [0, 1] 或 [-1, 1] 范围。
- 数据增强：通过旋转、平移、缩放、翻转等操作增加数据集的多样性。
- 裁剪和调整大小：将图像裁剪或调整到模型所需的输入尺寸。

2.1 卷积神经网络（CNN）的应用

CNN 是图像分类任务中最常用的模型，它通过卷积层、池化层和全连接层提取图像特征并进行分类。以下是一个简单的 CNN 模型示例：

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader
import torchvision.datasets as datasets
import torchvision.transforms as transforms# 定义一个简单的 CNN 模型
class SimpleCNN(nn.Module):def __init__(self):super(SimpleCNN, self).__init__()self.conv1 = nn.Conv2d(3, 16, 3, padding=1)self.pool = nn.MaxPool2d(2, 2)self.conv2 = nn.Conv2d(16, 32, 3, padding=1)self.fc = nn.Linear(32 * 8 * 8, 10)def forward(self, x):x = self.pool(F.relu(self.conv1(x)))  # 第一个卷积层和池化层x = self.pool(F.relu(self.conv2(x)))  # 第二个卷积层和池化层x = x.view(-1, 32 * 8 * 8)            # 展平特征图x = self.fc(x)                         # 全连接层return x# 数据预处理和加载
transform = transforms.Compose([transforms.Resize((32, 32)),   # 调整图像大小transforms.ToTensor(),         # 转换为张量transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 归一化
])# 下载并加载 CIFAR-10 数据集
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)# 初始化模型、损失函数和优化器
model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)# 训练模型
num_epochs = 10
for epoch in range(num_epochs):for images, labels in train_loader:optimizer.zero_grad()outputs = model(images)loss = criterion(outputs, labels)loss.backward()optimizer.step()print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {loss.item():.4f}')

在这个示例中，我们定义了一个简单的 CNN 模型，加载了 CIFAR-10 数据集，并使用交叉熵损失函数和 Adam 优化器进行训练。通过多轮迭代，模型能够学习到图像的特征并进行分类。

3 目标检测

目标检测是计算机视觉中的一个关键任务，旨在识别图像中的目标对象，并通过边界框标注其位置。以下是关于目标检测的详细介绍：

3.1 目标检测的定义

目标检测任务的目标是在图像中识别和定位一个或多个目标对象，并标注其位置。通常使用边界框（bounding box）来表示目标的位置。常见的目标检测算法包括R-CNN系列和YOLO系列。

3.2 R-CNN系列

R-CNN（Region-based Convolutional Neural Network）系列算法是目标检测领域的经典方法，通过区域提议和卷积神经网络提取特征来实现目标检测。

R-CNN：
- 步骤：
  1. 使用选择性搜索（Selective Search）生成约2000个候选区域（region proposals）。
  2. 对每个候选区域进行预处理（如裁剪、调整大小）。
  3. 使用CNN提取每个候选区域的特征。
  4. 使用支持向量机（SVM）对特征进行分类。
- 优点：首次将深度学习引入目标检测，显著提高了检测精度。
- 缺点：计算开销大，速度慢。
Fast R-CNN：
- 改进：将特征提取过程统一，避免对每个候选区域单独提取特征。
- 步骤：
  1. 对整个图像进行卷积操作，生成特征图。
  2. 使用区域提议（region proposals）在特征图上提取感兴趣区域（ROI）。
  3. 对ROI进行池化操作，使其大小统一。
  4. 使用全连接层进行分类和边界框回归。
- 优点：减少了重复计算，提高了速度。
- 缺点：仍需独立生成区域提议。
Faster R-CNN：
- 改进：引入区域提议网络（Region Proposal Network, RPN）自动生成区域提议。
- 步骤：
  1. 使用卷积网络提取图像特征。
  2. RPN生成候选区域。
  3. ROI池化层将候选区域映射到相同大小的特征图。
  4. 全连接层进行分类和边界框回归。
- 优点：端到端的训练方式，速度更快，精度更高。

3.3 YOLO系列

YOLO（You Only Look Once）是一种实时目标检测算法，将目标检测任务转化为单个网络的回归问题。YOLO系列算法以其速度快、实时性好而闻名。

YOLOv3：
- 特点：
  - 使用多尺度特征图进行检测，能够同时检测不同大小的目标。
  - 引入了锚框（anchor boxes）来预测边界框。
- 优点：实时性好，适合需要快速响应的场景。
- 缺点：在小目标检测上可能不如R-CNN系列准确。
YOLOv5：
- 改进：简化了网络结构，提高了速度和精度。
- 特点：
  - 支持动态输入尺寸，提高了模型的灵活性。
  - 使用了更高效的特征提取网络。
- 优点：速度快，精度高，易于部署。

3.4 目标检测的应用场景

目标检测技术广泛应用于多个领域，以下是一些典型的应用场景：

自动驾驶：检测车辆、行人、交通标志等，为自动驾驶提供环境感知。
视频监控：实时检测和跟踪监控视频中的目标，用于安全监控。
交通管理：检测交通流量、违规行为等，优化交通信号灯控制。
工业检测：检测生产线上产品的缺陷和异常。
医疗影像分析：检测医学影像中的病变区域，辅助医生进行诊断。

3.5 目标检测的挑战

尽管目标检测技术取得了显著进步，但仍面临一些挑战：

数据的多样性和复杂性：目标的大小、形状、姿态、光照条件等变化多样。
实时性要求：许多应用场景需要实时处理，对模型的速度有很高的要求。
小目标检测：小目标的特征信息少，检测难度大。
目标遮挡：目标被其他物体遮挡时，检测难度增加。

通过学习目标检测任务，你可以深入理解如何利用深度学习模型实现对图像中目标的识别和定位。这些知识和技能在多个领域都有广泛的应用前景。

4 语义分割

语义分割是计算机视觉中的一个重要任务，旨在将图像的每个像素分类为预定义的类别。与图像分类和目标检测不同，语义分割不仅需要识别图像中的物体，还需要确定每个像素所属的类别。以下是关于语义分割的详细介绍：

4.1 语义分割的定义

语义分割任务的目标是将图像的每个像素分类为预定义的类别。例如，将图像中的每个像素标注为道路、建筑物、树木、车辆、行人等。这在自动驾驶、医学图像分析、卫星图像分析等领域具有重要应用。

4.2 全卷积网络（FCN）

全卷积网络（Fully Convolutional Network, FCN）是语义分割任务中的基础模型。它通过将全连接层替换为卷积层，实现对任意大小图像的像素级分类。

卷积层：用于提取图像特征。
池化层：用于减少特征图的空间尺寸。
反卷积层：用于上采样特征图，恢复到原始图像尺寸。

FCN的代码实现：

import torch
import torch.nn as nn
import torch.nn.functional as Fclass FCN(nn.Module):def __init__(self, num_classes):super(FCN, self).__init__()self.conv1 = nn.Conv2d(3, 64, 3, padding=1)self.conv2 = nn.Conv2d(64, 128, 3, padding=1)self.conv3 = nn.Conv2d(128, 256, 3, padding=1)self.conv4 = nn.Conv2d(256, 512, 3, padding=1)self.conv5 = nn.Conv2d(512, 1024, 3, padding=1)self.conv6 = nn.Conv2d(1024, num_classes, 1)self.pool = nn.MaxPool2d(2, 2)self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)def forward(self, x):x1 = F.relu(self.conv1(x))x1p = self.pool(x1)x2 = F.relu(self.conv2(x1p))x2p = self.pool(x2)x3 = F.relu(self.conv3(x2p))x3p = self.pool(x3)x4 = F.relu(self.conv4(x3p))x4p = self.pool(x4)x5 = F.relu(self.conv5(x4p))x5p = self.pool(x5)x6 = self.conv6(x5p)x_up = self.upsample(x6)return x_up# 初始化模型
num_classes = 21  # 例如，PASCAL VOC数据集有21个类别
model = FCN(num_classes)# 假设输入图像
input_image = torch.randn(1, 3, 256, 256)
output = model(input_image)

4.3 U-Net

U-Net是一种在医学图像分割领域广泛应用的模型，特别适用于处理具有较少训练数据的任务。它通过跳跃连接将编码器和解码器部分连接起来，保留了图像的细节信息。

编码器：通过卷积和池化层提取图像特征。
解码器：通过反卷积和卷积层恢复特征图的空间尺寸。
跳跃连接：将编码器的特征图直接连接到解码器，保留细节信息。

U-Net的代码实现：

class UNet(nn.Module):def __init__(self, num_classes):super(UNet, self).__init__()self.conv1 = nn.Conv2d(3, 64, 3, padding=1)self.conv2 = nn.Conv2d(64, 128, 3, padding=1)self.conv3 = nn.Conv2d(128, 256, 3, padding=1)self.conv4 = nn.Conv2d(256, 512, 3, padding=1)self.conv5 = nn.Conv2d(512, 1024, 3, padding=1)self.conv6 = nn.Conv2d(1024, 512, 3, padding=1)self.conv7 = nn.Conv2d(512, 256, 3, padding=1)self.conv8 = nn.Conv2d(256, 128, 3, padding=1)self.conv9 = nn.Conv2d(128, 64, 3, padding=1)self.conv10 = nn.Conv2d(64, num_classes, 1)self.pool = nn.MaxPool2d(2, 2)self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)def forward(self, x):# 编码器部分x1 = F.relu(self.conv1(x))x1p = self.pool(x1)x2 = F.relu(self.conv2(x1p))x2p = self.pool(x2)x3 = F.relu(self.conv3(x2p))x3p = self.pool(x3)x4 = F.relu(self.conv4(x3p))x4p = self.pool(x4)x5 = F.relu(self.conv5(x4p))# 解码器部分x5u = self.upsample(x5)x6 = F.relu(self.conv6(x5u + x4))x6u = self.upsample(x6)x7 = F.relu(self.conv7(x6u + x3))x7u = self.upsample(x7)x8 = F.relu(self.conv8(x7u + x2))x8u = self.upsample(x8)x9 = F.relu(self.conv9(x8u + x1))x10 = self.conv10(x9)return x10# 初始化模型
num_classes = 21
model = UNet(num_classes)# 假设输入图像
input_image = torch.randn(1, 3, 256, 256)
output = model(input_image)

4.4 Mask R-CNN

Mask R-CNN是Faster R-CNN的扩展，能够同时进行目标检测和像素级分割。它在Faster R-CNN的基础上添加了一个分支，用于预测目标的分割掩码。

Faster R-CNN：用于生成目标的边界框和类别。
掩码分支：用于生成目标的分割掩码。

Mask R-CNN的代码实现：

import torch
import torchvision.models as models# 加载预训练的Mask R-CNN模型
model = models.detection.maskrcnn_resnet50_fpn(pretrained=True)# 推理
model.eval()
input_image = torch.randn(1, 3, 256, 256)
with torch.no_grad():predictions = model(input_image)# 显示结果
for prediction in predictions:masks = prediction['masks']labels = prediction['labels']scores = prediction['scores']

4.5 DeepLabv3+

DeepLabv3+是一种先进的语义分割模型，通过引入空洞卷积（Atrous Convolution）和编码器-解码器结构，有效地捕捉图像的多尺度特征。

空洞卷积：通过在卷积核中插入空洞来扩大感受野，捕捉多尺度特征。
编码器-解码器结构：编码器提取图像特征，解码器恢复特征图的空间尺寸。

DeepLabv3+的代码实现：

import torch
import torchvision.models.segmentation as segmentation# 加载预训练的DeepLabv3+模型
model = segmentation.deeplabv3_resnet50(pretrained=True)# 推理
model.eval()
input_image = torch.randn(1, 3, 256, 256)
with torch.no_grad():output = model(input_image)['out']# 显示结果
output = torch.argmax(output, dim=1)

语义分割在计算机视觉中具有广泛的应用，通过学习全卷积网络（FCN）、U-Net、Mask R-CNN和DeepLabv3+等模型，你可以深入理解如何实现像素级分类。这些模型在不同的应用场景中表现出色，为解决实际问题提供了强大的工具。

5 实例分割

实例分割是计算机视觉中的一个高级任务，它不仅将图像的每个像素分类为预定义的类别，还要区分同一类别中的不同实例。实例分割结合了目标检测和语义分割的特点，能够同时识别目标的位置和形状。以下是关于实例分割的详细介绍：

5.1 实例分割的定义

实例分割任务的目标是识别图像中的每个目标对象，并为每个目标对象生成一个分割掩码，明确其在图像中的位置和轮廓。这使得实例分割能够区分同一类别中的不同实例，例如区分图像中的不同汽车或不同行人。

5.2 与语义分割的区别

语义分割将图像的每个像素分类为预定义的类别，但不区分同一类别中的不同实例。而实例分割则进一步区分同一类别中的不同实例，为每个实例生成独立的分割掩码。

5.3 Mask R-CNN

Mask R-CNN 是一种在实例分割任务中表现出色的模型，它是 Faster R-CNN 的扩展，通过添加一个分支来预测目标的分割掩码。以下是 Mask R-CNN 的主要组件：

Faster R-CNN：用于生成目标的边界框和类别。
掩码分支：为每个目标生成一个分割掩码。

Mask R-CNN 的代码实现：

import torch
import torchvision.models as models# 加载预训练的 Mask R-CNN 模型
model = models.detection.maskrcnn_resnet50_fpn(pretrained=True)# 推理
model.eval()
input_image = torch.randn(1, 3, 256, 256)
with torch.no_grad():predictions = model(input_image)# 显示结果
for prediction in predictions:masks = prediction['masks']labels = prediction['labels']scores = prediction['scores']

5.4 应用场景

实例分割技术在多个领域有重要应用，以下是一些典型的应用场景：

自动驾驶：识别和区分道路上的车辆、行人和其他障碍物。
视频监控：实时检测和跟踪监控视频中的目标，区分不同的个体。
医学影像分析：区分同一组织中的不同细胞或结构。
机器人视觉：帮助机器人在复杂环境中识别和操作不同的物体。

实例分割是计算机视觉中一个具有挑战性的任务，它结合了目标检测和语义分割的特点。通过学习 Mask R-CNN 等先进模型，你可以更好地理解和应用实例分割技术来解决实际问题。

6 目标跟踪

目标跟踪是计算机视觉中的一个重要任务，旨在在视频序列中跟踪目标对象的运动。目标跟踪技术广泛应用于视频监控、自动驾驶、运动分析等领域。以下是关于目标跟踪的详细介绍：

6.1 目标跟踪的定义

目标跟踪任务的目标是在视频序列中跟踪一个或多个目标对象的运动。与目标检测不同，目标跟踪不仅需要识别目标的位置，还需要在连续的视频帧中保持对目标的跟踪。

常见的跟踪算法

卡尔曼滤波（Kalman Filter）：
- 原理：通过预测和更新步骤，估计目标的状态（如位置和速度）。
- 优点：计算效率高，适合实时应用。
- 缺点：假设目标的运动模型是线性的，对于复杂运动可能效果不佳。
粒子滤波（Particle Filter）：
- 原理：通过一组随机样本（粒子）来表示目标的状态分布，适用于非线性、非高斯噪声场景。
- 优点：能够处理非线性运动模型。
- 缺点：计算复杂度较高，需要大量的粒子。
基于深度学习的跟踪算法：
- Siamese网络：使用孪生网络结构，通过比较目标模板和搜索区域的特征来实现跟踪。
- MDNet：使用多域网络结构，能够适应目标外观的变化。
- ATOM：一种基于深度学习的高效跟踪算法，使用孪生网络和优化的目标函数。

6.2 目标跟踪的应用场景

目标跟踪技术在多个领域有广泛应用，以下是一些典型的应用场景：

视频监控：实时跟踪监控视频中的目标，检测异常行为和事件。
自动驾驶：跟踪其他车辆和行人的位置和运动轨迹，确保行车安全。
运动分析：分析运动员的动作和轨迹，用于训练和比赛分析。
无人机航拍：跟踪特定目标，如人员、车辆等，用于监控和拍摄。
人机交互：通过跟踪手势和动作，实现自然的人机交互。

6.3 目标跟踪的挑战

目标跟踪任务面临以下挑战：

目标外观变化：目标在运动过程中可能发生变化，如姿态、光照、遮挡等。
背景复杂性：复杂的背景可能包含与目标相似的物体，导致误跟踪。
实时性要求：许多应用场景（如自动驾驶、视频监控）对实时性有很高的要求。
多目标跟踪：在多目标场景中，需要区分和跟踪多个目标，避免目标混淆。

6.4 使用YOLO进行目标跟踪的示例

YOLO（You Only Look Once）是一种实时目标检测算法，也可以用于目标跟踪任务。以下是使用YOLO进行目标跟踪的示例代码：

import cv2
import torch# 加载预训练的YOLO模型
model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)# 读取视频
cap = cv2.VideoCapture('video.mp4')# 初始化跟踪器
tracker = cv2.TrackerCSRT_create()# 读取第一帧
ret, frame = cap.read()
if not ret:print("无法读取视频")exit()# 选择要跟踪的目标区域
bbox = cv2.selectROI(frame, False)
tracker.init(frame, bbox)while cap.isOpened():ret, frame = cap.read()if not ret:break# 更新跟踪器success, bbox = tracker.update(frame)# 绘制跟踪结果if success:x, y, w, h = map(int, bbox)cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)else:cv2.putText(frame, "Tracking failure", (100, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 0, 255), 2)# 显示结果cv2.imshow('Tracking', frame)if cv2.waitKey(1) & 0xFF == ord('q'):breakcap.release()
cv2.destroyAllWindows()

在上述代码中，我们使用了YOLO模型进行目标检测，并使用OpenCV的CSRT跟踪器进行目标跟踪。首先，我们加载预训练的YOLO模型并读取视频。然后，我们在第一帧中选择要跟踪的目标区域，并初始化跟踪器。在后续帧中，我们更新跟踪器并绘制跟踪结果。

通过目标跟踪技术，可以实现对视频中目标对象的实时监测和分析，为各种应用场景提供强大的技术支持。

目标跟踪是计算机视觉中的一个重要任务，通过学习和应用目标跟踪技术，可以更好地理解和分析视频内容。

7 图像生成

图像生成是计算机视觉中的一个重要任务，旨在生成新的图像或对现有图像进行编辑。生成对抗网络（GAN）是图像生成任务中的重要模型。以下是关于图像生成的详细介绍：

7.1 图像生成的定义

图像生成任务的目标是生成新的图像或对现有图像进行编辑。生成的图像可以是全新的场景、修改后的图像或艺术创作。图像生成技术在多个领域有广泛应用，如艺术创作、虚拟现实、游戏开发等。

7.2 生成对抗网络（GAN）

GAN由Ian Goodfellow等人于2014年提出，是一种通过对抗训练生成逼真图像的模型。GAN由两个部分组成：生成器（Generator）和判别器（Discriminator）。

生成器：生成器的目标是生成逼真的图像，使得判别器无法区分生成的图像和真实的图像。
判别器：判别器的目标是区分输入的图像是真实的还是生成的。

GAN的训练过程是生成器和判别器之间的对抗过程，生成器不断学习生成更逼真的图像，而判别器不断学习更好地识别生成的图像。

GAN的数学表达：
$\min_G \max_D \mathbb{E}_{x \sim p_{data}(x)}[\log D(x)] + \mathbb{E}_{z \sim p_z(z)}[\log(1 - D(G(z)))]$

其中：

$G$ 是生成器。
$D$ 是判别器。
$p_{data}(x)$ 是真实数据的分布。
$p_z(z)$ 是生成器输入噪声的分布。

7.3 GAN的代码实现

import torch
import torch.nn as nn
import torch.optim as optim# 定义生成器
class Generator(nn.Module):def __init__(self, latent_dim, img_size):super(Generator, self).__init__()self.model = nn.Sequential(nn.Linear(latent_dim, 128),nn.ReLU(),nn.Linear(128, 256),nn.ReLU(),nn.Linear(256, 512),nn.ReLU(),nn.Linear(512, 1024),nn.ReLU(),nn.Linear(1024, img_size * img_size * 3),nn.Tanh())self.img_size = img_sizedef forward(self, z):img = self.model(z)img = img.view(img.size(0), 3, self.img_size, self.img_size)return img# 定义判别器
class Discriminator(nn.Module):def __init__(self, img_size):super(Discriminator, self).__init__()self.model = nn.Sequential(nn.Linear(img_size * img_size * 3, 512),nn.LeakyReLU(0.2),nn.Linear(512, 256),nn.LeakyReLU(0.2),nn.Linear(256, 128),nn.LeakyReLU(0.2),nn.Linear(128, 1),nn.Sigmoid())def forward(self, img):img_flat = img.view(img.size(0), -1)return self.model(img_flat)# 初始化模型和优化器
latent_dim = 100
img_size = 64
generator = Generator(latent_dim, img_size)
discriminator = Discriminator(img_size)
optimizer_g = optim.Adam(generator.parameters(), lr=0.0002)
optimizer_d = optim.Adam(discriminator.parameters(), lr=0.0002)# 定义损失函数
criterion = nn.BCELoss()# 训练循环
num_epochs = 100
for epoch in range(num_epochs):for i, (imgs, _) in enumerate(train_loader):batch_size = imgs.size(0)real_labels = torch.ones(batch_size, 1)fake_labels = torch.zeros(batch_size, 1)# 训练判别器optimizer_d.zero_grad()outputs = discriminator(imgs)loss_real = criterion(outputs, real_labels)loss_real.backward()z = torch.randn(batch_size, latent_dim)fake_images = generator(z)outputs = discriminator(fake_images.detach())loss_fake = criterion(outputs, fake_labels)loss_fake.backward()optimizer_d.step()# 训练生成器optimizer_g.zero_grad()outputs = discriminator(fake_images)loss_g = criterion(outputs, real_labels)loss_g.backward()optimizer_g.step()print(f'Epoch [{epoch+1}/{num_epochs}], Loss D: {loss_real + loss_fake:.4f}, Loss G: {loss_g:.4f}')