pytorch张量（Tensor）的创建和常用方法

• 导入pytorch包

import torch

• 查看版本号

torch.__version__
'1.7.1'

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

1. 张量创建方法

使用pytorch 张量创建函数：torch.tensor() 进行创建：

# 通过列表创建张量
t = torch.tensor([1, 2])
t
tensor([1,2])

# 通过元组创建张量
torch.tensor((1,2))
tensor([1,2])

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

注： 通过上述返回结果可知张量也具有dtype类型

2.张量的类型

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

a.type
dtype('int32')

t.dtype
torch.int64

t1.dtype
torch.int32

通过上述输出可以看出数组默认创建int32（整型）类型，而张量则默认创建int64（长整型）类型

np.array([1.1, 2.2]).dtype
dtype('float64')

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

torch.tensor([1.1,2.2]).dtype
torch.float32

相对的，创建浮点型数组时，张量默认创建float32(单精度浮点型)，而Array则默认为float64(双精度浮点型)。
除了数值型张量外，常用的常量类型还有布尔型张量

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

t2.dtype
torch.bool

pytorch中tensor类型：

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

可以在张量创建过程中指定dtype：

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

pytoch中也支持复数类型对象创建

a = torch.tensor([1 + 2j])
a
tensor([1.+2.j])

3.张量类型的转化

• 张量类型的隐式转化
  当张量各元素属于不同类型时，系统会自动进行隐式转换

# 浮点型和整数型的隐式转化
torch.tensor([1.1, 2]).dtype
torch.float32

# 布尔型和数值型的隐式转化
torch.tensor([Truen, 2.0])
tensor([1., 2.])

• 张量类型的转化方法
  可以使用.float()、.int()等方法对张量类型进行转化

t
tensor([1, 2])

# 转化为默认浮点型（32位）
t.float()
tensor([1., 2.])

# 转化为双精度浮点型
t.double()
tensor([1., 2.], dtype=torch.float64)
t.dtype
torch.int64

# 转化为16位整数
t.short()
tensor([1,2],dtype=torch.int16)

注：

• 当torch函数中使用dtype参数时，需要输入torch.float表示精度；
• 在使用方法进行类型转化是，方法名称为double。

二、张量的维度与形变

1. 创建高维张量

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

t1 = torch.tensor([1, 2])
t1
tensor([1, 2])

# 使用ndim属性查看张量维度
t1.ndim
1

# 使用shape查看形状
t1.shape
torch.Size([2])

# 和size函数相同
t1.size()
torch.Size([2])

注： 和numpy不同，pytorch中的size方法返回的结果和shape属性返回结果一致
此外，还需要注意有两个常用的函数/方法，用来查看张量形状

# 返回拥有几个维元素
len(t1)
2

# 返回总共有几个数
t1.numel()
2

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

• 创建二维张量

# 用复合list创建二维张量
t2 = torch.tensor([[1, 2], [3, 4]])
t2
tensor([[1, 2],[3, 4]])

t2.ndim
2

t2.shape
torch.Size([2,2])

t2.size()
torch.Size([2, 2])

len(t2)
2

注： 这里的2代表t2由两个一维张量生成

t2.numel()
4

注： 这里的4代表t2由4个数构成

• 0维张量

t = torch.tensor(1)
t
tensor(1)

t.ndim
0

t.shape
torch.Size([])

t.numel()
1

注： python的原生数值对象是不能存在于GPU上的，但是0位张量可以。从学术名称来说，Python中单独一个数是scalars（标量），而零维的张量则是tensor。

• 高维张量
  一般来说，三维及三维以上的张量，称之为高维张量。高维张量最常用的是3维张量，可以看做是二维数组或矩阵的合集

a1 = np.array([[1, 2, 2], [3, 4, 4]])
a1
array([[1, 2, 2],[3, 4, 4]])

a2 = np.array([[5, 6, 6], [7, 8, 8]])
a2
array([[5, 6, 6],[7, 8, 8]])

# 由两个形状相同的二维数组创建一个三维的张量
t3 = torch.tensor([a1, a2])
t3tensor([[[1, 2, 2], [3, 4, 4]],[[5, 6, 6],[7, 8, 8]]]), dtype=torch.int32)

t3.ndim
3

t3.shape
torch.Size([2,2,3])

len(t3)
2

t3.numel()
12

2.张量的形变

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

t2
tensor([[1, 2],[3, 4]])

t2.flatten()
tensor([1, 2, 3, 4])

按行排列拉平

t3
tensor([[[1, 2, 2],[3, 4, 4]],[[5, 6, 6],[7, 8, 8]]], dtype=torch.int32)

t3.flatten()
tensor([1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8], dtype=torch.int32)

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

t
tensor(1)

t.flatten()
tensor([1])

t.flatten().ndim
1

2.2 reshape方法：任意形变

t1
tensor([1, 2])

# 转化为两行，一列向量
t1.reshape(2, 1)
tensor([[1],[2]])

**注：**reshape转化后的维度由该方法输入的参数个数决定

• 转化后生成一维张量

t1.reshape(2)
tensor([1, 2])

t1.reshape(2).ndim
1

# 另一种表达形式
t1.reshape(2, )
tensor([1, 2])

• 转化后生成二维张量

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

t1.reshape(1, 2).ndim
2

• 转化后生成三维张量

t1.reshape(1, 1, 2)
tensor([[[1, 2]]])

t1.reshape(1, 2, 1)
tensor([[[1],[2]]])

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

三、特殊张量的创建方法

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

• 全0张量

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

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

• 全1张量

torch.ones([2, 3])
tensor([[1., 1., 1.],[1., 1., 1.]])

• 单位矩阵

torch.eye(5)
tensor([[1., 0., 0., 0., 0.],[0., 1., 0., 0., 0.],[0., 0., 1., 0., 0.],[0., 0., 0., 1., 0.],[0., 0., 0., 0., 1.]])

• 对角矩阵
  注： 在pytorch中需要使用一维张量去创建对角矩阵

t1
tensor([1, 2])

torch.diag(t1)
tensor([[1, 0],[0, 2]])

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

---------------------------------------------------------------------------TypeError                                 Traceback (most recent call last)<ipython-input-237-314c189cb631> in <module>
----> 1 torch.diag([1, 2])             # 不能使用list直接创建对角矩阵TypeError: diag(): argument 'input' (position 1) must be Tensor, not list

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

torch.rand(2, 3)
tensor([[0.9223, 0.9948, 0.2804],[0.8130, 0.2890, 0.5319]])

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

torch.randn(2, 3)
tensor([[-1.2513,  0.6465, -2.3011],[ 0.8447,  1.6856,  1.3615]])

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

torch.normal(2, 3, size=(2, 2))      #均值为2， 标准差为3的张量
tensor([[2.4660, 1.4952],[6.0202, 0.7525]])

• randint: 整数随机采样结果

torch.randint(1, 10, [2, 4])                       # 在1-10之间随机抽取整数， 组成两行四列举证
tensor([[5, 8, 8, 3],[6, 1, 4, 2]])

• arange/linespace: 生成数列

torch.arange(5)                        # 和range相同
tensor([0, 1, 2, 3, 4])

torch.arange(1, 5, 0.5)                             # 从1到5（左闭右开），每隔0.5取值一个
tensor([1.0000, 1.5000, 2.0000, 2.5000, 3.0000, 3.5000, 4.0000, 4.5000])

torch.linspace(1, 5, 3)                              # 从1到5（左右都包含），等距离取三个数
tensor([1., 3., 5.])

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

torch.empty(2, 3)
tensor([[0.0000e+00, 1.7740e+28, 1.8754e+28],[1.0396e-05, 1.0742e-05, 1.0187e-11]])

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

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

2.创建指定形状的数组

使用“_like”创建指定形状的数组：

t1
tensor([1, 2])

t2
tensor([[1, 2],[3, 4]])

torch.full_like(t1, 2)                        # 根据t1形状，填充数量2
tensor([2, 2])

torch.randint_like(t2, 1, 10)
tensor([[4, 8],[5, 8]])

torch.zeros_like(t1)
tensor([0, 0])

注：
“_like”类型转换需要注意转化前后数据类型的一致问题

torch.randn_like(t1)								# t1是整数，而转化后将变为浮点数，因此该代码报错

---

RuntimeError                              Traceback (most recent call last)<ipython-input-285-82e06104e8a8> in <module>
----> 1 torch.randn_like(t1)RuntimeError: "normal_kernel_cpu" not implemented for 'Long'

t10 = torch.tensor([1.1, 2.2])             # 重新生成一个新的浮点型张量
t10
tensor([1.1000, 2.2000])

torch.randn_like(t10)
tensor([1.0909, 0.0379])

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

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

t1
tensor([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

t1.numpy()
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10], dtype=int64)

# 当然，也可以通过np.array函数直接转化为array
np.array(t1)
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10], dtype=int64)

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

t1.tolist()
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

• list函数：张量转化为列表

list(t1)
[tensor(1),tensor(2),tensor(3),tensor(4),tensor(5),tensor(6),tensor(7),tensor(8),tensor(9),tensor(10)]

**注：**此时转化的列表是由一个个0位张量构成的列表，而非张量数值组成的列表。

• .item()方法：转化为数值

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

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

n.item()
1

五、张量的深拷贝

使用clone方法进行深拷贝

t1
tensor([ 1, 2,  3,  4,  5,  6,  7,  8,  9, 10 ])

t11 = t1                                 # t11是t1的浅拷贝
t11
tensor([ 1, 2,  3,  4,  5,  6,  7,  8,  9, 10])

t1[1]
tensor(2)

t1[1] = 10
t1
tensor([1, 10,  3,  4,  5,  6,  7,  8,  9, 10])

t11                                                         # t11被同步修改
tensor([ 1, 10,  3,  4,  5,  6,  7,  8,  9, 10])

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

t11 = t1.clone()
t1
tensor([1, 10,  3,  4,  5,  6,  7,  8,  9, 10])

t11
tensor([ 1, 10,  3,  4,  5,  6,  7,  8,  9, 10])

t1[0]
tensor(1)

t1[0] = 100
t1
tensor([100,  10,   3,   4,   5,   6,   7,   8,   9,  10])

t11
tensor([ 1, 10,  3,  4,  5,  6,  7,  8,  9, 10])