【无标题】

import torch
import matplotlib.pyplot as plt
import torch.optim as optim
from torch.autograd import Variable
import torch.nn as nn
import numpy as np
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

'''
确定网络结构
输入的维度：in_dim；
第一层神经网络输出的神经元个数n_hidden_1；
第二层神经网络输出的神经元的个数n_hidden_2,
第三层网络输出的神经元的个数out_dim
'''
class simpleNet(nn.Module):
    def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):
        super(simpleNet,self).__init__()
        self.layer1 = nn.Linear(in_dim,n_hidden_1)#Linear线性函数，未包含激励函数
        self.layer2 = nn.Linear(n_hidden_1,n_hidden_2)
        self.layer3= nn.Linear(n_hidden_2,out_dim)
        
    def forward(self,x):#前向输入
        hidden_1_out = self.layer1(x)
        hidden_2_out = self.layer2(hidden_1_out)#第一层神经网络输出作为第二层神经网络输入
        out = self.layer3(hidden_2_out)
        return out

#nn.Sequential将网络的层组合到一起里面,按顺序进行网络构建。
#**层和池化从都不需要参数。
class Activation_Net(nn.Module):
    def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):
        super(Activation_Net,self).__init__()
        self.layer1 = nn.Sequential(
            nn.Linear(in_dim,n_hidden_1),nn.ReLU(True))#nn.Linear(in_dim,n_hidden_1)：线性函数；nn.ReLU(True)：激励函数ReLU
        self.layer2 = nn.Sequential(
            nn.Linear(n_hidden_1,n_hidden_2),nn.ReLU(True))
        self.layer3 = nn.Sequential(nn.Linear(nn_hidden_2,out_dim))
        
    def forward(self,x):
        hidden_1_out = self.layer1(x)
        hidden_2_out = self.layer2(hidden_1_out)
        out = self.layer3(hidden_2_out)  #输出层不能添加**函数，因为输出的结果表示真实的得分
        return out

'''添加标准化'''
class Batch_Net(nn.Module):
    def __init__(self,in_dim,n_hidden_1,n_hidden_2,out_dim):
        super(Baych_Net,self).__init__()
        self.layer1 = nn.Sequential(
            nn.Linear(in_dim,n_hidden_1),
            nn.BatchNorm1d(n_hidden_1),
            nn.ReLU(True))
        self.layer2 = nn.Sequential(
            nn.Linear(n_hidden_1,n_hidden_2),
            nn.BatchNorm1d(n_hidden_2),
            nn.ReLU(True))
        self.layer3 = nn.Sequential(
            nn.Linear(n_hidden_2,out_dim))
            
    def forward(self,x):
        hidden_1_out = self.layer1(x)
        hidden_2_out = self.layer2(hidden_2_out)
        out = self.layer3(hidden_2_out)
        return out

'''模型训练'''
#定义超参数
batch_size = 64
learning_rate = 0.02

#定义图片格式转化为Tenson格式：
'''
1.transforms.Compose()将各种预处理操作组合到一起
2.transform.ToTensor()将图片转换成 PyTorch 中处理的对象 Tensor.在转化的过程中 PyTorch 自动将图片标准化了，也就是说Tensor的范用是(0,1)之间
3.transforms.Normalize()要传入两个参数:均值、方差，做的处理就是减均值，再除以方差。将图片转化到了(-1,1)之间
4.注意因为图片是灰度图，所以只有一个通道，如果是彩色图片，有三个通道，transforms.Normalize([a,b,c],[d,e,f])来表示每个通道对应的均值和方差。
'''
data_tf = transforms.Compose([transforms.ToTensor(),
                              transforms.Normalize([0.5],[0.5])])
#PyTorch 的内置函数 torchvision.datasets.MN工ST 导人数据集
train_dataset = datasets.MNIST(
    root='./data',train=True,transform=data_tf,download=True)
test_dataset = datasets.MNIST(
    root='./data',train=False,transform=data_tf)
#注意：测试集为如下形式，评估的准确率为5.0，损失也很高。为什么：test_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=False)DataLoader(train_dataset, batch_size=batch_size, shuffle=False)
#torch.utils.data.DataLoader 建立一个数据迭代器，传入数据集和 batch size, 通过 shuffle=True 来表示每次迭代数据的时候是否将数据打乱。

#测试集无需打乱顺序；训练集打乱顺序，为了增加训练模型的泛化能力
train_loader = DataLoader(train_dataset,batch_size=batch_size,shuffle=True)
test_loader = DataLoader(test_dataset,batch_size=batch_size,shuffle=False)

#定义模型、损失函数和优化函数
#输入的图片尺寸为28*28；两个隐层分别为300和100；最后输出维度是10，因为是10分类问题。
model = simpleNet(28*28,300,100,10)#简单三层全连接网络  
#可以根据需要选择不同的模型进行分类任务
# model = Activation_Net(28 * 28, 300, 100, 10)
# model = Batch_Net(28 * 28, 300, 100, 10)
if torch.cuda.is_available():
    model = model.cuda()

criterion = nn.CrossEntropyLoss()  #交叉熵损失作为目标函数
optimizer = optim.SGD(model.parameters(),lr=learning_rate) #优化函数为SGD随机梯度下降，lr：学习率

#训练模型
epoch = 0
for data in train_loader:
    img, label = data
#     print(img.size())  #torch.Size([64, 1, 28, 28])
    img = img.view(img.size(0), -1)  #将维度变为(64,1*28*28)----(batch,in_dim)
    if torch.cuda.is_available():
        img = img.cuda()
        label = label.cuda()
    else:
        img = Variable(img)
        label = Variable(label)
    out = model(img)#网络输出
    loss = criterion(out, label)#交叉熵损失函数：网络输出与理想输出进行比较
    print_loss = loss.data.item()
 
    optimizer.zero_grad()#使用交叉熵损失函数对参数进行调整
    loss.backward()#反向传播算法
    optimizer.step()#梯度调整
    epoch+=1#下一次迭代
    if epoch%50 == 0:
        print(f'epoch: {epoch},Train Loss:{loss.data.item():.6f}')  

#模型评估
model.eval()
eval_loss = 0
eval_acc = 0
for data in test_loader:
    img,label = data
    img = img.view(img.size(0),-1)  
    if torch.cuda.is_available():
        # volatile=True表示前向传播时不会保留缓存。测试集不需要做反向传播，所以可以在前向传播时释放掉内存，节约内存空间c
        img = Variable(img,volatile=True).cuda()
        label = Variable(label,volatile=True).cuda()
    else:
        img = Variable(img,volatile=True)
        label = Variable(label,volatile=True)
    out = model(img)
    loss = criterion(out,label)
    eval_loss += loss.data.item() * label.size(0)
    _,pred = torch.max(out,1)
    num_correct = (pred==label).sum()#测试集中正确识别的个数
    eval_acc += num_correct.data.item()
print(f'Test Loss:{eval_loss/(len(test_dataset)):.6f},Acc:{eval_acc/(len(test_dataset)):.6f}')