Pytrch基础-Day1

Pytrch基础-Day1

—基本概念

1. 什么是Pytorch，为什么Pytorch？

   PyTorch是一个基于torch深度学习框架。为什么选择Pytorch，优点在于
             a.可用GPU或CPU优化（CUDA）
             b.自动求导
             c.易上手（Python优先）
   

   • Pytroch的安装
     安装参见官网 [https://pytorch.org/get-started/locally/]，选择自己对应的环境，一般有Conda和pip两种方式，未用Conda，
     用pip安装，
     显卡不支持CUDA9.0，选None

   • 配置Python环境

     已装Python3.7 Path已加（未用Anaconda ）
     pass

   • 准备Python管理器
     Notepad++

   • 通过命令行安装PyTorch
     cmd命令行输入

pip3 install https://download.pytorch.org/whl/cpu/torch-1.1.0-cp37-cp37m-win_amd64.whl
pip3 install torchvision

• PyTorch基础概念
  Torch
  Tensor （张量）：张量是有大小和多个方向的量，方向就是指张量的阶数。在PyTorch中，Tensor是一种重要的数据结构，可认为它是一个高维数组，其可以是一个数（标量）、一维数组（向量）、二维数组（矩阵）以及更高维的数组。它和Numpy的ndarrays类似，但Tensor可通过.cuda 方法转为GPU的Tensor，从而使用GPU加速运算。
  

• autograd: 自动微分
  深度学习的算法本质上是通过反向传播求导数，而PyTorch的autograd模块则实现了此功能。在Tensor上的所有操作，autograd都能为它们自动提供微分，避免了手动计算导数的复杂过程。要想使得Tensor使用autograd功能，只需要设置tensor.requries_grad=True
  PyTorch 中所有神经网络的核心是 autograd 包，torch.Tensor是这个包的核心类

2. 通用代码实现流程(实现一个深度学习的代码流程)
   按照教程实现了一遍Mnist手写数字识别
   基本流程如下
   a.导包
   b.定义超参数
   c.获得训练和测试数据
   d.定义神经网络
   e.优化器
   f.封装测试和训练函数
   g.开始训练测试

参考 MNIST数据集手写数字识别

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
torch.__version__


BATCH_SIZE=512 #大概需要2G的显存
EPOCHS=20 # 总共训练批次
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 让torch判断是否使用GPU，建议使用GPU环境，因为会快很多


train_loader = torch.utils.data.DataLoader(
        datasets.MNIST('data', train=True, download=True, 
                       transform=transforms.Compose([
                           transforms.ToTensor(),
                           transforms.Normalize((0.1307,), (0.3081,))
                       ])),
        batch_size=BATCH_SIZE, shuffle=True)


test_loader = torch.utils.data.DataLoader(
        datasets.MNIST('data', train=False, transform=transforms.Compose([
                           transforms.ToTensor(),
                           transforms.Normalize((0.1307,), (0.3081,))
                       ])),
        batch_size=BATCH_SIZE, shuffle=True)

class ConvNet(nn.Module):
    def __init__(self):
        super().__init__()
        # 1,28x28
        self.conv1=nn.Conv2d(1,10,5) # 10, 24x24
        self.conv2=nn.Conv2d(10,20,3) # 128, 10x10
        self.fc1 = nn.Linear(20*10*10,500)
        self.fc2 = nn.Linear(500,10)
    def forward(self,x):
        in_size = x.size(0)
        out = self.conv1(x) #24
        out = F.relu(out)
        out = F.max_pool2d(out, 2, 2)  #12
        out = self.conv2(out) #10
        out = F.relu(out)
        out = out.view(in_size,-1)
        out = self.fc1(out)
        out = F.relu(out)
        out = self.fc2(out)
        out = F.log_softmax(out,dim=1)
        return out

model = ConvNet().to(DEVICE)
optimizer = optim.Adam(model.parameters())


def train(model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if(batch_idx+1)%30 == 0: 
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.item()))



def test(model, device, test_loader):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += F.nll_loss(output, target, reduction='sum').item() # 将一批的损失相加
            pred = output.max(1, keepdim=True)[1] # 找到概率最大的下标
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))



for epoch in range(1, EPOCHS + 1):
    train(model, DEVICE, train_loader, optimizer, epoch)
    test(model, DEVICE, test_loader)