PyTorch-Tensor

Posted 2021-03-16 yanshw

Tensor 即张量，在 tf 中也有这个概念，tensor 是 pytorch 和 tf 非常重要的数据结构，可以理解为多维数组，它可以是一个数、一个向量、一个矩阵、多维数组；

Tensor 可以用 GPU 加速；

在 pytorch 中其用法类似于 numpy；

 

创建 Tensor

创建 Tensor，并查看尺寸

• torch.Tensor(size)：
• torch.empty(size)：
• torch.zeros(size)、torch.zeros_like(input)：返回跟 input 同 size 的全 0 tensor
• torch.ones(size)、torch.ones_like(input)
• torch.arange(start=0, end, step=1)：
• torch.full(size, value)：见示例

查看尺寸用 size 或者 shape

 

示例

import torch as t

x = t.Tensor(2, 3)      ### 构建 2x3 矩阵
print(t.ones_like(x))
print(t.full((2, 3), 5))
# tensor([[5., 5., 5.],
#         [5., 5., 5.]])
print(t.arange(5))      # tensor([0, 1, 2, 3, 4])

print(x.size())         # torch.Size([2, 3])    ### 查看尺寸
print(x.size()[0])      # 2 查看行数
print(x.size(0))        # 2 查看行数
print(t.Size([2, 3]))
print(x.shape)          # torch.Size([2, 3])

 

随机初始化

• torch.rand(size)：生成 (0，1) 内均匀分布的随机数
• torch.randn(size)：生成标准正态分布 (0，1) 的随机数
• torch.normal(mean, std, out=None)：生成正态分布的随机数，注意 mean 和 std 都是 tensor 格式，mean 默认 0，std 默认 1

更多的随机抽样方法，参见链接：https://pytorch.org/docs/stable/torch.html#random-sampling

 

基本操作

有很多操作，这里只介绍简单的，具体查看官网

 

切片

 

m = t.Tensor(3, 5)
print(m[:, 1])      # tensor([1.4226e-13, 5.6015e-02, 7.7782e+31])  ### 3 row

 

 

 

合并分割

t.cat(seq, dim, out=None)：合并，dim 指定维度

dim 为 0 代表按第 0 维度拼接，确切的说是在第 0 维度上拼接，即在行上拼接，1相反

a = t.ones(1, 2)
b = t.zeros(1, 2)
c = t.cat((a, b), 0)
print(c)
# tensor([[1., 1.],
#         [0., 0.]])

 

t.chunk(tensor, chunks, dim)：分割，chunks 代表分割的块数，dim 代表分割的维度 

dim 为 0 代表在第 0 个维度上进行分割，也就是横着切，1 相反

e = t.ones(3, 2)
print(t.chunk(e, 2, 1))
# (tensor([[1.],
#         [1.],
#         [1.]]), tensor([[1.],
#         [1.],
#         [1.]]))
print(t.chunk(e, 2, 0))
# (tensor([[1., 1.],
#         [1., 1.]]), tensor([[1., 1.]]))

分割还有一种方法 t.split(tensor, split_size_or_sections, dim)，具体自行尝试

 

尺寸变换

t.reshape(input, shape) 和 tensor.view(shape) 都可以实现尺寸变换，前者是 tensor 类的一个方法，后者是 tensor 对象的方法，当然 前者也可以用走 tensor 对象的方法；

也就是说 reshape 大于 view；

注意，二者都不会改变原 tensor 的尺寸，除非把结果赋给一个新的对象；

import torch as t

f = t.arange(10)

### 单纯调用 view
print(f.view(2, 5))     ### view 设置了新的尺寸
# tensor([[0, 1, 2, 3, 4],
#         [5, 6, 7, 8, 9]])
print(f)    # tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])    ### 但是并没有改变 原来的 tensor
# print(t.view(f, (2, 5)))    ### view 不能这么用，它不是 torch 的方法

g = f.view(2, 5)    ### 这样会生成新的 tensor

### reshape,也不会改变本身
print(f.reshape(2, 5))
# tensor([[0, 1, 2, 3, 4],
#         [5, 6, 7, 8, 9]])
print(f)    # tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
print(t.reshape(f, (2, 5)))     ### reshape 可以作为 torch 的方法
# tensor([[0, 1, 2, 3, 4],
#         [5, 6, 7, 8, 9]])

 

数学运算

加法：有 3 种方式，+，add，add_

import torch as t
y = t.rand(2, 3)        ### 使用[0，1]均匀分布构建矩阵
z = t.ones(2, 3)        ### 2x3 的全 1 矩阵
print(y + z)            ### 加法1
t.add(y, z)             ### 加法2
### 加法的第三种写法
result = t.Tensor(2, 3) ### 预先分配空间
t.add(y, z, out=result) ### 指定加法结果的输出目标
print(result)

 

add_ 与 add 的区别在于，add 不会改变原来的 tensor，而 add_会改变原来的 tensor；

在 pytorch 中，方法后面加  _ 都会改变原来的对象，相当于 inplace 的作用

print(y)
# tensor([[0.4083, 0.3017, 0.9511],
#         [0.4642, 0.5981, 0.1866]])
y.add(z)
print(y)                ### y 不变
# tensor([[0.4083, 0.3017, 0.9511],
#         [0.4642, 0.5981, 0.1866]])
y.add_(z)
print(y)                ### y 变了，相当于 inplace
# tensor([[1.4083, 1.3017, 1.9511],
#         [1.4642, 1.5981, 1.1866]])

其他运算

t.mul(input, other, out=None)：乘法

t.div(input, other, out=None)：除法

t.pow(input, other, out=None)：指数

t.sqrt(input, out=None)：开方

t.round(input, out=None)：四舍五入到整数

t.abs(input, out=None)：绝对值

t.ceil(input, out=None)：向上取整

t.clamp(input, min, max, out=None)：把 input 规范在 min 到 max 之间，超出用 min 和 max 代替，可理解为削尖函数

t.argmax(input, dim=None, keepdim=False)：返回指定维度最大值的索引

 

t.sigmoid(input, out=None)

t.tanh(input, out=None)

 

Tensor-Numpy 互转

操作如下

n = t.ones(2, 3)
print(n.numpy())    ### Tensor 转 Numpy
# [[1. 1. 1.]
#  [1. 1. 1.]]

import numpy as np
p = np.ones((2, 3))
q = t.from_numpy(p)      ### Numpy 转 Tensor
print(p)
# tensor([[1., 1., 1.],
#         [1., 1., 1.]], dtype=torch.float64)

Tensor 与 Numpy 共享内存，使得他们之间的转换很快，而且几乎不会消耗资源；

共享内存意味着，一个变了，另一个也跟着变；

q.add_(n)       ### q 被改变
print(q)        ###
# tensor([[2., 2., 2.],
#         [2., 2., 2.]], dtype=torch.float64)
print(p)        ### p 竟然也被改变了
# [[2. 2. 2.]
#  [2. 2. 2.]]

 

GPU 加速

 注意，GPU 的优势体现在大规模数据集和复杂运算上，把数据从内存转移到显存产生额外开销，导致小数据反而不占优势

print(t.cuda.is_available())    # False
if t.cuda.is_available():
    x = x.cuda()        ### Tensor 通过 cuda 方法转换为 GPU 的 Tensor
    y = y.cuda()
    x + y

 

 

 

参考资料：

《深度学习框架PyTorch：入门与实践_陈云(著)》

https://www.jianshu.com/p/7dbfc7076e5a