pytorch图片分类神经网络代码

文章详细描述了如何使用PyTorch构建卷积神经网络进行MNIST手写数字识别,包括数据加载、网络结构定义、损失函数选择和训练测试过程。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

#%%
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
#%%
# 下载训练集
train_dataset = datasets.MNIST(root='./',
                train=True,
                transform=transforms.ToTensor(),
                download=True)
# 下载测试集
test_dataset = datasets.MNIST(root='./',
               train=False,
               transform=transforms.ToTensor(),
               download=True)
#%%
# 批次大小
batch_size = 64

# 装载训练集
train_loader = DataLoader(dataset=train_dataset,
                      batch_size=batch_size,
                      shuffle=True)
# 装载测试集
test_loader = DataLoader(dataset=test_dataset,
                     batch_size=batch_size,
                     shuffle=True)
#%%
for i, data in enumerate(train_loader):
    # 获得数据和对应的标签
    inputs, labels = data
    print(inputs.shape)
    print(labels.shape)
    break
#%%
# 定义网络结构
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Sequential(nn.Conv2d(1, 32, 5, 1, 2), nn.ReLU(), nn.MaxPool2d(2, 2))
        self.conv2 = nn.Sequential(nn.Conv2d(32, 64, 5, 1, 2), nn.ReLU(), nn.MaxPool2d(2, 2))
        self.fc1 = nn.Sequential(nn.Linear(64 * 7 * 7, 1000), nn.Dropout(p=0.4), nn.ReLU())
        self.fc2 = nn.Sequential(nn.Linear(1000, 10), nn.Softmax(dim=1))
        
    def forward(self, x):
        # ([64, 1, 28, 28])
        x = self.conv1(x)
        x = self.conv2(x)
        x = x.view(x.size()[0], -1)
        x = self.fc1(x)
        x = self.fc2(x)
        return x
#%%
LR = 0.0003
# 定义模型
model = Net()
# 定义代价函数
entropy_loss = nn.CrossEntropyLoss()
# 定义优化器
optimizer = optim.Adam(model.parameters(), LR)
#%%
def train():
    model.train()
    for i, data in enumerate(train_loader):
        # 获得数据和对应的标签
        inputs, labels = data
        # 获得模型预测结果,(64,10)
        out = model(inputs)
        # 交叉熵代价函数out(batch,C),labels(batch)
        loss = entropy_loss(out, labels)
        # 梯度清0
        optimizer.zero_grad()
        # 计算梯度
        loss.backward()
        # 修改权值
        optimizer.step()


def test():
    model.eval()
    correct = 0
    for i, data in enumerate(test_loader):
        # 获得数据和对应的标签
        inputs, labels = data
        # 获得模型预测结果
        out = model(inputs)
        # 获得最大值,以及最大值所在的位置
        _, predicted = torch.max(out, 1)
        # 预测正确的数量
        correct += (predicted == labels).sum()
    print("Test acc: {0}".format(correct.item() / len(test_dataset)))
    
    correct = 0
    for i, data in enumerate(train_loader):
        # 获得数据和对应的标签
        inputs, labels = data
        # 获得模型预测结果
        out = model(inputs)
        # 获得最大值,以及最大值所在的位置
        _, predicted = torch.max(out, 1)
        # 预测正确的数量
        correct += (predicted == labels).sum()
    print("Train acc: {0}".format(correct.item() / len(train_dataset)))
#%%
for epoch in range(0, 20):
    print('epoch:',epoch)
    train()
    test()
#%%

这个代码示例是一个基本的图像分类神经网络,使用了卷积神经网络(Convolutional Neural Network, CNN)的结构。下面是代码中主要部分的原理解释:

  1. 定义神经网络模型:在代码中,使用了一个继承自nn.Module的类Net来定义神经网络模型。这个模型包括了卷积层、池化层和全连接层。通过__init__方法来初始化网络的各个层,然后通过forward方法来定义前向传播过程。

  2. 加载和预处理数据集:使用torchvision.transforms模块中的Compose函数来定义数据集的预处理操作,包括将图像转换为张量(ToTensor)和归一化操作(Normalize)。然后使用torchvision.datasets模块中的CIFAR10类来加载CIFAR-10数据集,并使用torch.utils.data.DataLoader类来创建训练集和测试集的数据加载器。

  3. 定义损失函数和优化器:在代码中使用了交叉熵损失函数(nn.CrossEntropyLoss)作为分类任务的损失函数,使用随机梯度下降(SGD)优化器(optim.SGD)来更新网络的参数。

  4. 训练网络:使用一个嵌套的循环来进行网络的训练。外层循环迭代多个epochs(整个数据集的完整训练周期),内层循环迭代小批次数据进行梯度更新。在每个小批次中,首先将梯度归零(optimizer.zero_grad()),然后通过前向传播计算输出,计算损失,然后进行反向传播和参数更新(optimizer.step())。

  5. 在测试集上评估网络:使用torch.no_grad()上下文管理器来禁用梯度计算,然后对测试集中的图像进行前向传播计算输出,并与标签进行比较,计算准确率。

这是一个简单的示例,用于展示PyTorch中构建和训练图像分类神经网络的基本原理。根据具体任务和需求

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

# 定义神经网络模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 加载和预处理数据集
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

# 定义损失函数和优化器
net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

# 训练网络
for epoch in range(2):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 2000 == 1999:    # 每2000个小批次打印一次损失值
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

# 在测试集上评估网络
correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))

这是一个基本的图像分类神经网络,使用CIFAR-10数据集进行训练和测试。可以根据需要进行修改和扩展。

### 使用PyTorch实现图像分类神经网络模型 构建基于PyTorch的图像分类神经网络涉及几个关键步骤,包括数据预处理、定义模型结构、设置损失函数和优化器以及训练过程。以下是详细的实现方式: #### 数据准备 在图像分类任务中,通常需要加载并预处理图像数据集。可以使用 `torchvision` 库中的工具来简化这一过程。 ```python import torch from torchvision import datasets, transforms transform = transforms.Compose([ transforms.Resize((224, 224)), # 调整图片大小 transforms.ToTensor(), # 将图片转换为张量 ]) train_dataset = datasets.ImageFolder(root='path_to_train_data', transform=transform) test_dataset = datasets.ImageFolder(root='path_to_test_data', transform=transform) train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=32, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=32, shuffle=False) ``` 上述代码展示了如何通过 `transforms` 对图像进行标准化操作,并创建用于训练和测试的数据加载器[^1]。 #### 定义卷积神经网络模型 接下来,定义一个简单的卷积神经网络 (CNN),该网络由若干卷积层、池化层和全连接层组成。 ```python import torch.nn as nn import torch.nn.functional as F class CNNModel(nn.Module): def __init__(self): super(CNNModel, self).__init__() self.conv1 = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1) self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0) self.fc1 = nn.Linear(16 * 56 * 56, 128) # 假设输入尺寸调整到224x224 self.fc2 = nn.Linear(128, num_classes) # 替换num_classes为目标类别的数量 def forward(self, x): x = self.pool(F.relu(self.conv1(x))) x = x.view(-1, 16 * 56 * 56) # 展平特征图 x = F.relu(self.fc1(x)) x = self.fc2(x) return x model = CNNModel() ``` 此部分实现了自定义的 CNN 架构,其中包含了必要的卷积层和全连接层配置[^2]。 #### 设置损失函数与优化器 为了使模型能够学习,需指定合适的损失函数和优化策略。 ```python criterion = nn.CrossEntropyLoss() # 处理多分类问题的标准交叉熵损失 optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # Adam优化器 ``` 这里选择了常用的交叉熵作为损失度量标准,并采用Adam算法更新权重参数。 #### 训练循环 最后一步是编写训练逻辑,在每轮迭代过程中前向传播计算预测值,反向传播调整梯度。 ```python for epoch in range(num_epochs): # 运行一定次数的epoch model.train() running_loss = 0.0 correct_predictions = 0 total_samples = 0 for images, labels in train_loader: optimizer.zero_grad() outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() _, predicted = torch.max(outputs.data, 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:.4f}, Accuracy: {accuracy:.2f}%') ``` 以上脚本执行完整的训练流程,记录每次迭代后的平均损失及准确率变化情况。 #### 测试模型性能 完成训练之后还需要验证模型的表现是否达到预期水平。 ```python model.eval() with torch.no_grad(): test_corrects = 0 test_total = 0 for images, labels in test_loader: outputs = model(images) _, predictions = torch.max(outputs, 1) test_total += labels.size(0) test_corrects += (predictions == labels).sum().item() final_accuracy = 100 * test_corrects / test_total print(f'Test Accuracy of the Model on Test Images: {final_accuracy:.2f}%') ``` 这段程序评估了经过训练后的模型对于未见过样本的识别能力。 ---
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值