Pytorch-定义MLP&GPU加速&测试

 1 import torch 
 2 import  torch.nn as nn
 3 import  torch.nn.functional as F
 4 
 5 #模拟一张28*28的图片摊平
 6 x = torch.randn(1, 784)            #shape=[1,784]
 7 
 8 #定义三个全连接层
 9 layer1=nn.Linear(784, 200)         #(in,out)
10 layer2=nn.Linear(200, 200)
11 layer3=nn.Linear(200, 10)
12 
13 x=layer1(x)                        #shape=[1,200]
14 x=F.relu(x, inplace=True)          #inplace=True在原对象基础上修改,可以节省内存
15 
16 x=layer2(x)                        #shape=[1,200]
17 x=F.relu(x, inplace=True)
18 
19 x=layer3(x)                        #shape=[1,10]
20 x=F.relu(x, inplace=True)

 1 import  torch
 2 import  torch.nn as nn
 3 import  torch.nn.functional as F
 4 import  torch.optim as optim
 5 from    torchvision import datasets, transforms
 6 
 7 #超参数
 8 batch_size=200
 9 learning_rate=0.01
10 epochs=10
11 
12 #获取训练数据
13 train_loader = torch.utils.data.DataLoader(
14     datasets.MNIST('../data', train=True, download=True,          #train=True则得到的是训练集
15                    transform=transforms.Compose([                 #transform进行数据预处理
16                        transforms.ToTensor(),                     #转成Tensor类型的数据
17                        transforms.Normalize((0.1307,), (0.3081,)) #进行数据标准化(减去均值除以方差)
18                    ])),
19     batch_size=batch_size, shuffle=True)                          #按batch_size分出一个batch维度在最前面,shuffle=True打乱顺序
20 
21 #获取测试数据
22 test_loader = torch.utils.data.DataLoader(
23     datasets.MNIST('../data', train=False, transform=transforms.Compose([
24         transforms.ToTensor(),
25         transforms.Normalize((0.1307,), (0.3081,))
26     ])),
27     batch_size=batch_size, shuffle=True)
28 
29 
30 class MLP(nn.Module):
31 
32     def __init__(self):
33         super(MLP, self).__init__()
34         
35         self.model = nn.Sequential(         #定义网络的每一层，nn.ReLU可以换成其他激活函数，比如nn.LeakyReLU()
36             nn.Linear(784, 200),
37             nn.ReLU(inplace=True),
38             nn.Linear(200, 200),
39             nn.ReLU(inplace=True),
40             nn.Linear(200, 10),
41             nn.ReLU(inplace=True),
42         )
43 
44     def forward(self, x):
45         x = self.model(x)
46         return x    
47 
48 
49 net = MLP()
50 #定义sgd优化器,指明优化参数、学习率，net.parameters()得到这个类所定义的网络的参数[[w1,b1,w2,b2,...]
51 optimizer = optim.SGD(net.parameters(), lr=learning_rate)
52 criteon = nn.CrossEntropyLoss()
53 
54 for epoch in range(epochs):
55 
56     for batch_idx, (data, target) in enumerate(train_loader):
57         data = data.view(-1, 28*28)          #将二维的图片数据摊平[样本数,784]
58 
59         logits = net(data)                   #前向传播
60         loss = criteon(logits, target)       #nn.CrossEntropyLoss()自带Softmax
61 
62         optimizer.zero_grad()                #梯度信息清空   
63         loss.backward()                      #反向传播获取梯度
64         optimizer.step()                     #优化器更新
65 
66         if batch_idx % 100 == 0:             #每100个batch输出一次信息
67             print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
68                 epoch, batch_idx * len(data), len(train_loader.dataset),
69                        100. * batch_idx / len(train_loader), loss.item()))
70 
71 
72     test_loss = 0
73     correct = 0                                         #correct记录正确分类的样本数
74     for data, target in test_loader:
75         data = data.view(-1, 28 * 28)
76         logits = net(data)
77         test_loss += criteon(logits, target).item()     #其实就是criteon(logits, target)的值，标量
78         
79         pred = logits.data.max(dim=1)[1]                #也可以写成pred=logits.argmax(dim=1)
80         correct += pred.eq(target.data).sum()
81 
82     test_loss /= len(test_loader.dataset)
83     print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
84         test_loss, correct, len(test_loader.dataset),
85         100. * correct / len(test_loader.dataset)))

1 import  torch
2 import  torch.nn as nn
3 import  torch.nn.functional as F
4 
5 x=torch.randn(1,10)
6 print(F.relu(x, inplace=True))   #tensor([[0.2846, 0.6158, 0.0000, 0.0000, 0.0000, 1.7980, 0.6466, 0.4263, 0.0000, 0.0000]])
7 
8 layer=nn.ReLU()
9 print(layer(x))                  #tensor([[0.2846, 0.6158, 0.0000, 0.0000, 0.0000, 1.7980, 0.6466, 0.4263, 0.0000, 0.0000]])

1 device = torch.device('cpu:0')                     #使用第一张显卡
2 net = MLP().to(device)                             #定义的网络
3 criteon = nn.CrossEntropyLoss().to(device)         #损失函数

1 data, target = data.to(device), target.cuda()     #两种方式

 1 import  torch
 2 import  torch.nn.functional as F
 3 
 4 logits = torch.rand(4, 10)
 5 pred = F.softmax(logits, dim=1)
 6 
 7 pred_label = pred.argmax(dim=1)                     #tensor([5, 8, 4, 7]) 和logits.argmax(dim=1)结果一样
 8 
 9 label = torch.tensor([5, 3, 2, 7])
10 correct = torch.eq(pred_label, label)               #tensor([ True, False, False,  True]) 和pred_label.eq(label)结果一样
11 
12 print(correct.sum().float().item() / len(logits))   #0.5