深度学习

基础知识和各种网络结构实战 ...

---

前言

pytorch实现

---

一、导入第三方库

import torch
from torch.utils.data import DataLoader
import torchvision.datasets as da
import torchvision.transforms as transforms
import torch.nn as nn
from torch.autograd import Variable
import numpy as np

DataLoader为下载MNIST数据集的库

二、下载MNIST数据集

train_dataset=da.MNIST(root='/pymnist', 
                       train=True,      
                       transform=transforms.ToTensor(), 
                       download=True)  
test_dataset=da.MNIST(root='/pymnist',  
                       train=False,    
                       transform=transforms.ToTensor(),  
                       download=True)   
#加载数据
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=True)

root=’/pymnist’用来选择数据根目录
train=True 用来选择训练数据集
transform=transforms.ToTensor()用来转为tensor
shuffle=True用来打乱数据

三、创建神经网络模型

# 创建神经网络模型
class neural_Net(nn.Module):
    def __init__(self, input_size, hidden_size, out_put):
        super(neural_Net, self).__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)  
        self.layer2 = nn.Linear(hidden_size, out_put)  

    def forward(self, x):
        out = self.layer1(x)  
        out = torch.relu(out)  
        out = self.layer2(out)  
        return out


neural_net= neural_Net(input_size, hidden_size, out_put)
print(neural_net)

四、训练数据集

learning_rate = 1e-1 
num_epoches = 5
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(neural_net.parameters(), lr=learning_rate)  # 使用随机梯度下降
for epoch in range(num_epoches):
    print('current epoch = %d' % epoch)
    for i, (images, labels) in enumerate(train_loader):  
        images = Variable(images.view(-1, 28 * 28))
        labels = Variable(labels)

        outputs = neural_net(images)  
        loss = criterion(outputs, labels)  # 计算loss
        optimizer.zero_grad()  
        loss.backward()  
        optimizer.step()  

        if i % 100 == 0:
            print('current loss = %.5f' % loss.item())

print('训练完成')

current epoch = 0
current loss = 2.30684
current loss = 0.46591
current loss = 0.35780
current loss = 0.34935
current loss = 0.25930
current loss = 0.26343
current epoch = 1
current loss = 0.30920
current loss = 0.26891
current loss = 0.19270
current loss = 0.35991
current loss = 0.38737
current loss = 0.21648
current epoch = 2
current loss = 0.21281
current loss = 0.23885
current loss = 0.15142
current loss = 0.16950
current loss = 0.13368
current loss = 0.21758
current epoch = 3
current loss = 0.25709
current loss = 0.19445
current loss = 0.13137
current loss = 0.11100
current loss = 0.12425
current loss = 0.22953
current epoch = 4
current loss = 0.12090
current loss = 0.20553
current loss = 0.11617
current loss = 0.09296
current loss = 0.09327
current loss = 0.12168

五、测试

total=0
correct=0
for images,labels in test_loader:
    images=Variable(images.view(-1,(28*28)))
    outputs=neural_net(images)
    _,predicts=torch.max(outputs.data,1)
    total+=labels.size(0)
    correct+=(predicts==labels).sum()
print('精度=%.2f'%(100*correct/total))

精度=96.19

完整代码

# 开发时间 ；2021/6/20 0020 22:12
import torch
from torch.utils.data import DataLoader
import torchvision.datasets as da
import torchvision.transforms as transforms
import torch.nn as nn
from torch.autograd import Variable
import numpy as np
batch_size = 100#批大小为100

#minist dataset
train_dataset=da.MNIST(root='/pymnist', #选择数据根目录
                       train=True,      #选择训练数据集
                       transform=transforms.ToTensor(),  #转为tensor
                       download=True)   #从网上下载
test_dataset=da.MNIST(root='/pymnist',  #选择数据根目录
                       train=False,     #选择测试数据集
                       transform=transforms.ToTensor(),  #不考虑使用任何数据预处理
                       download=True)   #从网上下载
#加载数据
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=True)

#定义神经网络各层
input_size = 784 #28*28
hidden_size = 500
out_put= 10 #输出为10个类别

# 创建神经网络模型
class neural_Net(nn.Module):
    def __init__(self, input_size, hidden_size, out_put):
        super(neural_Net, self).__init__()
        self.layer1 = nn.Linear(input_size, hidden_size)  # 从输入到隐藏层的线性处理
        self.layer2 = nn.Linear(hidden_size, out_put)  # 从隐层到输出层的线性处理

    def forward(self, x):
        out = self.layer1(x)  # 输入层到隐藏层的线性计算
        out = torch.relu(out)  # 隐藏层激活
        out = self.layer2(out)  # 输出层，注意，输出层直接接loss
        return out


neural_net= neural_Net(input_size, hidden_size, out_put)
print(neural_net)

# 训练


learning_rate = 1e-1  # 学习率
num_epoches = 5
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(neural_net.parameters(), lr=learning_rate)  # 使用随机梯度下降
for epoch in range(num_epoches):
    print('current epoch = %d' % epoch)
    for i, (images, labels) in enumerate(train_loader):  # 利用enumerate取出一个可迭代对象的内容
        images = Variable(images.view(-1, 28 * 28))
        labels = Variable(labels)

        outputs = neural_net(images)  # 将数据集传入网络做前向计算
        loss = criterion(outputs, labels)  # 计算loss
        optimizer.zero_grad()  # 在做反向传播之前先清除下网络状态
        loss.backward()  # loss反向传播
        optimizer.step()  # 更新参数

        if i % 100 == 0:
            print('current loss = %.5f' % loss.item())

print('finished training')


#测试集准确度测试
#预测
total=0
correct=0
for images,labels in test_loader:
    images=Variable(images.view(-1,(28*28)))
    outputs=neural_net(images)
    _,predicts=torch.max(outputs.data,1)
    total+=labels.size(0)
    correct+=(predicts==labels).sum()
print('精度=%.2f'%(100*correct/total))

总结

期待大家和我交流，留言或者私信，一起学习，一起进步！