Tensor(张量)

Tensor表示的是一个多维的矩阵。比如零维就是一个点，一维就是向量，二维就是一般的矩阵，多维就相当于一个多维的矩阵。这点和numpy是对应的，pytorch的Tensor可以和numpy的ndarray互相转换。唯一的区别是前者可以在GPU上运行，后者只能在CPU上运行。

Tensor数据类型

：32位浮点型torch.FloatTensor、

64位浮点型torch.DoubleTensor、16位整型torch.ShortTensor、

32位整型torch.IntTensor和64位整型torch.LongTensor。

import torch

a = torch.Tensor([[2,3],[4,8],[7,9]])

print('a:{}'.format(a))

print('a size is {}'.format(a.size()))

输出结果：

a:tensor([[2., 3.],

[4., 8.],

[7., 9.]])

a size is torch.Size([3, 2])

此时定义的torch.Tensor默认是32位浮点型，我们也可以像Numpy一样通过索引的方式取得其中的元素，同时也可以改变它的值，比如将a的第一行第二列变为100。

import torch

a = torch.IntTensor([[2,3],[4,8],[7,9]])

print('a:{}'.format(a))

a[0,1] = 100

print('a:{}'.format(a))

print('a size is {}'.format(a.size()))

输出结果：

a:tensor([[2, 3],

[4, 8],

[7, 9]], dtype=torch.int32)

a:tensor([[ 2, 100],

[ 4, 8],

[ 7, 9]], dtype=torch.int32)

a size is torch.Size([3, 2])

除此之外，还可以在Tensor和numpy.ndarray之间互相转换。

numpy_a = a.numpy()

print('convey to numpy is \n {}'.format(numpy_a))

输出结果：convey to numpy is

[[ 2 100]

[ 4 8]

[ 7 9]]

可以将数据定义为我们需要的特定类型。

import torch

b = torch.IntTensor([[2,3],[4,8],[7,9]])

print('b is :{}'.format(b))

输出结果：

b is :tensor([[2, 3],

[4, 8],

[7, 9]], dtype=torch.int32)

或者也可以创建全是0的空Tensor或者取一个正态分布作为随机初始值：

import torch

c = torch.zeros((3,2))

print('zero tensor is:{}'.format(c))

d = torch.randn((3,2))

print('normal randon is:{}'.format(d))

输出结果：

zero tensor is:tensor([[0., 0.],

[0., 0.],

[0., 0.]])

normal randon is:tensor([[-0.8500, 1.0744],

[ 0.0696, -0.2072],

[-0.6850, 0.0531]])

通过a.numpy()可以将a转换为numpy数据类型，同时使用torch.from_numpy()就能将numpy转换为tensor，如果需要更改tensor的数据类型，只需要转换后的tensor后面加上需要的类型，比如a类型转换为float，只需要a.float()就可以了。

Variable(变量)

variable变量是神经网络计算图里特有的一个概念，variable和tensor本质上没有区别，variable会被放入一个计算图中，然后进行前向传播，反向传播，自动求导。

Variable是在torch.autograd.Variable中，要将一个tensor变成Variable也非常简单，比如想让一个tensor a变成Variable，只需要Variable(a)就可以了。Variable有三个比较重要的组成属性：data,grad和grad_fn。data可以取出variable里面的tensor数值，grad_fn可以得到variable的操作，比如通过加减还是乘除得到的，是variable的反向传播梯度。

import torch

from torch.autograd import Variable

x = Variable(torch.Tensor([1]), requires_grad=True)

w = Variable(torch.Tensor([2]), requires_grad=True)

b = Variable(torch.Tensor([3]), requires_grad=True)

y = w * x + b

y.backward() #自动求导，等价于 y.backward(torch.FloatTensor([1]))

print(x.grad)

print(w.grad)

print(b.grad)

输出结果：

tensor([2.])

tensor([1.])

tensor([1.])

参数requires_grad=True表示对这个变量求梯度，默认是False，也就是不对这个变量求梯度。

也可以对矩阵求导：

import torch

from torch.autograd import Variable

x = torch.randn(3)

x = Variable(x, requires_grad=True)

y = x * 2

print(y)

y.backward(torch.FloatTensor([1,0.1,0.01]))

print(x.grad)

输出结果：

tensor([-2.5607, -0.2617, 1.5490], grad_fn=)

tensor([2.0000, 0.2000, 0.0200])

相当于给出了一个三维向量去做运行。

Dataset(数据集)

处理任何机器学习问题之前都需要数据读取，并进行预处理。torch.utils.data.Dataset是代表这一数据的抽象类，可以自己定义数据类继承和重写，只需要定义_len_和_getitem_这两个函数：

class myDataset(Dataset):

def _init_(self, csv_file, txt_file, root_dir, other_file):

self.csv_data = pd.read_csv(csv_file):

with open(txt_file,'r') as f:

data_list = f.readlines()

self.txt_data = data_list

self.root_dir = root_dir

def _len_(self):

return len(self.csv_data)

def _getitem(self, idx):

data = (self.csv_data[idx], self.text_data[idx])

return data

通过上面的方式，可以定义我们需要的数据类。

nn.Module(模组)

在pytorch里面编写神经网络，所有的层结构和损失函数都来自于torch.nn，所有的模型构建都是从这个基类nn.Module继承的，模板如下：

class net_name(nn.Module):

def __init__(self, other_arguments):

super(net_name, self).__init__()

self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size)

#other network layer

def forward(self, x):

x = self.conv1(x)

return x

这样建立了一个计算图，这个结构可以重复使用多次，每次调用就相当于用该计算图定义的相同参数做一次前向传播。

torch.optim(优化)

在机器学习或深度学习中，我们需要通过修改参数使得损失函数最小化(或最大化)，优化算法就是一种调整模型参数更新的策略。优化算法分为两大类：

1.一阶优化算法

这种算法使用各个参数的梯度值来更新参数，最常用的一阶优化算法就是梯度下降。网格的参数更新公式是：θ = θ - η * (dJ(θ) / dθ)，其中η是学习率，dJ(θ) / dθ是函数的梯度(dJ(θ) / dθ公式应该是求偏导的符号，不好打)；

2.二阶优化算法

二阶优化算法使用了二阶导数来最小化或最大化损失函数，基于牛顿法，但是这种方法的计算成本很高，并没有广泛使用。

模型的保存和加载

使用torch.save来保存模型的结构和参数，有两种保存方式

(1)保存整个模型的结构信息和参数信息，保存的对象是模型model；

(2)保存模型的参数，保存的对象是模型的状态model.state_dict()。

可以这样保存，save的第一个参数是保存对象，第二个参数是保存路径及名称。

torch.save(model,’./model.pth’)

torch.save(mode.state_dict(),’./model.pth’)

加载模型时有两种方式对应于保存模型的方式：

(1)加载完整的模型结构和参数信息，使用load_model = torch.load(‘model.pth’)，在网络较大的时候加载的时间比较长，存储空间也比较大；

(2)加载模型参数信息，需要先导入模型的结构，然后通过model.load_state_dic(torch.load(‘model_state.pth’))来导入。k