【Torch笔记】Tensor

1 什么是 Tensor?

Tensor，又称张量，它是矩阵向任意维度的推广。

【Tensor 与 Variable（目前已弃用，但最好了解一下）】

Variable 是 torch.autograd 中的数据类型，主要用于封装 tensor，进行自动求导：

data：被封装的 tensor
grad：data 的梯度
grad_fn：创建 tensor 的 function，是自动求导的关键
requires_grad：指示是否需要梯度
is_leaf：指示是否是叶子结点（张量）

总的来说，Variable 就是给 Tensor 添加相关属性，使其自动求导。

从 PyTorch 0.4.0 版本开始，Variable 并入 Tensor，并额外添加了三个与数据相关的属性：

dtype：张量的数据类型，如 torch.FloatTensor，torch.cuda.FloatTensor
shape：张量的形状，如 (64, 3, 224, 224)
device：张量所在设备，GPU/CPU

2 Tensor 的创建方法

2.1 直接创建

2.1.1 torch.tensor()

最简单、直接的方法就是通过 torch.tensor() 进行创建。

torch.tensor()：

data：数据，可以是 list，numpy

dtype：数据类型，默认与数据保持一致

device：所在设备，cuda / cpu

requires_grad：是否需要计算梯度

pin_memory：是否存于锁页内存，通常为 False

arr = np.ones((3, 3))       # ndarray 类型
tensor = torch.tensor(arr)
print(arr.dtype)
print(tensor)

稍做修改，将数据放入 cuda：

arr = np.ones((3, 3))
tensor = torch.tensor(arr, device="cuda")
print(arr.dtype)
print(tensor)

2.1.2 torch.from_numpy(ndarray)

另一种直接创建的方法，使用方法 torch.from_numpy(ndarray) 创建 tensor，从 numpy 创建 tensor。

需要注意的是，使用该方法创建的 tensor 与原 ndarray 共享内存，即当修改其中一个的数据，另一个也会被改动。

arr = np.array([1, 2, 3, 4]).reshape(2, 2)
tensor = torch.from_numpy(arr)
print(arr)
print(tensor)

2.2 依据数值创建

2.2.1 torch.zeros() 与 torch.zeros_like()

torch.zeros() 方法的功能是创建全 0 的张量：

size：张量的形状
out：输出的张量
layout：内存中布局形式，有 strided，sparse_coo 等
device：cuda / cpu
requires_grad：是否需要梯度

out_t = torch.tensor([1])
t = torch.zeros(size=(3, 3), out=out_t)
print(out_t)
print(t)
print(id(out_t), id(t), id(out_t)==id(t))

可见，t 和 out_t 指向同一个地址，也就是生成一个全 0 的张量，然后赋值给 out。

torch.zeros_like() 函数功能是，依 input 形状创建全 0 张量：

input：创建与 input 同形状的全 0 张量
dtype：数据类型
layout：内存中布局形式

2.2.2 torch.ones() 与 torch.ones_like()

类似的，需要得到全 1 张量，只需要将 zeros 改成 ones 即可，上述两方法均有对应的方法。

2.2.3 torch.full() 与 torch.full_like()

torch.full() 依 input 形状和对应值 fill_value 创建张量：

size：张量的形状
fill_value：张量的值

out_t = torch.tensor([1])
t = torch.full(size=(3, 3), out=out_t, fill_value=10)
print(out_t)
print(t)
print(id(out_t), id(t), id(out_t)==id(t))

2.2.4 torch.arange()

torch.arange() 方法可创建等差为 1 的张量，数值区间在 [start, end)。

start：数列起始值
end：数列“结束值”
step：数列公差，默认为 1

t = torch.arange(start=0, end=10, step=2)
print(t)

2.2.5 torch.linspace()

torch.linspace() 可创建均分的一维张量。数值区间长度为 [start, end]：

start：数列起始值
end：数列结束值
steps：数列长度

t = torch.linspace(start=0, end=10, steps=2)
print(t)
t = torch.linspace(start=0, end=10, steps=5)
print(t)
t = torch.linspace(start=0, end=10, steps=8)
print(t)

2.2.6 torch.logspace()

torch.logspace() 方法与上面的一样，不同之处在于长度为 stpes，对数的底为 base：

start：数列起始值
end：数列结束值
steps：数列长度
base：对数函数的底，默认为 10

2.2.7 torch.eye()

torch.eye() 可创建单位对角矩阵（二维张量），默认为方阵：

n：矩阵行数
m：矩阵列数

2.3 依概率分布创建张量

2.3.1 torch.normal()

torch.normal() 方法可以生成正态分布：

mean：均值
std：标准差

它具有四种模式，均值、标准差分别为标量和张量的形式。

## 模式一：二者均为张量
mean = torch.tensor([1, 2, 3, 4], dtype=float)
std = torch.tensor([1, 2, 3, 4], dtype=float)
t_normal = torch.normal(mean, std)
print("mean:{} \n std:{}".format(mean, std))
print(t_normal)

实际上，上述案例生成了四个正态分布，其均值和标准差从序列 0-3 分别对应，生成的张量从这四个正态分布中进行采样，然后拼成一个一维张量。

## 模式二：二者均为标量
t_normal = torch.normal(0, 1, size=(4,))
print(t_normal)

## 模式三：均值为张量，标准差为标量
mean = torch.tensor([1, 2, 3, 4], dtype=float)
std = 1
t_normal = torch.normal(mean, std)
print("mean:{}\nstd:{}".format(mean, std))
print(t_normal)## 模式四：均值为标量，标准差为张量
mean = 1
std = torch.tensor([1, 2, 3, 4], dtype=float)
t_normal = torch.normal(mean, std)
print("mean:{}\nstd:{}".format(mean, std))
print(t_normal)

2.3.2 torch.randn() 与 torch.randn_like()

torch.randn() 生成标准正态分布：

size：张量的形状

2.3.3 torch.rand() 与 torch.rand_like()

torch.rand() 方法生成区间 [0, 1) 上，生成均匀分布。

2.3.4 torch.randint() 与 torch.randint_like()

torch.rand() 方法生成区间 [low, high) 上，生成整数均匀分布：

size：张量的形状

2.3.5 torch.randperm()

torch.randperm() 生成从 0 到 n-1 的随机排列：

n：张量的长度

2.3.5 torch.bernoulli()

torch.bernoulli() 以 input 为概率，生成伯努利分布（0-1分布，两点分布）

input：概率