pytorch 官方文档 之 菜鸡摸索（2）

pytorch tutorials

import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
import torch.optim as optim
import matplotlib.pyplot as plt
import numpy as np

# load data into a numpy array , Then convert this array into a torch.*Tensor
'''
1) Load and normalizing the CIFAR10 training and test dattasets using torchvision
2) Define a CNN
3) Define a loss function
4) Train on the traing data
5) Test on  the test data
'''
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)
# 将训练集的50000张图片划分成12500份，每份4张图，用于mini-batch输入。
# shffule=True在表示不同批次的数据遍历时，打乱顺序。num_workers=2表示使用两个子进程来加载数据
trainloader = torch.utils.data.DataLoader(trainset,batch_size=4,
                                        shuffle=True,num_workers=0)            # batchsize 默认是1
testset = torchvision.datasets.CIFAR10(root='./data',train=False,
                                       download=True,transform=transform)

# 将测试集的10000张图片划分成2500份，每份4张图，用于mini-batch输入。
testloader = torch.utils.data.DataLoader(testset,batch_size=4,
                                       shuffle=False,num_workers=0)            # windows 下 num_workers(加载用到的进程数量)设置为0，不然出错
classess=('plane','car','bird','cat','deer','dog','frog','horse','ship','truck')


# functions to show an image

def imshow(img):
    img = img / 2  +0.5 #unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg,(1,2,0)))
    plt.show()
#
# # get some random training image
# dataiter = iter(trainloader)
# images , labels = dataiter.next()
#
# # show images
# imshow(torchvision.utils.make_grid(images))
# # print labels
# print(' '.join('%5s' % classess[labels[j]] for j in range(4)))

# Define a CNN

class Net(nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        # input 大小 32*32*3
        self.conv1 = nn.Conv2d(3,6,5)   # 29*29*6
        self.pool = nn.MaxPool2d(2,2)   # 14*14*6
        self.conv2 = nn.Conv2d(6,16,5)  # 11*11*16
        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(F.relu(self.conv1(x)))  # 输出14*14*6
        x = self.pool(F.relu(self.conv2(x)))  # 输出5*5*16
        x = x.view(-1,16*5*5)                 # 弄成列拉直
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x
net = Net()

# Define Loss Function

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(),lr=0.001,momentum=0.9)
# # Training on GPU
# device = torch.device("cuda:0" if torch.cuda.is_available() else 'cpu')
# print(device)
# net.to(device)

# Train the network

for epoch in range(2):
    running_loss = 0.0
    for i, data in enumerate(trainloader,0):         # 0 表示从trainloader的第一个开始加载，2的话就是从第三个开始
                                                     #   get the inputs; data is a list of [inputs,labels]
        inputs, labels = data
        # zero the parameter gredients
        optimizer.zero_grad()

        # forward + backword + gradients
        outputs = net(inputs)
        loss = criterion(outputs,labels)
        loss.backward()
        optimizer.step()

        # print statistics
        # 每2000批数据打印一次平均loss值
        running_loss += loss.item()
        if i %2000 == 1999:   #print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss=0.0
print("Finished Training")
#
# # Save Model
#
PATH = './cifar_net.pth'
torch.save(net.state_dict(),PATH)

# Test The Network

dataiter = iter(testloader)
images, labels = dataiter.next()

# #print images
# imshow(torchvision.utils.make_grid(images))
# print('GroundTruth: ',' '.join('%5s' % classess[labels[j]] for j in range(4)))#选择4以内（batchsize）个加载
#

# load model,这个模型有问题，参数是不是没有保存
net = Net()
net.load_state_dict(torch.load(PATH))


# outputs = net(images)
# print(outputs)
# '''outputs:
# tensor([[ 0.0200,  0.0377,  0.0699,  0.1513, -0.0399,  0.0977, -0.1174, -0.0743,
#          -0.0844,  0.0305],
#         [ 0.0137,  0.0357,  0.0664,  0.1436, -0.0322,  0.0954, -0.1213, -0.0751,
#          -0.0942,  0.0332],
#         [ 0.0205,  0.0387,  0.0690,  0.1505, -0.0289,  0.0985, -0.1225, -0.0738,
#          -0.0915,  0.0296],
#         [ 0.0106,  0.0371,  0.0694,  0.1481, -0.0292,  0.0950, -0.1181, -0.0729,
#          -0.0904,  0.0198]], grad_fn=<AddmmBackward>)
# '''
# # outputs.data是一个4x10张量，将每一行的最大的那一列的值和序号各自组成一个一维张量返回，第一个是值的张量，第二个是序号的张量。
# _, predicted = torch.max(outputs,1)
# print(_,)                              # 返回predict[按行最大的值的序号]，是一个值  ，tensor([0.1513, 0.1436, 0.1505, 0.1481], grad_fn=)
# print("*************",predicted)       # 返回按行最大的序号   tensor([3, 3, 3, 3])
# print('Predicted: ',' '.join('%5s' % classess[predicted[j]] for j in range(4)))

#
# 在整个测试集上的评估：

# correct = 0
# total = 0
# i = 1
# with torch.no_grad():
#     for data in testloader:
#         images,labels  = data
#         outputs = net(images)
#         _,predicted = torch.max(outputs.data,1)
#         # print("labels.size(0):",labels.size(0))  #label.size(0)=4,说的是每次加载的batchsize大小   tensor([4, 9, 9, 0])
#         total += labels.size(0)  # 计算总共有多少个测试数据
#         # print("第",i,"次：")
#         # print("predicted:  ",predicted)
#         # print("labels:  ",labels)
#         # print(predicted == labels)
#         # print((predicted == labels).sum())
#         # 每一个batchsize包含4个比较对象，比较预测值和真实值对应的tensor里面的每个数值是否一致，tensor([False, True, True, False])
#         # .sum()是TRUE的个数计算出来，返回 tensor(2)
#         # .item()把张量变成数字    ，返回 2
#         correct += (predicted == labels).sum().item()
#         i +=1
# print("Accuracy of the network on the 10000 test  images: %d %%" % (
#     100 * correct / total
# ))

# #在每个类上面的表现
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()
        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1


for i in range(10):
    print('Accuracy of %5s : %2d %%' % (
        classess[i], 100 * class_correct[i] / class_total[i]))
#
#
#
#

参考

DataLoader解疑

"""
    批训练，把数据变成一小批一小批数据进行训练。
    DataLoader就是用来包装所使用的数据，每次抛出一批数据
"""
import torch
import torch.utils.data as Data

BATCH_SIZE = 2

x = torch.linspace(1, 12, 20)
print(x)
y = torch.linspace(1, 10, 20)
print(y)
# 把数据放在数据库中
torch_dataset = Data.TensorDataset(x, y)    #  制作成数据集

loader = Data.DataLoader(
    # 从数据库中每次抽出batch size个样本
    dataset=torch_dataset,
    batch_size=BATCH_SIZE,
    shuffle=True,
    num_workers=2
)


def show_batch():  #  总共20个数据，batchsize=2，每次从20个数据中随机挑2个，然后一直下去挑完，共需要step=10次
    for epoch in range(3):
        for step, data in enumerate(loader):   # 把data换成(batch_x,batch_y),结果一样
            # training

            print(step)
            inputs, labels = data
            print("inputs:",inputs)
            print("labels:",labels)
            # print("batch_x: ",batch_x)
            # print("batch_y: ",batch_y)

            print("step:{}, batch_x:{}, batch_y:{}".format(step, batch_x, batch_y))


if __name__ == '__main__':
    show_batch()