码迷,mamicode.com
首页 > 其他好文 > 详细

pytorch神经网络搭建-手写字符识别

时间:2020-10-14 20:41:51      阅读:24      评论:0      收藏:0      [点我收藏+]

标签:+=   清空   pen   sed   beta   training   squeeze   super   过滤   

技术图片
  1 import torch
  2 import torchvision
  3 import torch.nn as nn
  4 import torch.utils.data as Data
  5 import matplotlib.pyplot as plt
  6 from torch.autograd import Variable
  7  
  8 # 超参数定义
  9 EPOCH = 5  #定义太大的话CPU计算时间会太长 train the training data n times
 10 LR = 0.01
 11 BATCH_SIZE = 50
 12 
 13 DOWNLOAD_MNIST = True  #没下载好的时候是True 下载好了改成 False
 14  
 15 # 下载MNIST数据集
 16 train_data = torchvision.datasets.MNIST(
 17     root = ./mnist/,
 18     # 是否是训练数据
 19     train = True,
 20     # 数据变换(0, 255) -> (0, 1) 把下载的数据改成TENSOR
 21     transform = torchvision.transforms.ToTensor(),
 22     # 是否下载MNIST数据
 23     download = DOWNLOAD_MNIST
 24 )
 25  
 26 test_data = torchvision.datasets.MNIST(
 27     root = ./mnist/,
 28     # 是否是训练数据
 29     train = False,
 30     # 数据变换(0, 255) -> (0, 1)
 31     transform = torchvision.transforms.ToTensor(),
 32     # 是否下载MNIST数据
 33     download = DOWNLOAD_MNIST
 34 )
 35 # 查看图像
 36 plt.imshow(train_data.train_data[0].numpy(), cmap = gray)
 37 plt.title(%i % train_data.train_labels[0])
 38 plt.show()
 39 
 40 plt.imshow(test_data.test_data[0].numpy(), cmap = gray)
 41 plt.title(%i % test_data.test_labels[0])
 42 plt.show()
 43 # 数据加载
 44 train_loader = Data.DataLoader(dataset = train_data, batch_size = BATCH_SIZE, shuffle = True, num_workers = 2)
 45 #test_x = Variable(torch.unsqueeze(test_data.test_data,dim=1),volatile=True).type(torch.FloatTensor)[:2000]/255.
 46 #test_y = test_data.test_lable[:2000] #测试只取了前两千个 为了节省时间 这里和莫烦视频里的不一样
 47 test_loader = Data.DataLoader(dataset = test_data, batch_size = BATCH_SIZE, shuffle = False, num_workers = 1)
 48  
 49 
 50  
 51 print(train_data.__len__)
 52 print(test_data.__len__)
 53 print(train_loader.__len__)
 54 print(test_loader.__len__)
 55  
 56  
 57 # 定义卷积神经网络 (重点)
 58 class CNN(nn.Module):
 59     def __init__(self):
 60         super(CNN, self).__init__()
 61         self.conv1 = nn.Sequential(      #卷积层
 62             nn.Conv2d(      #(1,28,28)     #卷积层相当于一个三维过滤器(有高度)(高度用来提取的特征属性)
 63                 in_channels = 1,             #图片有多少个层 黑白图:1层  彩图:RGB 3层
 64                 out_channels = 16,           #16个过滤器 同时提取16个特征
 65                 kernel_size = 5,             #过滤器的大小 5*5
 66                 stride = 1,                  #每隔一步跳一下
 67                 padding = 2                  #扫到边缘过滤器超出范围时,多加一圈为0的信息
 68                                              #padding 的值的计算  if stride=1,padding=(kernel_size-1)/2=(5-1)/2=2
 69             ),#-->(16,28,28)
 70             nn.ReLU(),  #-->(16,28,28)   #神经网络
 71             nn.MaxPool2d(kernel_size = 2)#池化层
 72                #-->(16,14,14)               #使用了一个2*2的过滤器,选择2*2区域中的最大值,相当于把原始图片裁剪了一下,
 73                                             #换成长宽变小,高度不变
 74         )
 75         # conv1输出为(16, 14, 14)
 76         self.conv2 = nn.Sequential(  
 77             nn.Conv2d(16, 32, 5, 1, 2), #-->(32,14,14)
 78             nn.ReLU(),                  #-->(32,14,14)
 79             nn.MaxPool2d(2)             #-->(32,7,7)
 80             #Pooling 有两种MaxPool2d,AvgPool2d(平均值) 一般选MAX的
 81         )
 82         # conv2输出为(32, 7, 7)
 83         self.output = nn.Linear(32 * 7 * 7, 10) 
 84  
 85     def forward(self, x):
 86         x = self.conv1(x)
 87         x = self.conv2(x)   #(batch,32,7,7)  考虑了batch
 88         x = x.view(x.size(0), -1)   #(batch,32*7*7)
 89         prediction = self.output(x)  #这样就有了上面的参数值
 90         return prediction
 91  
 92 cnn = CNN()
 93 print (cnn)
 94 # 定义优化器
 95 optimizer = torch.optim.Adam(cnn.parameters(), lr = LR, betas= (0.9, 0.999))
 96  
 97 # 定义损失函数
 98 loss_func = nn.CrossEntropyLoss()
 99  
100 # 训练
101 for epoch in range(EPOCH):
102     for step, (x, y) in enumerate(train_loader):
103        
104         # print(‘Epoch: ‘, epoch, ‘Step: ‘, step) 
105         x_var = Variable(x)
106         y_var = Variable(y)
107         
108         prediction = cnn(x_var)
109         loss = loss_func(prediction, y_var)
110        # print(loss)
111 
112         optimizer.zero_grad() # 清空上一步的残余更新参数值
113         loss.backward()     # 误差反向传播, 计算参数更新值
114         optimizer.step()    # 将参数更新值施加到 net 的 parameters 上
115  
116         if step % 50 == 0:    
117             correct = 0.0
118             for step_test, (test_x, test_y) in enumerate(test_loader):
119                 # print(step_test)
120 
121                 test_x = Variable(test_x)
122                 test_output = cnn(test_x)
123 
124                 pred_y = torch.max(test_output, 1)[1].data.squeeze()
125                 correct += sum(pred_y == test_y)
126 
127             accuracy = correct / test_data.test_data.size(0)
128             print (epoch: , epoch, | train loss: %.4f % loss.data, | accuracy: , accuracy)
129 
130          
View Code

 

pytorch神经网络搭建-手写字符识别

标签:+=   清空   pen   sed   beta   training   squeeze   super   过滤   

原文地址:https://www.cnblogs.com/zhaopengpeng/p/13814932.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!