Python实现深度学习

在Python中实现深度学习，最常用的库是TensorFlow和PyTorch。以下是一个使用PyTorch的简单深度学习模型示例，用于图像分类任务（例如，MNIST手写数字识别）。

首先，确保你已经安装了PyTorch。你可以通过pip安装：

pip install torch torchvision

然后，你可以使用以下代码来创建一个简单的神经网络，训练它，并在测试集上进行评估：

import torch  
import torch.nn as nn  
import torch.optim as optim  
from torchvision import datasets, transforms  
  
# 定义超参数  
input_size = 784  # 28x28像素的图像  
hidden_size = 500  # 隐藏层的大小  
num_classes = 10  # 输出层的神经元数量（0-9的数字）  
num_epochs = 5  # 训练轮数  
batch_size = 100  # 批处理大小  
learning_rate = 0.001  # 学习率  
  
# 转换图像为Tensor并归一化  
transform = transforms.Compose([transforms.ToTensor(),  
                                transforms.Normalize((0.5,), (0.5,))])  
  
# 下载和加载MNIST训练集  
trainset = datasets.MNIST('~/.pytorch/MNIST_data/', download=True, train=True, transform=transform)  
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True)  
  
# 下载和加载MNIST测试集  
testset = datasets.MNIST('~/.pytorch/MNIST_data/', download=True, train=False, transform=transform)  
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False)  
  
# 定义神经网络模型  
class Net(nn.Module):  
    def __init__(self, input_size, hidden_size, num_classes):  
        super(Net, self).__init__()  
        self.fc1 = nn.Linear(input_size, hidden_size)   
        self.relu = nn.ReLU()  
        self.fc2 = nn.Linear(hidden_size, num_classes)    
      
    def forward(self, x):  
        out = self.fc1(x)  
        out = self.relu(out)  
        out = self.fc2(out)  
        return out  
  
model = Net(input_size, hidden_size, num_classes)  
  
# 定义损失函数和优化器  
criterion = nn.CrossEntropyLoss()  
optimizer = optim.Adam(model.parameters(), lr=learning_rate)    
  
# 训练模型  
for epoch in range(num_epochs):  
    for i, (images, labels) in enumerate(trainloader, 0):  
        # 将图像数据展平  
        images = images.reshape(-1, 28*28)  
          
        # 前向传播  
        outputs = model(images)  
        loss = criterion(outputs, labels)  
          
        # 反向传播和优化  
        optimizer.zero_grad()  
        loss.backward()  
        optimizer.step()  
          
        if (i+1) % 100 == 0:  
            print (f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{len(trainloader)}], Loss: {loss.item():.4f}')  
  
# 测试模型  
correct = 0  
total = 0  
with torch.no_grad():  
    for images, labels in testloader:  
        images = images.reshape(-1, 28*28)  
        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 10000 test images: {100 * correct / total}%')

这个代码首先定义了一个简单的全连接神经网络，然后在一个训练循环中训练这个网络。在每个训练步骤中，它都会进行前向传播以计算损失，然后进行反向传播以计算梯度，并最后更新网络的权重。训练完成后，代码会在测试集上评估模型的准确性。