vgg16实现数字识别pytorch完整代码

### 关于 LeNet5、VGG16 和 VGG19 的实现 以下是基于 Python 和 PyTorch 编写的 LeNet5、VGG16 和 VGG19 神经网络模型的训练代码示例。 #### 1. **LeNet5 实现** LeNet5 是一种经典的卷积神经网络架构，主要用于手写数字识别任务。其核心组件包括两层卷积层和三层全连接层。 ```python import torch import torch.nn as nn import torch.optim as optim from torchvision import datasets, transforms from torch.utils.data import DataLoader class LeNet5(nn.Module): def __init__(self): super(LeNet5, self).__init__() self.conv_layers = nn.Sequential( nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5), nn.ReLU(), nn.MaxPool2d(kernel_size=2), nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5), nn.ReLU(), nn.MaxPool2d(kernel_size=2) ) self.fc_layers = nn.Sequential( nn.Linear(16 * 4 * 4, 120), nn.ReLU(), nn.Linear(120, 84), nn.ReLU(), nn.Linear(84, 10) ) def forward(self, x): x = self.conv_layers(x) x = x.view(-1, 16 * 4 * 4) # Flatten the tensor x = self.fc_layers(x) return x # Data preparation and training loop transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))]) train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform) test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform) batch_size = 128 train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = LeNet5().to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) def train_model(model, criterion, optimizer, num_epochs=10): model.train() for epoch in range(num_epochs): running_loss = 0.0 correct_predictions = 0 total_samples = 0 for inputs, labels in train_loader: inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() _, predicted = torch.max(outputs, 1) total_samples += labels.size(0) correct_predictions += (predicted == labels).sum().item() running_loss += loss.item() accuracy = 100 * correct_predictions / total_samples print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}, Accuracy: {accuracy:.2f}%") train_model(model, criterion, optimizer, num_epochs=10) ``` --- #### 2. **VGG16/VGG19 实现** VGG 系列是一种深层卷积神经网络，具有多个卷积层堆叠的特点。下面是一个通用的 VGG 架构实现方法： ```python cfg_vgg16 = [ 64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M' ] cfg_vgg19 = [ 64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M' ] def make_layers(cfg, batch_norm=False): layers = [] in_channels = 3 for v in cfg: if v == 'M': layers += [nn.MaxPool2d(kernel_size=2, stride=2)] else: conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1) if batch_norm: layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)] else: layers += [conv2d, nn.ReLU(inplace=True)] in_channels = v return nn.Sequential(*layers) class VGG(nn.Module): def __init__(self, features, num_classes=1000): super(VGG, self).__init__() self.features = features self.avgpool = nn.AdaptiveAvgPool2d((7, 7)) self.classifier = nn.Sequential( nn.Linear(512 * 7 * 7, 4096), nn.ReLU(True), nn.Dropout(), nn.Linear(4096, 4096), nn.ReLU(True), nn.Dropout(), nn.Linear(4096, num_classes), ) def forward(self, x): x = self.features(x) x = self.avgpool(x) x = torch.flatten(x, 1) x = self.classifier(x) return x vgg16_net = VGG(make_layers(cfg_vgg16)).to(device) vgg19_net = VGG(make_layers(cfg_vgg19)).to(device) # Training setup similar to LeNet5 with FashionMNIST dataset resized to 224x224. transform_vgg = 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_vgg = datasets.FashionMNIST('./data', train=True, download=True, transform=transform_vgg) test_dataset_vgg = datasets.FashionMNIST('./data', train=False, download=True, transform=transform_vgg) train_loader_vgg = DataLoader(train_dataset_vgg, batch_size=128, shuffle=True) test_loader_vgg = DataLoader(test_dataset_vgg, batch_size=128, shuffle=False) criterion_vgg = nn.CrossEntropyLoss() optimizer_vgg16 = optim.SGD(vgg16_net.parameters(), lr=0.05, momentum=0.9, weight_decay=5e-4) optimizer_vgg19 = optim.SGD(vgg19_net.parameters(), lr=0.05, momentum=0.9, weight_decay=5e-4) train_model(vgg16_net, criterion_vgg, optimizer_vgg16, num_epochs=10) train_model(vgg19_net, criterion_vgg, optimizer_vgg19, num_epochs=10) ``` --- ### 讨论与总结 以上代码分别实现了 LeNet5、VGG16 和 VGG19 的基本框架并完成了训练过程[^1]。需要注意的是，在实际应用中可能需要调整超参数（如学习率、批量大小等），以及优化器的选择来提升性能[^2]。

### 如何使用 PyTorch 实现车牌识别系统 #### 数据准备 构建车牌识别系统的第一步是准备好高质量的训练数据集。这通常涉及收集带有标注的车牌图像，其中每张图片都附有对应的字符标签。为了处理这些数据，在 PyTorch 中可以创建自定义的数据加载器 `MyDataset` 来读取和预处理图像文件[^2]。 ```python from torch.utils.data import Dataset, DataLoader import torchvision.transforms as transforms class MyDataset(Dataset): def __init__(self, image_paths, labels, transform=None): self.image_paths = image_paths self.labels = labels self.transform = transform def __len__(self): return len(self.image_paths) def __getitem__(self, idx): img_path = self.image_paths[idx] label = self.labels[idx] image = Image.open(img_path).convert('RGB') if self.transform: image = self.transform(image) return image, label ``` 上述代码展示了如何定义一个简单的自定义数据集类来加载车牌图像及其对应标签。 --- #### 模型架构设计 对于车牌识别任务，可以选择卷积神经网络 (CNN) 作为基础模型结构。常见的 CNN 结构包括 ResNet、VGG 或 MobileNet 等。以下是一个基于简单 CNN 的例子： ```python import torch.nn as nn import torch.nn.functional as F class LicensePlateRecognizer(nn.Module): def __init__(self, num_classes=36): # 假设总共有36个类别(10位数字+26字母) super(LicensePlateRecognizer, self).__init__() self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=1) self.pool = nn.MaxPool2d(kernel_size=2, stride=2) self.fc1 = nn.Linear(32 * 8 * 8, 128) # 输入大小取决于输入分辨率 self.fc2 = nn.Linear(128, num_classes) def forward(self, x): x = self.pool(F.relu(self.conv1(x))) x = x.view(-1, 32 * 8 * 8) # 展平操作 x = F.relu(self.fc1(x)) x = self.fc2(x) return x ``` 此部分描述了一个基本的 CNN 架构用于提取特征并预测车牌中的单个字符[^1]。 --- #### 损失函数与优化器配置 在训练过程中，交叉熵损失函数常被用来衡量预测值与真实值之间的差异。Adam 是一种常用的优化算法，能够有效提升收敛速度。 ```python model = LicensePlateRecognizer(num_classes=36) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) ``` 以上代码片段说明了如何设置损失函数以及优化方法。 --- #### 训练过程 以下是完整的训练循环逻辑，其中包括前向传播、计算损失、反向传播更新参数等步骤。 ```python def train_model(dataloader, model, criterion, optimizer, epochs=10): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.to(device) for epoch in range(epochs): running_loss = 0.0 for images, labels in dataloader: images, labels = images.to(device), labels.to(device) outputs = model(images) loss = criterion(outputs, labels) optimizer.zero_grad() loss.backward() optimizer.step() running_loss += loss.item() print(f'Epoch [{epoch+1}/{epochs}], Loss: {running_loss/len(dataloader)}') train_model(train_loader, model, criterion, optimizer, epochs=10) ``` 该脚本实现了标准的监督学习流程，并支持 GPU 加速以提高效率。 --- #### 测试与评估 最后一步是对测试集进行验证，确保模型具备良好的泛化能力。 ```python correct = 0 total = 0 with torch.no_grad(): for data in test_loader: images, labels = data outputs = model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print(f'Accuracy of the network on the test set: {(100 * correct / total)}%') ``` 这段程序演示了如何统计模型在未见过的数据上的表现指标。 ---