### Python 实现手写体识别的代码示例
以下是基于 PyTorch 和 TensorFlow 的 MNIST 数据集的手写体识别代码示例。
---
#### 使用 PyTorch 实现 MNIST 手写体识别
```python
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
# 定义超参数
batch_size = 64
learning_rate = 0.01
epochs = 5
# 加载数据集并预处理
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('./data', train=False, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
# 构建卷积神经网络模型
class CNN(nn.Module):
def __init__(self):
super(CNN, self).__init__()
self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
self.relu = nn.ReLU()
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
self.fc = nn.Linear(32 * 14 * 14, 10) # 输出层有10个类别
def forward(self, x):
out = self.conv1(x)
out = self.relu(out)
out = self.pool(out)
out = out.view(out.size(0), -1) # 展平
out = self.fc(out)
return out
model = CNN()
# 设置损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)
# 训练过程
for epoch in range(epochs):
model.train()
for data, labels in train_loader:
optimizer.zero_grad() # 清零梯度
outputs = model(data) # 前向传播
loss = criterion(outputs, labels) # 计算损失
loss.backward() # 反向传播
optimizer.step() # 更新权重
print("训练完成")[^3]
# 测试过程
correct = 0
total = 0
with torch.no_grad():
model.eval()
for data, labels in test_loader:
outputs = model(data)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
accuracy = 100 * correct / total
print(f'测试集上的准确率: {accuracy:.2f}%')
```
---
#### 使用 TensorFlow/Keras 实现 MNIST 手写体识别
```python
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
# 载入MNIST数据集并进行预处理
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(-1, 28, 28, 1).astype('float32') / 255.0
x_test = x_test.reshape(-1, 28, 28, 1).astype('float32') / 255.0
y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)
# 创建卷积神经网络模型
model = models.Sequential([
layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
layers.MaxPooling2D((2, 2)),
layers.Flatten(),
layers.Dense(128, activation='relu'),
layers.Dense(10, activation='softmax')
])
# 编译模型
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
# 训练模型
model.fit(x_train, y_train, epochs=5, batch_size=64, validation_split=0.1)[^1]
# 测试模型性能
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'测试集上的准确率: {test_acc*100:.2f}%')
```
---
### 关键点说明
- **PyTorch** 中的数据加载部分使用 `torchvision.datasets` 提供的接口来获取 MNIST 数据集，并通过自定义变换将其转换为张量形式[^3]。
- **TensorFlow/Keras** 中则利用内置方法直接读取 MNIST 数据集，同时调整输入形状以便于后续卷积操作。
- 在两种框架中均采用了简单的卷积神经网络结构用于特征提取与分类任务。
---
扫一扫
737
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
