pytorch-1-4 张量的基础知识和运算

Lesson 1. 张量（Tensor）的创建和常用方法

首次使用，先导入PyTorch包
import torch
查看版本号
torch.version

一、张量（Tensor）的基本创建及其类型

1.张量（Tensor）函数创建方法

张量的最基本创建方法和NumPy中创建Array的格式一致，都是创建函数(序列)的格式：张量创建函数：torch.tensor()

# 通过列表创建张量
t = torch.tensor([1, 2])
t# 通过元组创建张量
torch.tensor((1, 2))import numpy as np
a = np.array((1, 2))
a
# 通过数组创建张量
t1 = torch.tensor(a)
t1

2.张量的类型

张量和数组类似，都拥有dtype方法，可返回张量类型。

# 数组类型
a.dtype
t.dtype
t1.dtype

在这里，我们发现，整数型的数组默认创建int32（整型）类型，而张量则默认创建int64（长整型）类型。

np.array([1.1, 2.2]).dtype
torch.tensor(np.array([1.1, 2.2])).dtype
torch.tensor([1.11, 2.2]).dtype

相对的，创建浮点型数组时，张量默认是float32（单精度浮点型），而Array则是默认float64（双精度浮点型）。
当然，除了数值型张量，常用的常量类型还有布尔型张量，也就是构成张量的各元素都是布尔类型的张量。

t2 = torch.tensor([True, False])
t2
t2.dtype

和数组不同，对于张量而言，数值型和布尔型张量就是最常用的两种张量类型，相关类型总结如下。

PyTorch中Tensor类型

数据类型	dtype
32bit浮点数	torch.float32或torch.float
64bit浮点数	torch.float64或torch.double
16bit浮点数	torch.float16或torch.half
8bit无符号整数	torch.unit8
8bit有符号整数	torch.int8
16bit有符号整数	torch.int16或torch.short
16bit有符号整数	torch.int16或torch.short
32bit有符号整数	torch.int32或torch.int
64bit有符号整数	torch.int64或torch.long
布尔型	torch.bool
复数型	torch.complex64

此外，我们还可以通过dtype参数，在创建张量过程中设置输出结果。

# 创建int16整型张量
torch.tensor([1.1, 2.7], dtype = torch.int16)

当然，在PyTorch中也支持复数类型对象创建

a = torch.tensor(1 + 2j)           # 1是实部、2是虚部
a

3.张量类型的转化

张量类型的隐式转化
和NumPy中array相同，当张量各元素属于不同类型时，系统会自动进行隐式转化。

# 浮点型和整数型的隐式转化
torch.tensor([1.1, 2]).dtype 
# 布尔型和数值型的隐式转化
torch.tensor([True, 2.0])

张量类型的转化方法
当然，我们还可以使用.float()、.int()等方法对张量类型进行转化。

t
# 转化为默认浮点型（32位）
t.float()
# 转化为双精度浮点型
t.double()
t.dtype
# 转化为16位整数
t.short()

Point:

当在torch函数中使用dtype参数时候，需要输入torch.float表示精度；
在使用方法进行类型转化时，方法名称则是double。（虽然torch.float和double都表示双精度浮点型。）

二、张量的维度与形变

张量作为一组数的结构化表示，也同样拥有维度的概念。简答理解，向量就是一维的数组，而矩阵则是二维的数组，以此类推，在张量中，我们还可以定义更高维度的数组。当然，张量的高维数组和NumPy中高维Array概念类似。

1.创建高维张量

用简单序列创建一维数组
包含“简单”元素的序列可创建一维数组。

t1 = torch.tensor([1, 2])
t1
# 使用ndim属性查看张量的维度
t1.ndim
# 使用shape查看形状
t1.shape
# 和size函数相同
t1.size()

注：和NumPy不同，PyTorch中size方法返回结果和shape属性返回结果一致。

此外，还需要注意有两个常用的函数/方法，用来查看张量的形状。

# 返回拥有几个（N-1）维元素
len(t1)
# 返回总共拥有几个数
t1.numel()

**注：**一维张量len和numel返回结果相同，但更高维度张量则不然

用“序列”的“序列”创建二维数组
以此类推，我们还可以用形状相同的序列组成一个新的序列，进而将其转化为二维张量。

# 用list创建二维数组
t2 = torch.tensor([[1, 2], [3, 4]])
t2
t2.ndim
t2.shape             
t2.size()
len(t2)

**理解：**此处len函数返回结果代表t2由两个1维张量构成

t2.numel()

**理解：**此处numel方法返回结果代表t2由总共由4个数构成

“零”维张量
在PyTorch中，还有一类特殊的张量，被称为零维张量。该类型张量只包含一个元素，但又不是单独一个数。

t = torch.tensor(1)
t
t.ndim
t.shape
t.numel()

理解零维张量:
目前，我们可将零维张量视为拥有张量属性的单独一个数。（例如，张量可以存在GPU上，但Python原生的数值型对象不行，但零维张量可以，尽管是零维。）从学术名称来说，Python中单独一个数是scalars（标量），而零维的张量则是tensor。

高维张量
一般来说，三维及三维以上的张量，我们就将其称为高维张量。当然，在高维张量中，最常见的还是三维张量。我们可以将其理解为二维数组或者矩阵的集合。

a1 = np.array([[1, 2, 2], [3, 4, 4]])
a1
a2 = np.array([[5, 6, 6], [7, 8, 8]])
a2# 由两个形状相同的二维数组创建一个三维的张量
t3 = torch.tensor([a1, a2])
t3
t3.ndim
t3.shape          # 包含两个，两行三列的矩阵的张量。
len(t3)
t3.numel()

当然，N维张量的创建方法，我们可以先创建M个N-1维的数组，然后将其拼成一个N维的张量。关于更高维度的张量，我们将在后续遇到时再进行讲解。在张量的学习过程中，三维张量就已经足够。

2.张量的形变

张量作为数字的结构化集合，其结构也是可以根据实际需求灵活调整的。

2.1 flatten拉平：将任意维度张量转化为一维张量

t2
t2.flatten()

按行排列，拉平。

t3
t3.flatten()

注：如果将零维张量使用flatten，则会将其转化为一维张量。

t
t.flatten()
t.flatten().ndim

2.2 reshape方法：任意变形

t1
# 转化为两行、一列的向量
t1.reshape(2, 1)

注意，reshape过程中维度的变化：reshape转化后的维度由该方法输入的参数“个数”决定

转化后生成一维张量

t1.reshape(2)
t1.reshape(2).ndim
# 注，另一种表达形式
t1.reshape(2, )

转化后生成二维张量

t1.reshape(1, 2)        # 生成包含一个两个元素的二维张量
t1.reshape(1, 2).ndim

转化后生成三维张量

t1.reshape(1, 1, 2)        
t1.reshape(1, 2, 1)
# 注意转化过程维度的变化
t1.reshape(1, 2, 1).ndim

Q1：如何利用reshape方法，将t3拉平？

二、特殊张量的创建方法

在很多数值科学计算的过程中，都会创建一些特殊取值的张量，用于模拟特殊取值的矩阵，如全0矩阵、对角矩阵等。因此，PyTorch中也存在很多创建特殊张量的函数。

1.特殊取值的张量创建方法

全0张量
torch.zeros([2, 3]) # 创建全是0的，两行、三列的张量（矩阵）

注：由于zeros就已经确定了张量元素取值，因此该函数传入的参数实际上是决定了张量的形状

全1张量

torch.ones([2, 3])

张量和列表、数组之间的转化

单位矩阵

torch.eye(5)

对角矩阵
略有特殊的是，在PyTorch中，需要利用一维张量去创建对角矩阵。

t1
torch.diag(t1)
torch.diag([1, 2])             # 不能使用list直接创建对角矩阵

rand：服从0-1均匀分布的张量

torch.rand(2, 3)

randn：服从标准正态分布的张量

torch.randn(2, 3)

normal：服从指定正态分布的张量

torch.normal(2, 3, size = (2, 2))            # 均值为2，标准差为3的张量

randint：整数随机采样结果

torch.randint(1, 10, [2, 4])                 # 在1-10之间随机抽取整数，组成两行四列的矩阵

arange/linspace：生成数列

torch.arange(5)                              # 和range相同
torch.arange(1, 5, 0.5)                      # 从1到5（左闭右开），每隔0.5取值一个
torch.linspace(1, 5, 3)                      # 从1到5（左右都包含），等距取三个数

empty：生成未初始化的指定形状矩阵

torch.empty(2, 3)

full：根据指定形状，填充指定数值

torch.full([2, 4], 2)

2.创建指定形状的数组

当然，我们还能根据指定对象的形状进行数值填充，只需要在上述函数后面加上_like即可。

t1
t2
torch.full_like(t1, 2)             # 根据t1形状，填充数值2
torch.randint_like(t2, 1, 10)
torch.zeros_like(t1)

Point:

更多_like函数，可查阅帮助文档；
需要注意一点的是，_like类型转化需要注意转化前后数据类型一致的问题；

torch.randn_like(t1)                  # t1是整数，而转化后将变为浮点数，此时代码将报错
t10 = torch.tensor([1.1, 2.2])        # 重新生成一个新的浮点型张量
t10
torch.randn_like(t10)                 # 即可执行相应的填充转化

三、张量（Tensor）和其他相关类型之间的转化方法

张量、数组和列表是较为相似的三种类型对象，在实际操作过程中，经常会涉及三种对象的相互转化。在此前张量的创建过程中，我们看到torch.tensor函数可以直接将数组或者列表转化为张量，而我们也可以将张量转化为数组或者列表。另外，前文介绍了0维张量的概念，此处也将进一步给出零维张量和数值对象的转化方法。

.numpy方法：张量转化为数组

t1
t1.numpy()
# 当然，也可以通过np.array函数直接转化为array
np.array(t1)

.tolist方法：张量转化为列表

t1.tolist()

list函数：张量转化为列表

list(t1)

需要注意的是，此时转化的列表是由一个个零维张量构成的列表，而非张量的数值组成的列表。

.item()方法：转化为数值
在很多情况下，我们需要将最终计算的结果张量转化为单独的数值进行输出，此时需要使用.item方法来执行。

n = torch.tensor(1)
n
n.item()

四、张量的深拷贝

Python中其他对象类型一样，等号赋值操作实际上是浅拷贝，需要进行深拷贝，则需要使用clone方法

t1
t11 = t1                          # t11是t1的浅拷贝       
t11
t1[1]                             
t1[1] = 10                        # t1修改
t1
t11                               # t11会同步修改

此处t1和t11二者指向相同的对象。而要使得t11不随t1对象改变而改变，则需要对t11进行深拷贝，从而使得t11单独拥有一份对象。

t11 = t1.clone()
t1
t11
t1[0]
t1[0] = 100
t1
t11

本节练习答案：

A1
t3
t3.reshape(t3.numel())

Lesson 2.张量的索引、分片、合并以及维度调整

张量作为有序的序列，也是具备数值索引的功能，并且基本索引方法和Python原生的列表、NumPy中的数组基本一致，当然，所有不同的是，PyTorch中还定义了一种采用函数来进行索引的方式。
而作为PyTorch中基本数据类型，张量即具备了列表、数组的基本功能，同时还充当着向量、矩阵、甚至是数据框等重要数据结构，因此PyTorch中也设置了非常完备的张量合并与变换的操作。