一起来学PyTorch——PyTorch基础

大家好，今天开始想整理一下PyTorch的内容，开始的基础知识可能更像书上写得内容，没有什么个人的理解。希望各位同学、同行们可以一起交流，随着更新的进行之后也会逐渐加入个人的理解。欢迎大家共同探讨。

基本数据（Tensor）

Tensor，我们称作张量，是PyTorch中的基本操作对象，实际上就是一个多维数组。从使用的角度来看，Tensor和Numpy中的ndarrays非常类似，相互之间也可以互相转换。

1. Tensor数据类型

在使用时，Tensor可以有不同的数据类型，官方给出了7种CPU类型和8种GPU类型，在使用时可以根据网络模型所需要的精度与显存容量，合理的进行选取。

PyTorch可以使用set_default_tensor_type函数设置使用的Tensor类型。

# 使用上表中的64位浮点类型（torch.DoubleTensor)
torch.set_default_tesor_type('torch.DoubleTensor')

对于Tensor之间的类型转换，可以通过type(new_type)、type_as()、int()等多种方式进行操作，尤其是type_as()函数，最为常用。

#创建新Tensor，默认类型为torch.FloatTensor
>>> a = torch.Tensor([[1, 2], [3, 4])
>>> a 
tensor([[1, 2],
        [3, 4]])

# 使用int(), float(), double()等直接进行数据类型的转换
>>> b = a.double()
>>> b
tensor([[1, 2],
        [3, 4]], dtype=torch.float64)

# 使用type()函数
>>> c = a.type(torch.DoubleTensor)
>>> c
tensor([[1, 2],
        [3, 4]], dtype=torch.float64)

#使用type_as()函数
>>> d = a.type_as(b)
>>> d
tensor([[1, 2],
        [3, 4]], dtype=torch.float64)

2. Tensor的创建与维度查看

Tensor有多种创建方法，如基础的构造函数Tensor(),还有多种与Numpy十分相似的方法，如ones(), eye(), zeros()和randn()等。

#最基础的Tensor()函数创建方法，参数为Tensor的每一维的大小
a = torch.Tensor(2, 2)

# 使用Python的list进行创建
b = torch.Tensor([[1, 2], [3, 4]])

# 使用zeros(), ones()创建
c = torch.zeros(2, 2)
d = torch.ones(2, 2)

# 使用eye()函数，对角线元素为1， 不要求行列数相同，生成二维矩阵
e = torch.eye(2, 2)

# 使用arange(start, end, step)函数，表示从start到end， 间距为step，一维向量。
f = torch.arange(1, 6, 2) #f为 tensor([1, 3, 5])

# 使用linspace(start, end, steps)函数，表示从start到end，一共steps份，一维向量。
g = torch.linspace(1, 6, 2) # g为tensor([1, 6])

# 使用randperm(num)函数,生成长度为num的随机排列向量
h = torch.randperm(4)

对于Tensor的维度，可以使用Tensor.shape()或者Tensor.size()查看每一维的大小。

对于Tensor的元素总个数，可以使用Tensor.numel()或者Tensor.nelement()查看。

3. Tensor的组合与分块

组合与分块是将Tensor相互叠加或者分开，是十分常用的两个功能，Pytorch提供了多种操作函数。

组合中的torch.cat()函数，是指沿着已有的数据的某一维度进行拼接，操作后，数据的总维度不变。而且在进行拼接时，其他维度必须相同。而tensor.stack()函数将新增维度。

#创建两个 2*2 的Tensor
>>> a = torch.Tensor([1, 2], [3, 4])
>>> b = torch.Tensor([5, 6], [7, 8])

# 以第一维进行拼接，则变成 4*2 的矩阵
>>> torch.cat([a, b], 0)
tensor([[1, 2],
        [3, 4],
        [5, 6],
        [7, 8]])

#　以第二维进行拼接，则变成　2*4　的矩阵
>>> torch.cat([a, b], 1)
tensor([[1, 2, 5, 6],
        [3, 4, 7, 8]])

# 以第0维进行stack，叠加的基本单位为序列本身，即a与b，输出[a, b]， 维度为2*2*2
>>> torch.stack([a, b], 0)
tensor([
        [[1, 2], 
         [3, 4]],
        [[5, 6],
         [7, 8]]
                ])

# 以第1维进行stack，叠加的基本单位为每一行，输出2*2*2
>>> torch.stack([a, b], 1)
tensor([
        [[1, 2],
         [5, 6]],
        [[3, 4],
         [7, 8]]
                ])

#以第2维进行stack，叠加的基本单位为每一行的每一个元素，输出2*2*2
>>> torch.stack([a, b], 2)
tensor([[[1, 5],
         [2, 6]],
        [[3, 7],
         [4, 8]]
                ])

分块是将Tensor分割成不同的子Tensor，主要有torch.chunk()与torch.split()两个函数。chunk函数需要指定分块的数量，而split函数需要指定每一块的大小。

>>> a = torch.Tensor([[1, 2, 3],  [4, 5, 6]])
>># 使用chunk，沿着第-0维进行分块，一共分两块，因此分割成两个1 1*3的的 的Tensor
>>> trochorch.chunk(a, 2, 0)
(tensor[([[1, 2, 3]]), tensor([4, 5, 6]])

#　沿着第1维进行分块，因此分割成两个Tensor，当不能整除时，最后一个的维数会小于前面的
#　因此第一个Tensor为 2*2，第二个为2*1
>>> torch.chunk(a, 2, 1)
(tensor([[1, 2], [4, 5]]), tensor([[3,], [6,]])

# 使用split，沿着第0维分块，每一块维度为2，由于第一维维度总共为2，因此相当于没有分割
>>>　torch.split(a, 2, 0)
(tensor([[1, 2, 3], [4, 5, 6]]), )

# 沿着第1维分块，每一块维度为2，因此第一个Tensor为2*2，第二个为2*1
>>>　torch.split(a, 2, 1)
(tensor([[1, 2], [4, 5]]), tensor([[3, ], [6, ], ]))

# split也可以根据输入的list进行自动分块，list中的元素代表了每一个快占的维度
>>> torch.split(a, [1, 2], 1)
(tensor([[1, ],[4, ]]), tensor([[2, 3], [5, 6]]) )

4. Tensor的索引与变形

Tensor的索引操作和numpy非常相似，主要包括下标索引、表达式索引、使用torch.where(),Tensor.clamp()的选择性索引。

>>> a = torch.Tensor([[0,1], [2, 3]])
>>> a
tensor([[ 0., 1.], [ 2., 3.]])

# 根据下标进行索引
>>> a[1]
tensor([ 2., 3.])
>>> a[0,1]
tensor(1.)

# 选择a中大于0的元素，返回和a相同大小的Tensor，符合条件的置1，否则置0
>>> a>0
tensor([[ 0, 1],
[ 1, 1]], dtype=torch.uint8)

# 选择符合条件的元素并返回，等价于torch.masked_select(a, a>0)
>>> a[a>0]
tensor([ 1., 2., 3.])

# 选择非0元素的坐标，并返回
>>> torch.nonzero(a)
tensor([[ 0, 1],
[ 1, 0],
[ 1, 1]])

# torch.where(condition, x, y)，满足condition的位置输出x，否则输出y
>>> torch.where(a>1, torch.full_like(a, 1), a)
tensor([[ 0., 1.],
[ 1, 1.]])

# 对Tensor元素进行限制可以使用clamp()函数，示例如下，限制最小值为1，最大值为2
>>> a.clamp(1,2)
tensor([[ 1., 1.],
[ 2., 2.]])

变形操作是指改变Tensor的维度，以适应在深度学习的计算中，数据维度经常变换的需求，是一种非常重要的基本操作。

• view(), resize(), reshape()

在不改变Tensor数据的前提下任意改变Tensor的形状，必须保证调整前后的元素总数相同。

>>> a=torch.arange(1,5)
>>> a
tensor([ 1., 2., 3., 4.])
# 分别使用view()、resize()及reshape()函数进行维度变换
>>> b=a.view(2,2)
>>> b
tensor([[ 1., 2.],
[ 3., 4.]])
>>> c=a.resize(4,1)
>>> c
tensor([[ 1.],
[ 0.],
[ 0.],
[ 4.]])
>>> d=a.reshape(4,1)
>>> d
tensor([[ 1.],
[ 0.],
[ 0.],
[ 4.]])
# 改变了b、c、d的一个元素，a也跟着改变了，说明两者共享内存
>>> b[0,0]=0
>>> c[1,0]=0
>>> d[2,0]=0
>>> a
tensor([ 0., 0., 0., 4.])

• transpose(), permute() 函数

transpose（）函数可以将指定的两个维度的元素进行转置，而permute（）函数可以按照给定的维度进行维度变换。

>>> a=torch.randn(2,2,2)
>>> a
tensor([[[-0.9268, 0.6006],
[ 1.0213, 0.5328]],
[[-0.7024, 0.7978],
[ 1.0553, -0.6524]]])

# 将第0维和第1维的元素进行转置
>>> a.transpose(0,1)
tensor([[[-0.9268, 0.6006],
[-0.7024, 0.7978]],
[[ 1.0213, 0.5328],
[ 1.0553, -0.6524]]])

# 按照第2、1、0的维度顺序重新进行元素排列
>>> a.permute(2,1,0)
tensor([[[-0.9268, -0.7024],
[ 1.0213, 1.0553]],
[[ 0.6006, 0.7978],
[ 0.5328, -0.6524]]])

• squeeze(), unsqueeze()函数

在实际的应用中，经常需要增加或减少Tensor的维度，尤其是维度 为1的情况，这时候可以使用squeeze()与unsqueeze()函数，前者用于去除 size为1的维度，而后者则是将指定的维度的size变为1。

>>> a=torch.arange(1,4)
>>> a.shape
torch.Size([3])
# 将第0维变为1，因此总的维度为1、3
>>> a.unsqueeze(0).shape
torch.Size([1, 3])
# 第0维如果是1，则去掉该维度，如果不是1则不起任何作用
>>> a.unsqueeze(0).squeeze(0).shape
torch.Size([3])

• expand(), expand_as() 函数

有时需要采用复制元素的形式来扩展Tensor的维度，这时expand就 派上用场了。expand()函数将size为1的维度复制扩展为指定大小，也可 以使用expand_as()函数指定为示例Tensor的维度。

>>> a=torch.randn(2,2,1)
>>> a
tensor([[[ 0.5379],
[-0.6294]],
[[ 0.7006],
[ 1.2900]]])
# 将第2维的维度由1变为3，则复制该维的元素，并扩展为3
>>> a.expand(2,2,3)
tensor([[[ 0.5379, 0.5379, 0.5379],
[-0.6294, -0.6294, -0.6294]],
[[ 0.7006, 0.7006, 0.7006],
[ 1.2900, 1.2900, 1.2900]]])

5. Tensor的排序与取极值

比较重要的是排序函数sort()，选择沿着指定维度进行排序，返回排 序后的Tensor及对应的索引位置。max()与min()函数则是沿着指定维度 选择最大与最小元素，返回该元素及对应的索引位置

>>> a=torch.randn(3,3)
>>> a
tensor([[ 1.0179, -1.4278, -0.0456],
[-1.1668, 0.4531, -1.5196],
[-0.1498, -0.2556, -1.4915]])

# 按照第0维即按行排序，每一列进行比较，True代表降序，False代表升序
>>> a.sort(0, True)[0]
tensor([[ 1.0179, 0.4531, -0.0456],
[-0.1498, -0.2556, -1.4915],
[-1.1668, -1.4278, -1.5196]])
>>> a.sort(0, True)[1]
tensor([[ 0, 1, 0],
[ 2, 2, 2],
[ 1, 0, 1]])

# 按照第0维即按行选取最大值，即将每一列的最大值选取出来
>>> a.max(0)
(tensor([ 1.0179, 0.4531, -0.0456]), tensor([ 0, 1, 0]))

对于Tensor的单元素数学运算，如abs()、sqrt()、log()、pow()和三 角函数等，都是逐元素操作（element-wise），输出的Tensor形状与原始 Tensor形状一致。

对于类似求和、求均值、求方差、求距离等需要多个元素完成的操 作，往往需要沿着某个维度进行计算，在Tensor中属于归并操作，输出 形状小于输入形状。牢记！！与numpy很相似。