pytorch学习笔记1-神经网络基础

pytorch实现一个神经网络的主要步骤：

首先了解输入数据和输出数据的维度，以此来确定网络的结构，和考虑是否对数据进行预处理

1 将数据从numpy类型转为tensor类型（torch.from_numpy（）），再转为variable类型

2 定义网络结构，进行前向传播，可以用Sequential 或 Module（参数也会随之被定义）

3.计算误差函数，pytorch有自带的误差函数，如

4.反向传播，pytorch内反向传播只需要先归零梯度，再使用优化器即可

5.参数的更新，使用优化器即可

主要过程

应用手写字符集的识别

所用的数据量比较大，6w条数据，数据量太大的话，不要一次性读进内存，此时就可以引入数据迭代器，一次读入一个批次的数据，像下图，就是从train_set中一次读入

代码：

import numpy as np
import torch
from torchvision.datasets import mnist # 导入 pytorch 内置的 mnist 数据

from torch import nn
from torch.autograd import Variable
from torch.utils.data import DataLoader

# 使用内置函数下载 mnist 数据集
train_set = mnist.MNIST('./data', train=True, download=True)
test_set = mnist.MNIST('./data', train=False, download=True)

def data_tf(x):
    x = np.array(x, dtype='float32') / 255
    x = (x - 0.5) / 0.5 # 标准化，这个技巧之后会讲到
    x = x.reshape((-1,)) # 拉平
    ##x=x.reshape(784,1)
    x = torch.from_numpy(x)
    return x

#./data表示mnist数据集加载的目录，train为true表示加载训练集，false表示加载测试集，transform=None表示不对数据进行预处理，吃出通过data——tf进行了预处理
train_set = mnist.MNIST('./data', train=True, transform=data_tf, download=True) # 重新载入数据集，申明定义的数据变换
test_set = mnist.MNIST('./data', train=False, transform=data_tf, download=True)


# 使用 pytorch 自带的 DataLoader 定义一个数据迭代器
train_data = DataLoader(train_set, batch_size=64, shuffle=True)
test_data = DataLoader(test_set, batch_size=128, shuffle=False)

net=nn.Sequential(
    nn.Linear(784,400),
    nn.ReLU(),
    nn.Linear(400,200),
    nn.ReLU(),
    nn.Linear(200,100),
    nn.ReLU(),
    nn.Linear(100,10)
    )

#定义loss函数
criterion=nn.CrossEntropyLoss()
#定义优化器，更新参数
optimizer=torch.optim.SGD(net.parameters(),1e-1)#学习率为0.1
for e in range(20):
    train_loss=0
    train_acc=0
    for x,y in train_data:#上文指定了一个批次是64，每个循环从train_data中读取64组数据
        #print(x.shape)
        #print(y.shape)
        x=Variable(x)
        y=Variable(y)
        #前向传播
        out=net(x)
        loss=criterion(out,y)##使用pytorch自带的交叉熵函数计算误差，criterion=nn.CrossEntropyLoss()
        train_loss=train_loss+loss#一次循环只有64组数据的平均误差，我们用的是60000组数据的平均误差
        #反向传播
        optimizer.zero_grad()##归0梯度
        loss.backward()##反向传播
        optimizer.step()##使用优化器更新参数optimizer=torch.optim.SGD(net.parameters(),1e-1)
        train_acc=train_acc+1#大约为948左右，948*64约等于6w
    print("loss:{}".format(train_loss/train_acc))