pytorch Tensor及其基本操作 01

1. Tensor 属性

​

Tensor(张量）的属性

Tensor及其基本操作

1.1 Tensor(张量）的属性

​ 每个 torch.Tensor 对象都有以下几个属性： torch.dtype, torch.device， 和 torch.layout。

torch.dtype

class torch.dtype
1

​ torch.dtype 属性标识了 torch.Tensor的数据类型。PyTorch 有八种不同的数据类型：

torch.device

class torch.device
1

​ torch.device 属性标识了torch.Tensor对象在创建之后所存储在的设备名称，而在对象创建之前此属性标识了即将为此对象申请存储空间的设备名称。

​ torch.device 包含了两种设备类型 ('cpu' 或者 'cuda') ，分别标识将Tensor对象储存于cpu内存或者gpu内存中，同时支持指定设备编号，比如多张gpu，可以通过gpu编号指定某一块gpu。 如果没有指定设备编号，则默认将对象存储于current_device()当前设备中； 举个例子， 一个torch.Tensor 对象构造函数中的设备字段如果填写'cuda'，那等价于填写了'cuda:X'，其中X是函数 torch.cuda.current_device()的返回值。

​ 在torch.Tensor对象创建之后，可以通过访问Tensor.device属性实时访问当前对象所存储在的设备名称。

​ torch.device 对象支持使用字符串或者字符串加设备编号这两种方式来创建：

​ 通过字符串创建：

>>> torch.device('cuda:0')
device(type='cuda', index=0)  # 编号为0的cuda设备

>>> torch.device('cpu')  # cpu内存
device(type='cpu')

>>> torch.device('cuda')  # 当前cuda设备
device(type='cuda')
1
2
3
4
5
6
7
8

​ 通过字符串加设备编号创建：

>>> torch.device('cuda', 0)
device(type='cuda', index=0)

>>> torch.device('cpu', 0)
device(type='cpu', index=0)
1
2
3
4
5

​ 可以通过 to 实现cpu和gpu设备的转换

>>> data = torch.Tensor([1])
>>> data.to('cpu')  #将数据转为cpu格式
>>> data = data.cpu()	 #将数据转为cpu格式
>>> data.to('cuda:0')   #将数据转为cuda格式
>>> data = data.cuda()  #将数据转为cuda格式
1
2
3
4
5

torch.layout

class torch.layout
1

​ torch.layout 属性标识了torch.Tensor 在内存中的布局模式。 现在， 我们支持了两种内存布局模式 torch.strided (dense Tensors) 和尚处试验阶段的torch.sparse_coo (sparse COO Tensors， 一种经典的稀疏矩阵存储方式).

​ torch.strided 跨步存储代表了密集张量的存储布局方式，当然也是最常用最经典的一种布局方式。 每一个strided tensor都有一个与之相连的torch.Storage对象, 这个对象存储着tensor的数据. 这些Storage对象为tensor提供了一种多维的， 跨步的(strided)数据视图. 这一视图中的strides是一个interger整形列表：这个列表的主要作用是给出当前张量的各个维度的所占内存大小，严格的定义就是，strides中的第k个元素代表了在第k维度下，从一个元素跳转到下一个元素所需要跨越的内存大小。 跨步这个概念有助于提高多种张量运算的效率。

>>> x = torch.Tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
>>> x.stride() 
(5, 1)     # 此时在这个二维张量中，在第0维度下，从一个元素到下一个元素需要跨越的内存大小是5，比如x[0] 到x[1]需要跨越x[0]这5个元素, 在第1维度下，是1，如x[0, 0]到x[0, 1]需要跨越1个元素

>>> x.t().stride() # t() 转置
(1, 5)
1
2
3
4
5
6

​ 更多关于 torch.sparse_coo tensors的信息, 请看torch.sparse.

2. Tensor类型操作

2.1 Tensor类型判断

torch.is_tensor(obj)

​ 如果obj是一个PyTorch张量，则返回True.

>>> data = torch.Tensor([1])
>>> torch.is_tensor(data)
True
1
2
3

torch.is_storage(obj)

​ 如果obj是一个PyTorch 存储对象，则返回True.

>>> data = torch.Tensor([1])
>>> data = data.storage()
>>> torch.is_storage(data)
True
1
2
3
4

​ tensor分为头信息区（Tensor）和存储区（Storage）。信息区主要保存着tensor的形状（size）、步长（stride）、数据类（type）等信息，而真正的数据则保存成连续数组，存储在存储区

2.2 类型设置

torch.set_default_dtype(d)

​ 将d设置为默认浮点类型(dtype). 该类型将在 torch.tensor() 中作为类型推断的默认浮点类型。初始默认浮点类型为torch.float32。

>>> torch.tensor([1.2, 3]).dtype           # 初始默认浮点类型为 torch.float32
torch.float32
>>> torch.set_default_dtype(torch.float64)
>>> torch.tensor([1.2, 3]).dtype           # 一个新的浮点类型的张量
torch.float64
1
2
3
4
5

torch.get_default_dtype()

​ 获取当前默认浮点类型。

>>> torch.set_default_dtype(torch.float64)
>>> torch.get_default_dtype()
torch.float64
1
2
3

Tensor.dtype属性

​ 直接获取Tensor对象的dtype属性，返回该Tensor的类型

>>> torch.tensor([1.2, 3]).dtype    # 初始默认浮点类型为 torch.float32
torch.float32
1
2

2.3 类型转换

Tensor.to(…)

Tensor.to(device=None, dtype=None, non_blocking=False, copy=False) → Tensor
1

返回具有特定设备类型和(可选)特定数据类型的张量Tensor.

• 如果传入的参数dtype是None,那么它的取值是由self.dtype推断出来的.
• 当non_blocking是True时,尽可能地(相对于宿主主机)尝试异步式转换,比如:将一个固定内存(pinned memory)的CPU张量转换到CUDA张量.
• 当设置了copy参数时,无论当前张量的数据类型和设备类型是否已经满足当前转换要求,都将创建一个新的张量.

>>> data.to(device='cuda:0')	# data = data.to(device='cuda:0')
tensor([1., 2., 3.], device='cuda:0')
>>> data.to(dtype=torch.float64) 	# data = data.to(dtype=torch.float64)
tensor([1., 2., 3.], dtype=torch.float64)
>>> data
tensor([1., 2., 3.])
1
2
3
4
5
6

3 Tensor 基本属性获取

3.1 基本属性获取

Tensor.size() / Tensor.shape

>>> data = torch.Tensor([[1,2,3],[4,5,6],[7,8,9]])
>>> data.size()
torch.Size([3, 3])
>>> data.shape
torch.Size([3, 3])
1
2
3
4
5

Tensor.dtype

>>> data = torch.Tensor([[1,2,3],[4,5,6],[7,8,9]])
>>> data.dtype
torch.float32
1
2
3

Tensor.requires_grad

​ 当前量是否需要在计算中保留对应的梯度信息,

>>> data = torch.Tensor([[1,2,3],[4,5,6],[7,8,9]])
>>> data.requires_grad
False
1
2
3

torch.numel()

torch.numel(input) → int # 返回 `input` 张量中元素总数
1

​ Example：

>>> a = torch.randn(1, 2, 3, 4, 5) # size=(1,2,3,4,5)
>>> torch.numel(a)
120
>>> a = torch.zeros(4,4)
>>> torch.numel(a)
16
1
2
3
4
5
6

Tensor.dim()

​ 获取Tensor维度

>>> data
tensor([1.], device='cuda:0')
>>> data.dim()
1
1
2
3
4

Tensor.device

​ 获取张量所在类型：cpu / gpu

>>> data = torch.Tensor([1])
>>> data.device
device(type='cpu')
>>> data = torch.Tensor([1]).cuda()
>>> data.device
device(type='cuda', index=0)
1
2
3
4
5
6

4. Tensor 创建

4.1 torch.tensor()和torch.Tensor()的区别

​ ==torch.tensor( )==是一个函数， 在使用的时候根据传入的data进行建造一个tensor。 其中data可以是：list, tuple, NumPy ndarray, scalar和其他类型。

​ torch.tensor()可以从data中的数据部分做拷贝（而不是直接引用），根据原始数据类型生成相应的torch.LongTensor，torch.FloatTensor，torch.DoubleTensor。

torch.tensor(data, dtype=None, device=None, requires_grad=False)
1

​ ==torch.Tensor==是一个类，是torch.FloatTensor的别称。torch.Tensor会调用Tensor类的构造函数init，生成默认的单精度浮点类型的张量。

​ 一般使用torch.tensor( )

4.2 Tensor创建

torch.tensor()

torch.tensor(data, dtype=None, device=None, requires_grad=False)
1

Example:

>>> data = torch.tensor([[1,2,3],[4,5,6],[7,8,9]])
>>> data
tensor([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])
>>> data.dtype #  Type inference on data
torch.int64
1
2
3
4
5
6
7

>>> data = torch.tensor([[1,2,3],[4,5,6],[7,8,9]], dtype=torch.float64, device='cuda:0')
>>> data
tensor([[1., 2., 3.],
        [4., 5., 6.],
        [7., 8., 9.]], device='cuda:0', dtype=torch.float64)
>>> data.dtype
torch.float64
1
2
3
4
5
6
7

​ torch.tensor() 会拷贝 data. 如果你有一个张量( data )，并且想要避免拷贝, 请使用 torch.Tensor.requires_grad_() 或者 torch.Tensor.detach() 。如果你有一个NumPy数组(ndarray) 并且想要避免拷贝, 请使用 torch.from_numpy().

torch.from_numpy()

​ 如果你有一个NumPy数组(ndarray) 并且想要避免拷贝, 请使用 torch.from_numpy(). 返回的张量和 ndarry 共享相同的内存。 对张量的修改将会反映在 ndarry，反之亦然。返回的张量 大小不可变。

torch.from_numpy(ndarray) → Tensor
1

Example:

>>> a = numpy.array([1, 2, 3])
>>> t = torch.from_numpy(a)
>>> t
tensor([1, 2, 3], dtype=torch.int32)
>>> t[0] = -1
>>> a
array([-1,  2,  3])
>>> t
tensor([-1,  2,  3], dtype=torch.int32)

1
2
3
4
5
6
7
8
9
10

torch.zeros()

torch.zeros(*sizes, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor
1

返回一个用标量 0 填充的张量，其中可变长参数 sizes 定义了该张量形状(shape).

Parameters:

• sizes (int…) – 定义输出张量形状的整数序列. 可以是可变长的参数 或者是像 列表元组这样的集合。
• out (Tensor, optional) – 输出张量
• dtype (torch.dtype, optional) – 返回张量的数据类型. 默认: 如果为 None, 使用全局默认值 (参考 torch.set_default_tensor_type()).
• layout (torch.layout, optional) – 返回张量的层数. Default: torch.strided.
• device (torch.device, optional) – 返回张量所需的设备. 默认: 如果为 None, 则当前的设备提供给默认张量类型(see torch.set_default_tensor_type()). device 将为支持CPU张量的CPU和支持CUDA张量类型的CUDA设备。
• requires_grad (bool, optional) – 自动梯度计算是否需要记录在返回张量上的操作。默认: False.

Example:

>>> torch.zeros(size=(2, 3))
tensor([[0., 0., 0.],
        [0., 0., 0.]])
>>> torch.zeros(size=(5,))
tensor([0., 0., 0., 0., 0.])
>>> torch.zeros(size=(5,), device='cuda:0')
tensor([0., 0., 0., 0., 0.], device='cuda:0')
1
2
3
4
5
6
7

torch.zeros_like()

​ 返回用标量0填充的张量，大小和input的size一样。torch.zeros_like(input) 等价于 torch.zeros(input.size(), dtype=input.dtype, layout=input.layout, device=input.device).

torch.zeros_like(input, dtype=None, layout=None, device=None, requires_grad=False) → Tensor
1

Parameters:

• input (Tensor) – input的size属性决定输出张量大小
• dtype (torch.dtype, optional) – 返回张量的数据类型. 默认: 如果为 None, 使用input的dtype属性 .
• layout (torch.layout, optional) – 返回张量的层数. Default: 默认为input的layout属性.
• device (torch.device, optional) – 返回张量所需的设备. 默认: 如果为 None, 则为input的device属性.
• requires_grad (bool, optional) – 自动梯度计算是否需要记录在返回张量上的操作。默认: False.

Example:

>>> input = torch.empty(2, 3)
>>> torch.zeros_like(input)
tensor([[ 0.,  0.,  0.],
 [ 0.,  0.,  0.]])
1
2
3
4

torch.ones()

​ 返回一个用标量 1 填充的张量，其中可变长参数 sizes 定义了该张量形状(shape).

torch.ones(*sizes, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor
1

Parameters:

• sizes (int…) – 定义输出张量形状的整数序列. 可以是可变长的参数 或者是像 列表元组这样的集合。
• out (Tensor, optional) – 输出张量
• dtype (torch.dtype, optional) – 返回张量的数据类型. 默认: 如果为 None, 使用全局默认值 (参考 torch.set_default_tensor_type()).
• layout (torch.layout, optional) – 返回张量的层数. Default: torch.strided.
• device (torch.device, optional) – 返回张量所需的设备. 默认: 如果为 None, 则当前的设备提供给默认张量类型(see torch.set_default_tensor_type()). device 将为支持CPU张量的CPU和支持CUDA张量类型的CUDA设备。
• requires_grad (bool, optional) – 自动梯度计算是否需要记录在返回张量上的操作。默认: False.

Example:

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

>>> torch.ones(5)
tensor([ 1.,  1.,  1.,  1.,  1.])
1
2
3
4
5
6

torch.ones_like()

​ 返回用标量1填充的张量，大小和input的size一样. torch.ones_like(input) 等价于 torch.ones(input.size(), dtype=input.dtype, layout=input.layout, device=input.device)

torch.ones_like(input, dtype=None, layout=None, device=None, requires_grad=False) → Tensor
1

Parameters:

• input (Tensor) – input的size属性决定输出张量大小
• dtype (torch.dtype, optional) – 返回张量的数据类型. 默认: 如果为 None, 使用input的dtype属性 .
• layout (torch.layout, optional) – 返回张量的层数. Default: 默认为input的layout属性.
• device (torch.device, optional) – 返回张量所需的设备. 默认: 如果为 None, 则为input的device属性.
• requires_grad (bool, optional) – 自动梯度计算是否需要记录在返回张量上的操作。默认: False.

Example:

>>> input = torch.empty(2, 3)
>>> torch.ones_like(input)
tensor([[ 1.,  1.,  1.],
 [ 1.,  1.,  1.]])
1
2
3
4

torch.arange()

返回一个一维张量，大小为[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tfvsAZoj-1622367720072)(Tensor用法01.assets/93f0e014493a12cb3334b1c1f00517f4.jpg)]，值为区间 [start,end)内，以step为步距,从start开始的数列.

Parameters:

• start (Number) – 点集的起始值. 默认为0.
• end (Number) – 点集的终值.
• step (Number) – 每对相邻点之间的距离 . 默认为 1.
• out (Tensor, optional) – 输出的张量
• dtype (torch.dtype, optional) – 返回张量的数据类型. 默认: 如果为 None, 使用全局默认值. (参考 torch.set_default_tensor_type()). 若 dtype 未提供, 则从其他输入参数推断数据类型. 如果 start, end, stop 中存在浮点数, 则 dtype 会使用默认数据类型, 请查看 get_default_dtype(). 否则, dtype 会使用 torch.int64.
• layout (torch.layout, optional) – 返回张量的层数. Default: torch.strided.
• device (torch.device, optional) – 返回张量所需的设备. 默认: 如果为 None, 则当前的设备提供给默认张量类型(see torch.set_default_tensor_type()). device 将为支持CPU张量的CPU和支持CUDA张量类型的CUDA设备。
• requires_grad (bool, optional) – 自动梯度计算是否需要记录在返回张量上的操作。默认: False.

Example:

>>> torch.arange(5)
tensor([ 0,  1,  2,  3,  4])
>>> torch.arange(1, 4)
tensor([ 1,  2,  3])
>>> torch.arange(1, 2.5, 0.5)
tensor([ 1.0000,  1.5000,  2.0000])
1
2
3
4
5
6

torch.linspace()

​ 返回共steps数量在start 和 end之间的等距点，从而组成的一维张量. 输出张量大小为steps，维度为一维.

torch.linspace(start, end, steps=100, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor
1

Parameters:

• start (float) – 点集的起始值.
• end (float) –点集的终值.
• steps (int) – start 和 end之间的样本点数目. 默认: 100.
• out (Tensor, optional) – 输出张量
• dtype (torch.dtype, optional) – 返回张量的数据类型. 默认: 如果为 None, 使用全局默认值. (参考 torch.set_default_tensor_type()).
• layout (torch.layout, optional) – 返回张量的层数. Default: torch.strided.
• device (torch.device, optional) – 返回张量所需的设备. 默认: 如果为 None, 则当前的设备提供给默认张量类型(see torch.set_default_tensor_type()). device 将为支持CPU张量的CPU和支持CUDA张量类型的CUDA设备。
• requires_grad (bool, optional) – 自动梯度计算是否需要记录在返回张量上的操作。默认: False.

Example:

>>> torch.linspace(3, 10, steps=5)
tensor([  3.0000,   4.7500,   6.5000,   8.2500,  10.0000])
>>> torch.linspace(-10, 10, steps=5)
tensor([-10.,  -5.,   0.,   5.,  10.])
>>> torch.linspace(start=-10, end=10, steps=5)
tensor([-10.,  -5.,   0.,   5.,  10.])
1
2
3
4
5
6

torch.logspace()

​ 返回共有steps数量的一维张量，点集由 10^start 和 10^end之间对数分布的点组成. 输出张量大小为steps，维度为一维.

torch.logspace(start, end, steps=100, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor
1

Parameters:

• start (float) – 点集的起始值.
• end (float) –点集的终值.
• steps (int) – start 和 end之间的样本点数目. 默认: 100.
• out (Tensor, optional) – 输出张量
• dtype (torch.dtype, optional) – 返回张量的数据类型. 默认: 如果为 None, 使用全局默认值. (参考 torch.set_default_tensor_type()).
• layout (torch.layout, optional) – 返回张量的层数. Default: torch.strided.
• device (torch.device, optional) – 返回张量所需的设备. 默认: 如果为 None, 则当前的设备提供给默认张量类型(see torch.set_default_tensor_type()). device 将为支持CPU张量的CPU和支持CUDA张量类型的CUDA设备。
• requires_grad (bool, optional) – 自动梯度计算是否需要记录在返回张量上的操作。默认: False.

Example:

>>> torch.logspace(start=-10, end=10, steps=5)
tensor([ 1.0000e-10,  1.0000e-05,  1.0000e+00,  1.0000e+05,  1.0000e+10])
>>> torch.logspace(start=0.1, end=1.0, steps=5)
tensor([  1.2589,   2.1135,   3.5481,   5.9566,  10.0000])
1
2
3
4

torch.eye()

​ 返回二维张量，对角线上是1，其它地方是0

torch.eye(n, m=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor
1

Parameters:

• n (int) – the number of rows
• m (int, optional) – the number of columns with default being n
• out (Tensor, optional) – the output tensor
• dtype (torch.dtype, optional) – the desired data type of returned tensor. Default: if None, uses a global default (see torch.set_default_tensor_type()).
• layout (torch.layout, optional) – the desired layout of returned Tensor. Default: torch.strided.
• device (torch.device, optional) – the desired device of returned tensor. Default: if None, uses the current device for the default tensor type (see torch.set_default_tensor_type()). device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types.
• requires_grad (bool, optional) – If autograd should record operations on the returned tensor. Default: False.

Example

>>> torch.eye(3)
tensor([[ 1.,  0.,  0.],
 [ 0.,  1.,  0.],
 [ 0.,  0.,  1.]])
1
2
3
4

torch.empty()

​ 类似 torch.ones()

torch.empty_like()

​ 类似 torch.ones_like()

torch.full()

torch.full(size, fill_value, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor
1

​ 返回大小为sizes,单位值为fill_value的矩阵

Example

>>> torch.full((2, 3), 3.141592)
tensor([[ 3.1416,  3.1416,  3.1416],
 [ 3.1416,  3.1416,  3.1416]])
1
2
3

torch.full_like()

​ 类似 torch.ones_like()

4.3 随机生成

torch.normal(mean, std, out=None)

torch.rand(*size, out=None, dtype=None, …) #返回[0,1]之间均匀分布的随机数值

torch.rand_like(input, dtype=None, …) #返回与input相同size的tensor, 填充均匀分布的随机数值

torch.randint(low=0, high, size,…) #返回均匀分布的[low,high]之间的整数随机值

torch.randint_like(input, low=0, high, dtype=None, …) #

torch.randn(*sizes, out=None, …) #返回大小为size,由均值为0，方差为1的正态分布的随机数值

torch.randn_like(input, dtype=None, …)

torch.randperm(n, out=None, dtype=torch.int64) # 返回0到n-1的数列的随机排列
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15