pytorch【神经网络训练minst-fashion数据集】

#导入我们相关的库和数据集
import  torchvision
import torchvision.transforms as transforms

#dataloader/TensorDataset-对数据的结构，归纳方式进行变换
#torchvision.transforms对数据集的数字本身惊醒修改

#实例化数据
mnist=torchvision.datasets.FashionMNIST(
    root="//UsersDocuments/MINST-FASHION"#你的计算机上的某个目录#当我们填写这个目录之后，它会在我们的目录当中寻找这个数据集
    #如果上面的root种没有数据集的话，它就会将其下载到你的root目录下
    ,download=False
    #这个数据是不是用来训练的
    ,train=True
    #重要的必填的参数。
    #将传入的数据集变成张量传入
    ,transform=transforms.ToTensor()
)

#会返回给你关于这个数据集的一些说明
mnist

Dataset FashionMNIST
    Number of datapoints: 60000
    Root location: //Users/Documents/MINST-FASHION
    Split: Train
    StandardTransform
Transform: ToTensor()

#查看有多少个样本
len(mnist)

60000

#查看其中的数据
mnist.data

tensor([[[0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         ...,
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0]],

        [[0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         ...,
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0]],

        [[0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         ...,
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0]],

        ...,

        [[0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         ...,
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0]],

        [[0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         ...,
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0]],

        [[0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         ...,
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0]]], dtype=torch.uint8)

#查看我们数据的结构
#sample_size ,H-height,W-width
mnist.data.shape

torch.Size([60000, 28, 28])

#查看标签
mnist.targets

tensor([9, 0, 0,  ..., 3, 0, 5])

#查看一共有多少个不同类别的标签
mnist.targets.unique()

tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

#查看每一个标签对应的类别
mnist.classes

['T-shirt/top',
 'Trouser',
 'Pullover',
 'Dress',
 'Coat',
 'Sandal',
 'Shirt',
 'Sneaker',
 'Bag',
 'Ankle boot']

#查看我们的数据集中的图片
import matplotlib.pyplot as plt
import numpy as np

#python中的原生结构是不能够读取tensor的，我们需要将其进行转换
#这个mnist中每一个对象包含了一个特征张量和标签

#查看第0号样本的图像
plt.imshow(mnist[0][0].view(28,28).numpy())#imageshow

plt.imshow(mnist[1][0].view(28,28).numpy())#imageshow

#TensorDataset 不需要，我们这个数据集本身就是打包好的
#小批量的划分

#导入库
import torch
from torch import nn
from torch import optim
from torch.nn import functional as F
from torch.utils.data import DataLoader,TensorDataset
import torchvision
import torchvision.transforms as transforms

#确定数据，确定超参数
#学习率
lr=0.15
#动量参数
gamma=0
#在全部的数据集上运行5次
epochs=10
#每一份中的含有的数据量
bs=128

mnist=torchvision.datasets.FashionMNIST(
    root="//Users/MINST-FASHION"#你的计算机上的某个目录#当我们填写这个目录之后，它会在我们的目录当中寻找这个数据集
    #如果上面的root种没有数据集的话，它就会将其下载到你的root目录下
    ,download=False
    #这个数据是不是用来训练的
    ,train=True
    #重要的必填的参数。
    #将传入的数据集变成张量传入
    ,transform=transforms.ToTensor()
)

#放入迭代的数据结构是什么样的

#划分数据
batchdata=DataLoader(mnist,batch_size=bs,
                     #打乱顺序
                     shuffle=True)

#查看一下特征和标签的形状
for x,y in batchdata:
    print(x.shape)
    print(y.shape)
    break

torch.Size([128, 1, 28, 28])
torch.Size([128])

#（500，,20）-20
#x -四维 （128，28*28）
#输入层的神经元个数
input_=mnist.data[0].numel()#查看这一个张量中一共有多少个元素呢？28*28

#输出层的神经元个数
output_=len(mnist.targets.unique())

#定义神经网络架构
class Model(nn.Module):
    def __init__(self,in_features=10,out_features=2):
        super().__init__()
        #定义一个隐藏层
        self.linear1=nn.Linear(in_features,128,bias=False)
        self.output=nn.Linear(128,out_features,bias=False)

    #向前传播
    def forward(self,x):
        #将图像的所有特征给拉平，让其能够放入神经元中
        #第一个参数传入-1表示我需要对数据结构进行一个改变，-1作为占位符，表示让pytorch帮助我们自动计算-1的这个维度是多少
        x=x.view(-1,28*28)
        sigma1=torch.relu(self.linear1(x))
        sigma2=F.log_softmax(self.output(sigma1),dim=1)
        return sigma2

#定义损失函数，优化算法，梯度下降的流程
#定义一个训练函数
def fit_(net,batchdata,lr=0.01,epochs=5,gamma=0):
    #负对数似然函数
    criterion=nn.NLLLoss()
    #小批量梯度下降
    #神经网络进行实例化之后，我们所有的参数w,b，然后传入学习率，动量参数
    opt=optim.SGD(net.parameters(),lr=lr,momentum=gamma)

    correct=0 #循环开始之前，预测正确的值为0
    samples=0#在循环之前，我一个样本都没有看过
    for epoch in range(epochs):#全部的数据被训练几次
        #索引，特征张量，标签


        for batch_idx,(x,y) in enumerate(batchdata):
            #多分类的数据的标签需要调整成一维，将其调整成样本的数量
            y=y.view(x.shape[0])
            sigma=net.forward(x)#正向传播
            loss=criterion(sigma,y)
            #反向传播
            loss.backward()
            #权重更新
            opt.step()
            opt.zero_grad()

            #求解准确率：全部判断正确的样本数量/总样本量
            yhat=torch.max(sigma,1)[1]#torch.max函数结果中的索引为1的部分，也就是预测出来的标签
            correct+=torch.sum(yhat==y)
            samples+=x.shape[0]
            #每训练一个batch的数据，我们模型见过的数据就会增加x.shape


            if(batch_idx+1)%125==0 or batch_idx==len(batchdata)-1:#每N个batch打印一次
                print("Epoch:{}:[{}/{}({:.0f})%],loss:{:.6f},accuracy:{:.3f}".format(
                                                      epoch+1,
                                                      samples,
                                                      epochs*len(batchdata.dataset),
                                                      100*samples/(epochs*len(batchdata.dataset)),
                                                      loss.data.item(),
                                                      float(100*correct/samples)))
            # 分子代表：已经查看过的数据有多少，
            # 分母代表：在现有的epochs数据下，模型一共需要查看多少数据

#训练与评估
#实例化
torch.manual_seed(420)
net=Model(in_features=input_,out_features=output_)

fit_(net,batchdata,lr=lr,epochs=epochs,gamma=gamma)

Epoch:1:[16000/600000(3)%],loss:0.236640,accuracy:89.981
Epoch:1:[32000/600000(5)%],loss:0.356568,accuracy:89.750
Epoch:1:[48000/600000(8)%],loss:0.363261,accuracy:89.821
Epoch:1:[60000/600000(10)%],loss:0.276292,accuracy:89.833
Epoch:2:[76000/600000(13)%],loss:0.226447,accuracy:89.918
Epoch:2:[92000/600000(15)%],loss:0.264218,accuracy:89.930
Epoch:2:[108000/600000(18)%],loss:0.201081,accuracy:89.969
Epoch:2:[120000/600000(20)%],loss:0.293935,accuracy:89.957
Epoch:3:[136000/600000(23)%],loss:0.196868,accuracy:90.051
Epoch:3:[152000/600000(25)%],loss:0.285641,accuracy:90.057
Epoch:3:[168000/600000(28)%],loss:0.202996,accuracy:90.041
Epoch:3:[180000/600000(30)%],loss:0.315412,accuracy:90.051
Epoch:4:[196000/600000(33)%],loss:0.261344,accuracy:90.062
Epoch:4:[212000/600000(35)%],loss:0.415000,accuracy:90.080
Epoch:4:[228000/600000(38)%],loss:0.274316,accuracy:90.115
Epoch:4:[240000/600000(40)%],loss:0.326621,accuracy:90.126
Epoch:5:[256000/600000(43)%],loss:0.308148,accuracy:90.155
Epoch:5:[272000/600000(45)%],loss:0.243264,accuracy:90.185
Epoch:5:[288000/600000(48)%],loss:0.205354,accuracy:90.218
Epoch:5:[300000/600000(50)%],loss:0.241000,accuracy:90.222
Epoch:6:[316000/600000(53)%],loss:0.282183,accuracy:90.249
Epoch:6:[332000/600000(55)%],loss:0.231662,accuracy:90.274
Epoch:6:[348000/600000(58)%],loss:0.162190,accuracy:90.297
Epoch:6:[360000/600000(60)%],loss:0.283224,accuracy:90.301
Epoch:7:[376000/600000(63)%],loss:0.334327,accuracy:90.320
Epoch:7:[392000/600000(65)%],loss:0.270720,accuracy:90.357
Epoch:7:[408000/600000(68)%],loss:0.239996,accuracy:90.386
Epoch:7:[420000/600000(70)%],loss:0.379344,accuracy:90.386
Epoch:8:[436000/600000(73)%],loss:0.247614,accuracy:90.417
Epoch:8:[452000/600000(75)%],loss:0.234226,accuracy:90.429
Epoch:8:[468000/600000(78)%],loss:0.193927,accuracy:90.449
Epoch:8:[480000/600000(80)%],loss:0.216918,accuracy:90.461
Epoch:9:[496000/600000(83)%],loss:0.237355,accuracy:90.483
Epoch:9:[512000/600000(85)%],loss:0.254329,accuracy:90.498
Epoch:9:[528000/600000(88)%],loss:0.205053,accuracy:90.507
Epoch:9:[540000/600000(90)%],loss:0.151338,accuracy:90.527
Epoch:10:[556000/600000(93)%],loss:0.241480,accuracy:90.552
Epoch:10:[572000/600000(95)%],loss:0.267640,accuracy:90.581
Epoch:10:[588000/600000(98)%],loss:0.275014,accuracy:90.595
Epoch:10:[600000/600000(100)%],loss:0.249724,accuracy:90.601