Pytorch学习笔记

----许涛

Pytorch基础

** Pytorch安装：**

• (1).Pytorch可以登录官网：http://pytorch.org/ ，直接下载安装。
• (2).使用pip安装，要求已经安装好Anaconda，输入命令：pip3 install torchvision。使用此命令需要参考官网提供的python和cuda版本指示：https://pytorch.org/get-started/locally/#pip-1

Tensor数据类型

和Numpy类似，Pytorch中的Tensor也有自己的数据类型定义方式，常用的有：

• torch.FloatTensor：生成浮点型的Tensor，输入参数可以使列表，也可以是一个维度值。如：a = torch.FloatTensor(3,3)，b = torch.FloatTensor([1,2,3,4]),print(a),print(b)
• torch.IntTensor：生成整型的Tensor，输入参数可以使列表，也可以是一个维度值。如：a = torch.IntTensor(3,3)，b = torch.IntTensor([1,2,3,4])
• torch.rand：生成浮点型的随机Tensor，和numpy.rand类似，随机生成的数据在0-1之间均匀分布。如：torch.rand(3,3)
• torch.randn：生成整型的随机Tensor，和numpy.randn类似，随机生成的数据满足均值为0、方差为1的正态分布。
• torch.range：生成浮点型的Tensor，从自定义起始值到自定义结束值。输入参数有三个：起始值、结束值、步长。如：torch.range(1,20,1)
• torch.zeros：生成全零Tensor。

Tensor的运算

Pytorch常用的Tensor运算如下：

• torch.abs：求Tensor的绝对值
• torch.add：对两个Tensor进行加法运算
• torch.clamp：对输入参数按照自定义的范围进行裁剪，裁剪结果为输出。输入参数有三个：分别是需要进行裁剪的Tensor数据类型的变量、裁剪的上边界和才裁剪的下边界。裁剪过程为：输入变量中的每一个元素与上下边界做比较，如果超过，则用边界值代替之。如：a = torch.randn(2,3) print(a) b = torch.clamp(a,-0.1,0.1)
• torch.div：求商
• torch.mul：求积
• torch.pow：求幂
• torch.mm：矩阵乘法
• torch.mv：矩阵与向量之间的乘法

torch and torchvision

torch和torchvision是Pytorch中两个核心的包。

torch是pytorch中的基本的包，很多数据操作的类都包含在torch包中。torch包含的类有：

• torch.Tensor
• torch.Storage
• torch.nn
• torch.nn.functional
• torch.autograd
• torch.optim
• torch.nn.init
• torch.multiprocessing
• torch.legacy
• torch.cuda
• torch.utils.ffi
• torch.utils.data
• torch.utils.model_zoo

torchvision包主要功能是实现数据的处理、导入和预览等。torchvision包含的类有：

• torchvision.datasets
• torchvision.models
• torchvision.transforms
• torchvision.utils

torch.nn

torch.nn包提供了很多与实现神经网络中的具体功能相关的类，包括实现卷基层、池化层、全连接层的方法，防止过拟合的参数归一化方法、Dropout方法，实现激活函数的方法包括线性激活函数、非线性激活函数等等。
使用torch.nn搭建简单模型的代码如下：

使用torch.nn搭建简单模型的代码如下：

import torch
from torch.autograd import Variable
batch_n = 100
hidden_layer = 100
input_data = 1000
output_data = 10

X = Variable(torch.randn(batch_n, input_data), requires_grad = False)
Y = Variable(torch.randn(batch_n, output_data), requires_grad = False)

models = torch.nn.Sequential(torch.nn.Linear(input_data, hidden_layer),
troch.nn.ReLU(),
torch.nn.Linear(hidden_layer, output_data))

在以上代码中，用到的几个函数：

• torch.nn.Sequential：torch.nn.Sequential类是torch.nn中的一种序列容器，通过在容器中嵌套各种实现神经网络的中具体功能相关的类，来完成对神经网络模型的搭建，最主要的是，参数会按照我们定义好的序列自动传递下去。
• torch.nn.Linear：用于定义模型的线性层，完成不同层之间的线性变换。参数有三个，分别是：输入特征、输出特征和是否使用偏置。设置是否使用偏置的参数是一个布尔值，默认为True，即使用偏置。在实际的应用中，只需要将输入的特征数和输出的特征数传递给torch.nn.Linear类，就会自动生成对应维度的权重参数和偏置，对于生成的权重参数和偏置，模型默认使用了一种默认的方法。
• torch.nn.ReLU：一种非线性激活函数，类似于PReLu、LeakyReLU、Tanh、Sigmoid、Softmax等。

下面介绍torch.nn中常用的损失函数：

• torch.nn.MSELoss：均方误差损失函数
• torch.nn.L1Loss：平均绝对误差损失函数
• torch.nn.CrossEntropyLoss：交叉熵损失函数

MSELoss函数调用方式为：loss_function = torch.nn.MSELoss()，loss = loss_function(x,y)，其余损失函数的调用方式类似。即，先对损失函数进行实例化，然后调用计算。

torch.optim

torch.optim中包含了许多自动优化的方法，如SGD、AdaGrad、RMSProp、Adam等。

• torch.optim.Adam：

troch.transforms

在torch.transforms中有大量的数据变换类，其中有很大一部分可以用于实现数据增强。

torch.transforms.Compose

torch.transforms.Compose类可以看做一种容器，能够同时对多种数据进行组合。传入的参数是一个列表，列表中的元素就是对载入的数据进行的各种变换操作。torch.transforms.Compose类常用的数据变化操作有：

• （1）torchvision.transforms.Resize：对目标图片数据按我们要求的大小进行缩放。
  * a.传入参数是一个整型数据，表示缩放的宽度和高度都是这个整型数据的值。
  * b.传入参数是一个类似（h,w）的序列，其中h代表高度，w代表宽度。
• （2）torchvision.transforms.Scale：对目标图片以图片中心为参考点，按要求的大小进行缩放，参数类似于（1）。
• （4）torchvision.transforms.CenterCrop：对目标图片以中心为参考点，按照要求大小进行裁剪，参数类似于（1）。
• （5）torchvision.transforms.RanddomCrop：对目标图片按要求大小进行随机裁剪，参数类似于（1）。
• （6）torchvision.transforms.RandomHorizontalFlip：按随机概率对图片进行水平翻转，概率可以自定义，默认为0.5。
• （7）torchvision.transforms.RandomVerticalFlip：按随机概率对图片进行垂直翻转，，概率可以自定义，默认为0.5。
• （8）torchvision.transforms.ToTensor：将图片数据进行类型转换，将之前构成PIL图片的数据转换成Tensor数据类型的变量，让Pytorch能够对其进行计算和处理。
• （9）torchvision.transforms.ToPILImage：将Tensor变量的数据转换成PIL图片数据，主要是为了方便图片内容的显示。

torch.nn.Conv2d

troch.nn.MaxPool2d

torch.nn.BatchNorm2d

torch.nn.Dropout

torch.utils.data

中文文档地址：https://pytorch-cn.readthedocs.io/zh/latest/package_references/data/

torch.utils.data用来将数据分批。常用的为数据加载器：torch.utils.data.DataLoader，其类的定义为：

class torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, num_workers=0, collate_fn=, pin_memory=False, drop_last=False)

参数：

• dataset (Dataset) – 加载数据的数据集。
• batch_size (int, optional) – 每个batch加载多少个样本(默认: 1)。
• shuffle (bool, optional) – 设置为True时会在每个epoch重新打乱数据(默认: False).
• sampler (Sampler, optional) – 定义从数据集中提取样本的策略。如果指定，则忽略shuffle参数。
• num_workers (int, optional) – 用多少个子进程加载数据。0表示数据将在主进程中加载(默认: 0)
• collate_fn (callable, optional) –
• pin_memory (bool, optional) –
• drop_last (bool, optional) – 如果数据集大小不能被batch size整除，则设置为True后可删除最后一个不完整的batch。如果设为False并且数据集的大小不能被batch size整除，则最后一个batch将更小。(默认: False)

pytroch保存模型

• 第一种（推荐）只保存和加载模型参数：

  torch.save(the_model.state_dict(), PATH)

然后：

the_model = TheModelClass(args, kwargs)
the_model.load_state_dict(torch.load(PATH))  

• 第二种保存和加载整个模型：
  torch.save(the_model, PATH)

然后：

the_model = torch.load(PATH)

pytorch 分类例子

import torch
import torch.nn as nn
import torch.utils.data as data
import matplotlib.pyplot as plt
%matplotlib inline

n_data = torch.ones(100,2)

x0 = torch.normal(2*n_data, 1)
y0 = torch.zeros(100)

x1 = torch.normal(-2*n_data,1)
y1 = torch.ones(100)

x = torch.cat((x0,x1),dim=0).type(torch.FloatTensor) # torch.float32
y = torch.cat((y0,y1),).type(torch.LongTensor) # torch.int64

class Classification(nn.Module):
def init(self, n_input, n_hidden, n_output):
super(Classification, self).init()
self.fc1 = nn.Linear(n_input, n_hidden)
self.fc2 = nn.Linear(n_hidden, n_hidden)
self.fc3 = nn.Linear(n_hidden, n_output)
self.relu = nn.ReLU()

def forward(self,x):
    x = self.fc1(x)
    x = self.relu(x)
    x = self.fc2(x)
    x = self.relu(x)
    x = self.fc3(x)
    return x

cls_net = Classification(2, 10, 2)
optimizer = torch.optim.SGD(cls_net.parameters(), lr=0.02)
loss = torch.nn.CrossEntropyLoss()

dataset = data.TensorDataset(x, y)
loader = data.DataLoader(dataset=dataset,batch_size=10,shuffle=True,num_workers=2)

plt.ion()
for i in range(10):
for D,L in loader:
pred = cls_net(x)
loss_value = loss(pred,y)

    optimizer.zero_grad()
    loss_value.backward()
    optimizer.step()

    if i % 5 == 0:
        plt.cla()
        prediction = torch.max(pred,1)[1]
        predy = prediction.data.numpy()
        targety = y.data.numpy()
        plt.scatter(x.data.numpy()[:,0],x.data.numpy()[:,1],
                   c=predy, s=100, lw=0, cmap='RdYlGn')
        accuracy = float((predy == targety).astype(int).sum() / float(targety.size))
        plt.text(1.5,-4,'Accuarcy={:2}'.format(accuracy),fontdict={'size':20, 'color':'red'})
        plt.pause(0.1)

plt.ioff()
plt.show()

Regression

Pytorch 回归例子

import torch
import torch.nn as nn
import torch.nn.functional as fn
import matplotlib.pyplot as plt

data = torch.linspace(-1,1,100)
x = torch.unsqueeze(data,dim=1)
y = -x.pow(2) + 0.5 * torch.rand(x.size())

class regression(nn.Module):
def init(self, n_input, n_hidden, n_output):
super(regression, self).init()
self.fc1 = nn.Linear(n_input, n_hidden)
self.fc2 = nn.Linear(n_hidden, n_hidden)
self.fc3 = nn.Linear(n_hidden, n_output)
self.relu = nn.ReLU()

def forward(self, x):
    x = self.fc1(x)
    x = self.relu(x)
    x = self.fc2(x)
    x = self.relu(x)
    x = self.fc3(x)
    return x

reg_net = regression(1, 20 ,1)
optimizer = torch.optim.SGD(reg_net.parameters(), lr=0.2)
loss = torch.nn.MSELoss()

plt.ion()
for i in range(200):
pred = reg_net(x)
loss_value = loss(pred,y)

optimizer.zero_grad()
loss_value.backward()
optimizer.step()

if i % 5 == 0:
    plt.cla()
    plt.scatter(x.data.numpy(), y.data.numpy())
    plt.plot(x.data.numpy(), pred.data.numpy())
    plt.text(0.5, 0, 'Loss={:.4}'.format(loss_value.data.numpy()),
            fontdict={'size':20, 'color':'red'})
    plt.pause(0.1)

plt.ioff()
plt.show()

sklearn

train_test_split

在深度学习中train_test_split出现的频率实在是太高了。

train_test_split官方文档：
https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html#sklearn.model_selection.train_test_split

train_test_split()是sklearn.cross_validatino模块中用来随机划分训练集和测试集的。train_test_split是交叉验证中常用的函数，功能是从样本中随机的按比例选取train data和test data，调用形式为：
** X_train,X_test, y_train, y_test = cross_validation.train_test_split(train_data, train_target, test_size=0.4, random_state=0,options) **

参数代表含义:

• train_data：所要划分的样本特征集
• train_target：所要划分的样本结果
• test_size：样本占比，如果是整数的话就是样本的数量
• random_state：是随机数的种子。
• options：默认为：None，额外参数：
  1.shuffle:在数据分离前是否重新洗牌，如果不随机洗牌shuffle=None，此时stratify的参数必须为None
  2.stratify：分层：数组相似或无（默认值=None）如果不是“None”，数据将以分层方式进行拆分，并将其用作类标签。

迭代器

class simple_range(object):
def init(self,num):
self.num = num
def iter(self):
return self
def next(self):
if self.num <= 0:
raise StopIteration
tmp = self.num
self.num -= 1
return tmp

a = simple_range(5)

a.next()

生成器

生成器器是一个有next()方法的对象，序列类型则保存了所有的数据项，它们的访问时通过索引进行的。

def infinte():
n = 1
while 1:
yield n #不加这一行的话，程序就进入了死循环
n += 1

ge = infinte()

next(ge)

使用生成器返回闰年

def getyear(start,end):
for i in range(start,end+1):
if i%4==0 and i%100 != 0:
yield i
elif i%400 == 0 :
yield i

year_gen = getyear(1900,2000)

next(year_gen)

os.path

• os.path.dirname:用于返回一个目录的目录名，输入参数为文件的目录
• os.path.exists：用于测试输入参数指定的文件是否存在
• os.path.isdir：用于测试输入参数是否为目录名
• os.path.isfile：用于测试输入参数是否是一个文件
• os.path.samefile：用于测试两个输入的路径参数是否指向同一个文件
• os.path.split：用于对输入参数中的目录名进行分割，返回一个元组，该元组由目录名和文件名组成，如：os.path.split(‘e:\atk\imet_xt.doc’)
• os.path.join：组合路径，如：os.path.join(‘e:\atk’,‘learn’)
• os.name:显示操作系统类型:nt-windows;posix-linux
• os.environ：查看系统环境变量

os方法执行shell命令

使用os模块system()方法可以执行shell命令,正常执行会返回0。使用格式：os.system(“bash command”)。如：os.system(‘ping www.baidu.com’)
注意：在非控制台编写时（如notebook编写），system只会调用系统命令而不会执行，执行结果可通过popen()函数返回file对象进行读取获得。

os操作目录及文件

• os.getcwd()：获取当前目录
• os.chdir()：更改当前脚本目录
• os.listdir(path)：列举目录下所有文件
• os.makedir（path）：创建单个目录
• os.makedirs（path）：创建多级目录，如：makedirs(’./dir1/dir2/dir3’)
• os.rmdir（path)：删除目录
• os.removedirs(path)：删除多级目录
• os.rename(‘文件或者目录名’,‘要修改成的文件或目录名称’)
• os.path.abspath(path)：获取绝对路径，如：os.path.abspath(’./’)

os表现形式参数

• os.sep：文件分隔符号
• os.extsep
• os.pathsep：路径分隔符
• os.linesep：行分隔符

os.sep

help(dict)