输出就是这样的 label: tensor(2) predicted[i]也是这样的数

import torch

import torch.nn as nn

import torchvision

import torchvision.transforms as transforms

import matplotlib.pyplot as plt

import numpy as np

import torch.nn.functional as F #nn不好使时，在这里找激活函数

# device config

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# hyper parameters

input_size = 784 # 28x28

hidden_size = 100

num_classes = 10

batch_size = 100

learning_rate = 0.001

num_epochs = 2

transform = transforms.Compose(

[transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

train_dataset = torchvision.datasets.CIFAR10(

root='./data', train=True, download=True, transform=transform)

test_dataset = torchvision.datasets.CIFAR10(

root='./data', www.laipuhuo.com train=False, download=True, transform=transform)

train_loader = torch.utils. data.DataLoader(

dataset=train_dataset, batch_size=batch_size, shuffle=True)

test_loader = torch.utils.data.DataLoader(

dataset=test_dataset, batch_size=batch_size, shuffle=False)

print('每份100个，被分成多少份：', len(test_loader))

classes = ('plane', 'car', 'bird', 'cat', 'deer',

'dog', 'frog', 'horse', 'ship', 'truck')

class ConvNet(nn.Module):

def __init__(self):

super(ConvNet,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) #这个在forward里解释

self.fc2 = nn.www.laipuhuo.com Linear(120, 84)

self.fc3 = nn.Linear(84, 10)

def forward(self, x):

x = self.pool(F.relu(self.conv1(x)))

x = self.pool(F.relu(self.conv2(x))) #这里x已经变成 torch.Size([4, 16, 5, 5])

# print("两次卷积两次池化后的x.shape:",x.shape)

x = x.view(-1,16*5*5)#这里的16*5*5就是x的后面3个维度相乘

x = F.relu(self.fc1(x)) #fc1定义时，inputx已经是16*5*5了

x = F.relu(self.fc2(x))

x= self.fc3(x)

return x

model = ConvNet().to(device)

criterion = nn.CrossEntropyLoss()

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

n_total_steps = len(train_loader)

for epoch in range(num_epochs):

for i, (images, labels) in enumerate(train_loader):

# origin shape:[www.laipuhuo.com 4,3，32，32]=4，3，1024

# input layer: 3 input channels, 6 output channels, 5 kernel size

images = images.to(device)

labels = labels.to(device)

# Forward pass

outputs = model(images)

loss = criterion(outputs, labels)

# Backward and optimize

optimizer.zero_grad()

loss.backward()

optimizer.step()

if (i+1) % 2000 == 0:

print(

f'Epoch www.laipuhuo.com [{epoch+1}/{num_epochs}], Step [{i+1}/{n_total_steps}], Loss: {loss.item():.4f}')

print('Finished Training')

# test

with torch.no_grad():

n_correct = 0

n_samples = 0

n_class_correct = [0 for i in range(10)] #生成 10 个 0 的列表

n_class_samples = [0 for i in range(10)]

for images, labels in test_loader:

images = images.to(device)

labels = labels.to(device)

print('test-images.shape：', images.shape)

outputs = model(images)

# max returns(value ,index)

_, predicted = torch.max(outputs, 1)

n_samples +=www.laipuhuo.com labels.size(0)

n_correct += (predicted == labels).sum().item()

for i in range(batch_size):

label = labels[i]

# print("label:",label) #这里存的是 0~9的数字 输出就是这样的 label: tensor(2) predicted[i]也是这样的数

pred = predicted[i]

if (label == pred):

n_class_correct[label] += 1

n_class_samples[label] += 1

acc = 100.0*n_correct/n_samples # 计算正确率

print(f'accuracy =www.laipuhuo.com {acc}')

for i in range(10):

acc = 100.0*n_class_correct[i]/n_class_samples[i]

print(f'Accuracy of {classes[i]}: {acc} %')