张量
张量是深度学习框架中最核心的组件，Tensor 实际上就是一个多维数组。
在PyTorch中，torch.Tensor 是存储和变换数据的主要工具。（与Numpy的多维数组类似）
（一）创建张量 torch.Tensor
torch.Tensor 默认张量类型为torch.FloatTensor
import torch # 导入PyTorch
1. 根据现有数据创建张量
torch.tensor(data, *, dtype=None, device=None, requires_grad=False, pin_memory=False)
# 从Python列表或序列构造张量
torch.tensor([[1., -1.], [1., -1.]])
>>> tensor([[ 1.0000, -1.0000],
[ 1.0000, -1.0000]])
torch.tensor(np.array([[1, 2, 3], [4, 5, 6]]))
>>> tensor([[ 1, 2, 3],
[ 4, 5, 6]])
torch.tensor(3.14159) # 创建一个标量
>>> tensor(3.1416)
torch.tensor([]) # 创建一个空张量
>>> tensor([])
2. 随机抽样创建张量
- 返回由区间 [ 0,1) 上均匀分布的随机数填充的张量，张量的形状由变量size定义
torch.rand(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) - 返回由标准正态分布（均值为0，方差为1）中的随机数填充的张量
torch.randn(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) - 返回由在low（包含）和high（排除）之间均匀生成的随机整数填充的张量
torch.randint(low=0, high, size, *, generator=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) - 返回从0到n-1的随机排列的整数的张量
torch.randperm(n, *, out=None, dtype=torch.int64, layout=torch.strided, device=None, requires_grad=False) - 返回一个由未初始化数据填充的张量
torch.empty(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False, pin_memory=False)
3. 创建与另一张量具有相同大小/类型的张量
- torch.rand_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format)
- torch.randn_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format)
- torch.randint_like(input, low=0, high, *, dtype=None, layout=torch.strided, device=None, requires_grad=False, memory_format=torch.preserve_format)
x = torch.randn_like(x, dtype=torch.float)
>>> tensor([[ 0.5344, 0.5095, 0.3691],
[ 0.0160, 1.4369, 1.3419]])
4. 创建与另一张量具有相似类型但大小不同的张量
会默认重用输入Tensor的一些属性
# 返回的tensor默认具有相同的torch.dtype和torch.device
x = x.new_ones(2, 3, dtype=torch.float64)
>>> tensor([[1., 1., 1.],
[1., 1., 1.]], dtype=torch.float64)
5. 创建其他特征的张量
- 全0张量
torch.zeros(*size) - 全1张量
torch.ones(*size) - [s,e)，步长为step的一维张量，张量大小为（e-f）/step
torch.arange(s,e,step) - [start, end)，步长为step的一维张量，张量大小为（e-f）/step+1
torch.range(s,e,step) - [s,e]，均匀切分成steps份
torch.linspace(s,e,step) - 对角线为1，其它为0的二维张量
torch.eye(*size) - 以fill_value填充的张量
torch.full(size, fill_value)
（二）张量属性 Tensor Attributes
1. 数据类型 torch.dtype
Pytorch有12种不同的数据类型。
2. 设备类型 torch.device
torch.device包含设备类型（“ cpu”或“ cuda”）和该设备类型的可选设备序号。如果不存在设备序号，则即使调用torch.cuda.set_device（），该对象也始终代表设备类型的当前设备。例如，使用设备“ cuda”构造的torch.Tensor等效于“ cuda：X”，其中X是torch.cuda.current_device（）的结果。
3. 内存布局 torch.layout
The torch.layout class is in beta and subject to change.
torch.strided表示dense Tensors，是最常用的内存布局。每个跨步张量都有一个关联的torch.Storage，用于保存其数据。这些张量提供了存储的多维跨步视图。步幅是一个整数列表：第k个步幅表示在张量的第k个维度中从一个元素到下一个元素所需的内存跳转。这个概念使得可以有效地执行许多张量运算。
4. 内存格式 torch.memory_format
torch.memory_format 表示正在或将要分配torch.Tensor的内存格式。
可能的值为：
- torch.contiguous_format
张量正在或将在密集的非重叠内存中分配。步数由递减的值表示。 - torch.channels_last
张量正在或将在密集的非重叠内存中分配。步长由步长[0]>步长[2]>步长[3]>步长[1] == 1（即NHWC顺序）中的值表示。 - torch.preserve_format
在诸如clone之类的函数中使用，以保留输入张量的存储格式。如果将输入张量分配在密集的非重叠内存中，则会从输入中复制输出张量步幅。否则输出步幅将遵循torch.contiguous_format
（三）张量视图 Tensor Views
PyTorch允许张量是现有张量的视图。view tensor与其base tensor共享相同的基础数据和内存，修改view tensor（视图张量）也会更改base tensor（基本张量）。支持视图避免了显式的数据复制，因此允许我们进行快速高效的内存重塑、切片和元素操作。
1. 切片和索引操作
正索引由左向右从0开始，负索引由右向左从-1开始
# 切片操作基本表达式：
object[start_index:end_index:step]
# 当start_index省略时，表示从起点开始
# 当end_index省略时，表示到终点为止
# 若step=-1，表示从右往左取值
object[start_index:end_index]
# 此时默认step=1
object[start_index]
# 此时表示start_index指定的元素
2. 视图操作
detach() 返回与当前计算图分离的新Tensor，但是仍指向原张量的存放位置，不同之处只是requires_grad为false，得到的这个Tensor永远不需要计算其梯度，不具有grad。
.view() 返回一个数据与自张量相同，元素个数也相同，但形状不同的新张量。
虽然view返回的Tensor与源Tensor是共享data的，但是依然是一个新的Tensor（因为Tensor除了包含data外还有一些其他属性），二者id（内存地址）并不一致。
（只适用于连续的张量，否则需要调用.contiguous()方法 ，torch.reshape()不受此限制）
torch.view(-1) # 张量变成一维的
torch.view(-1,2) #自动补齐张量的长度
torch.view(2,-1) #自动补齐张量的宽度
// 通过shape或者size()来获取Tensor的形状:
print(x.size())
print(x.shape)
返回的torch.Size其实就是一个tuple, 支持所有tuple的操作。
// 如果想返回一个副本不共享data内存可用clone创建一个副本再用view()，使用clone还有一个好处是会被记录在计算图中，即梯度回传到副本时也会传到源Tensor。
torch.transpose(input, dim0, dim1) 在两个维度间进行转换
x=torch.Tensor(2,3,4,5) #这是一个4维的矩阵（只用空间位置，没有数据）
print(x.size())
>>> torch.Size([2, 3, 4, 5])
#先转置0维和1维，之后在第2，3维间转置，之后在第1，3间转置
y=x.transpose(0,1).transpose(3,2).transpose(1,3)
print(y.size())
>>> torch.Size([3, 4, 5, 2])
torch.Tensor.item() 从包含单个值的张量中获取Python数
x = torch.tensor([[1]])
>>> tensor([[ 1]])
x.item()
>>> 1
x = torch.tensor(2.5)
>>> tensor(2.5000)
x.item()
>>> 2.5
（四）算术操作
加法：add
print(x+y)
print(torch.add(x,y))
# 指定输出：
result = torch.empty(5,3)
torch.add(x,y,out=result)
print(result)
y.add_(x) # 原地操作
print(y)
原地操作改变张量用下划线后缀标记。
in-place size / stride / storage changes (such as resize_ / resize_as_ / set_ / transpose_) 不再更新原始张量，而是触发错误。
减法：sub
乘法：mul
除法：div
其他线性代数可参考官方文档。
（五）广播机制(broadcasting)
当对两个形状不同的Tensor按元素运算时，可能会触发广播（broadcasting）机制：先适当复制元素使这两个Tensor形状相同后再按元素运算。
x = torch.arange(1, 3).view(1, 2)
print(x)
y = torch.arange(1, 4).view(3, 1)
print(y)
print(x + y)
>>> tensor([[1, 2]])
>>> tensor([[1],
[2],
[3]])
>>> tensor([[2, 3],
[3, 4],
[4, 5]])
// 由于x和y分别是1行2列和3行1列的矩阵，如果要计算x + y，那么x中第一行的2个元素被广播（复制）到了第二行和第三行，而y中第一列的3个元素被广播（复制）到了第二列。如此，就可以对2个3行2列的矩阵按元素相加。
（六）Tensor和NumPy相互转换
我们很容易用numpy()和from_numpy()将Tensor和NumPy中的数组相互转换。但是需要注意： 这两个函数所产生的的Tensor和NumPy中的数组共享相同的内存，所以它们之间的转换很快，改变其中一个时另一个也会改变。
整理来源
https://tangshusen.me/Dive-into-DL-PyTorch/#/
https://pytorch.org/
1853
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
