pytorch初学习小结(一）

1、Python导入模块的常用形式

在不同的代码中，我们常会看到模块导入部分也不太一样，下面就总结一下这些常用的形式：
1、import 模块名
在程序中直接通过 模块名.函数名 就可以调用。
Example:

import math
s=math.sqrt(25）

2、from 模块名 import *
使用这种方法导入模块，可以直接通过函数名调用模块里的方法，不再需要模块名.函数名。
Example:

from math import *
s=sqrt(5)

注意，使用这种方式导入模块后，如果当前模块与被导入模块有名字相同的函数时，当前模块中的函数会被导入模块中的函数所覆盖。

3、from 模块名 import 函数名
这种方法只能导入模块中的指定函数。
Example:

from math import log 
log(3,9)

4、from 模块名 as 别名
当你导入的模块名字太长，想给它取个别名，以后每次用到它的时候都可以用别名代替它，就可以使用这种方法。
Example:

import datatime as dt
print (dt.datatime.now())

当程序需要导入多个模块时，一般按照python系统标准模块，第三方扩展模块，自定义和开发的本地模块的顺序进行导入。

一些常用的模块

import os
import time
import sys 
import argparse ##argpare 是python标准库里用来处理命令行函数的库
import torch ##pytorch 最基本模块
from torchvision import transforms ##torchvision，该包主要由3个子包组成，分别是：torchvision.datasets、torchvision.models、torchvision.transforms，其中torchvision主要用于数据增强
from torchvision import datasets ##视觉库中，提供了加载数据集的接口
import torch.optim as optim ##优化模块，封装了求解模型的一些优化器
import torch.nn as nn ##pytroch中最重要模块，封装了神经网络的相关模块
from torch.optim.lr_scheduler import StepLR, MultiStepLR ##学习率调整器，在训练过程中合理变动学习率
import torch.nn.functional as F ##提供了一些常用的函数，如softmax
from __future__ import division  ## 导入python未来支持的语言特征division,当我们没有在程序中导入该特征时，“/”执行的是截断除法，导入后执行的是精确除法

2、argparse模块的作用

argparse是python用于解析命令行参数和选项的标准模块。

import argparse ##argpare 是python标准库里用来处理命令行函数的库
parser = argparse.ArgumentParser(description='PyTorch GCN MNIST Training')##创建一个解析对象
parser.add_argument('--epochs', default=50, type=int, metavar='N',help='number of total epochs to run')    ##向该对象中添加你要关注的命令行参数
parser.add_argument('--model', default='', type=str, metavar='NETWORK',help='Network to train')
args = parser.parse_args() ##进行解析

通过argparse可以设置一些参数，例如上述代码中的 epochs,model。每个参数都有默认值，输入 python 文件名.py -h可以获得相关帮助。如果想改变一些参数，即可以用命令行的形式更改，比如我们想设置epochs=20,只需要输入python 文件名.py -epochs=20。

ps: epoch，batchsize, iteration的含义
batchsize：批大小。在深度学习中，一般采用SGD训练，即每次训练在训练集中取batchsize个样本训练；
iteration：1个iteration等于使用batchsize个样本训练一次；
epoch：1个epoch等于使用训练集中的全部样本训练一次.
举个例子，假设训练集有1000个样本，batchsize=10，那么，训练完整个样本集需要100次 iteration，1次 epoch。

3、数据预处理

常用的数据预处理方法主要包括中心化、标准化、PCA、白噪声。pytorch中的torchvision模块提供了数据预处理的常用方法。torchvision主要由3个子包组成，分别是：torchvision.datasets、torchvision.models、torchvision.transforms。
下面以MNIST数据集为例：

normalize = transforms.Normalize((0.1307,), (0.3081,))
train_transform = transforms.Compose([
    transforms.Scale(32),
    transforms.ToTensor(),
    normalize,])
test_transform = transforms.Compose([
    transforms.Scale(32),
    transforms.ToTensor(), 
    normalize,])

标准化处理指的是，data减去它的均值，再除以它的标准差，最终data将呈现均值为0方差为1的数据分布。
在代码中，((0.1307,), (0.3081,))，均值是0.1307，标准差是0.3081，这些系数都是数据集提供方计算好的数据 。这里的MNIST数据集中是灰度图片，所以只有一个通道，如果是彩色图片，有三通道，那么transforms.Normalize([a,b,c],[e,f,g]）来表示每个通道对应的均值和方差。
transform.compose()将各种预处理操作结合到一起。

4、MNIST数据集的下载和读取

首先，通过pytorch的内置函数 torchvision.datasets.MNIST 导入数据集，传入数据预处理。

train_dataset = datasets.MNIST(root=args.dataset_dir, train=True, 
   				download=True, transform=train_transform)
test_dataset = datasets.MNIST(root=args.dataset_dir, train=False, 
                 download=True,transform=test_transform)

然后，通过torch.utils.data.DataLoadar建立一个数据迭代器，传入数据集。

train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size,
                                num_workers=args.workers, pin_memory=True, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=args.batch_size,
                                num_workers=args.workers, pin_memory=True, shuffle=True)

其中比较重要的几个参数，batch_size(每个batch的大小), shuffle(是否进行shuffle操作), num_workers(加载数据的时候使用几个子进程)。

接着导入网络，定义所示函数和优化算法。

model = get_network_fn(args.model)
optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=3e-05)##optim模块中的SGD梯度优化方式---随机梯度下降
scheduler = StepLR(optimizer, step_size=10, gamma=0.5) ##调整学习率
##optimizer(Optimizer对象)--优化器
##step_size(整数类型): 调整学习率的步长,每过step_size次,更新一次学习率
##gamma(float 类型):学习率下降的乘数因子
criterion = nn.CrossEntropyLoss()##交叉熵损失函数

5、函数shuffle与permutation的用法

1、函数shuffle与permutation都是对原来的数组进行重新进行洗牌，区别在于shuffle直接在原来的数组上进行操作，改变原来数组的顺序，没有返回值。而permutation不直接在原来的数组上进行操作，而是返回一个新的打乱的数组，并不改变原来的数组。
Example:

a=np.arange(10)
print a
b=np.random.shuffle(a)
print b
print a

输出结果：

[0 1 2 3 4 5 6 7 8 9]
[8 0 3 2 5 7 1 4 9 6]
[8 0 3 2 5 7 1 4 9 6]

a=np.arange(10）
print a
b=np.random.permutation(a)
print b
print a

输出结果：

[0 1 2 3 4 5 6 7 8 9]
[3 2 5 8 6 9 0 1 7 4]
[0 1 2 3 4 5 6 7 8 9]

2、在多维矩阵中，只对第一维（行）进行打乱操作。
Example:

a=np.arange(9).reshape((3,3))
b=np.random.shuffle(a)
print b

输出结果：

[3 4 5] [0 1 2] [6 7 8]

6、 @once_differentiable有什么用？

from torch.autograd.function import once_differentiable
class GOF_Function(Function):
    @staticmethod #一般来说，要使用某个类的方法，需要先实例化一个对象再调用方法。 而使用@staticmethod或@classmethod，就可以不需要实例化，直接类名.方法名()来调用。 
    def forward(ctx, weight, gaborFilterBank):# 在forward中，需要定义GOF_Function这个运算的forward计算过程
        ctx.save_for_backward(weight, gaborFilterBank)  # 将输入保存起来，在backward时使用
        output = _C.gof_forward(weight, gaborFilterBank)
        return output

    @staticmethod
    @once_differentiable
    def backward(ctx, grad_output):
        weight, gaborFilterBank = ctx.saved_tensors
        grad_weight = _C.gof_backward(grad_output, gaborFilterBank)
        return grad_weight, None 

Pytorch提供了包torch.autograd用于自动求导。在前向过程中PyTorch会构建计算图，每个节点用Variable表示，边表示由输入节点到输出节点的函数（torch.autograd.Function对象）。Function对象不仅负责执行前向计算，在反向过程中，每个Function对象会调用.backward()函数计算输出对输入的梯度，然后将梯度传递给下一个Function对象。但是一些操作是不可导的，当你自定义的函数不可导时，在写backward函数时，就需要使用@once_differentiable。