一 . tensor创建
1 . 张量的定义
张量在形式上就是多维数组，例如标量就是0维张量，向量就是一维张量，矩阵就是二维张量，而三维张量就可以想象RGB图片，每个channel是一个二维的矩阵，共有三个channel，还可以考虑更多。
在代码中创建张量Tensor数据类型时，除了封装张量本身的数据data外，还会附加张量的一些性质和操作，例如数据的梯度（grad），创建tensor的函数（grad_fun，是求导的关键），是否为叶子节点（is_leaf），是否需要梯度（require_grad）。
2 . 张量的创建
2 .1 tensor直接创建
torch.tensor([1])
arr = np.ones((3, 3))
t = torch.tensor(arr, device='cuda')
t = torch.tensor(arr)
值得注意的点：
（1）tensor（）括号里的数据可以是list（以"()"表示），也可以是数组（以[]表示），也可以是numpy，即先用numpy创建一个numpy，然后直接导入（如下）；
（2）注意数据类型，有时候需要在数字后面加"."表示float，因为求导时候需要float类型；
（3）可以添加device='cuda'获得加速。
2 .2 from _numpy 从numpy中创建
arr = np.array([[1, 2, 3], [4, 5, 6]])
t = torch.from_numpy(arr)
arr[0, 0] = 0
t[0, 0] = -1
值得注意的点：
（1）这个创建的tensor和原来的numpy共享内存，也即是说修改tensor就会修改原来的numpy。
2.3 从数字中创建
通过torch.zeros创建张量
out_t = torch.tensor([1])
#t=torch.zeros((3,3))
t = torch.zeros((3, 3), out=out_t)
值得注意的点：
（1）也可以先创建一个tensor，然后在zeros函数的out接收创建的zeros，二者的size可以不一样，创建完成后二者一致。
（2）还可以torch.ones
（3）全1张量还可以用full函数
t = torch.full((3, 3), 1)
注意试验一下是不是还可以创建全"2"张量？
（4）还可以利用torch.zeros_like()，torch.ones_like()，torch.full_like创建和input张量（类似于size,只不过是用一个真实的张量表示）一致的全0/1张量。
（5）torch.eye()创建单位对角矩阵
2 .4 等差均分创建
t = torch.arange(2, 10, 2)
（1）创建等差数列张量，后面为等差值，默认为1.
t = torch.linspace(2, 10, 5)
t = torch.linspace(2, 10, 6)
（1）在[start,end]中均分n等份，这时会出现小数。
（2）还可以等log创建，torch.logspace()
2 .5 依据概率创建
通过torch.normal创建正态分布张量
mean：张量 std: 张量
mean = torch.arange(1, 5, dtype=torch.float)
std = torch.arange(1, 5, dtype=torch.float)
t_normal = torch.normal(mean, std)
mean：标量 std: 标量
t_normal = torch.normal(0., 1., size=(4,))
mean：张量 std: 标量
mean = torch.arange(1, 5, dtype=torch.float)
std = 1
t_normal = torch.normal(mean, std)
（1）注意mean，std可以是标量和张量的组合，共四种模式。
（2）torch.randn(),torch.randn_like()创建标准正态分布张量；
（3）torch.rand(),torch.rand_like()创建[0,1]均匀分布。
（4）torch.randint(low,high),torch.randint_like(low,high)创建[low,high)均匀分布。
（5）torch.randperm(n)，创建从0到n-1的随机排列张量
（6）torch.bernoulli(input)，创建以input为概率值的伯努利分布张量。
3 . 张量的操作
3 .1 张量拼接
torch.cat(tensors,dim)
t = torch.ones((2, 3))
t_0 = torch.cat([t, t], dim=0)
t_1 = torch.cat([t, t, t], dim=1)
（1）是在原来的维度上进行拼接
torch.stack(tensor,dim)
t = torch.ones((2, 3))
t_stack = torch.stack([t, t, t], dim=0)
（1）是在新创建的维度上进行拼接，如果维度小于现存的维度，则创建该维度后，后面的递推。比如t现在维度是2*3，拼接后，则是3*2*3，其中后两维的2*3是原来的t。
3 .2 张量切分
torch.chunk(input,chunk,dim)
a = torch.ones((2, 7)) # 7
list_of_tensors = torch.chunk(a, dim=1, chunks=3) # 3
for idx, t in enumerate(list_of_tensors):
(1)在维度dim上进行chunk均分，如果不能整除，最后一份为余数。
torch.split(input,int/list,dim)
t = torch.ones((2, 5))
list_of_tensors = torch.split(t, [2, 1, 1], dim=1) # [2 , 1, 2]
for idx, t in enumerate(list_of_tensors):
list_of_tensors = torch.split(t, [2, 1, 2], dim=1)
for idx, t in enumerate(list_of_tensors):
(1)为int时，和chunk功能类似；
（2）为list时，可以按照设定值切分，但总和要与input维度上值一致。
3 .3 张量索引
torch.index_select(input,dim,select)
t = torch.randint(0, 9, size=(3, 3))
idx = torch.tensor([0, 2], dtype=torch.long) # float
t_select = torch.index_select(t, dim=0, index=idx)
(1)在dim维度上按照select索引数值。
torch.maksed_select(input,mask)
t = torch.randint(0, 9, size=(3, 3))
mask = t.le(5) # ge is mean greater than or equal/ gt: greater than le lt
t_select = torch.masked_select(t, mask)
- mask是和input同大小的布尔类型张量，按照TRUE返回一维张量。
3 .4 张量变形
torch.reshape(input,shape)
t = torch.randperm(8)
t_reshape = torch.reshape(t, (-1, 2, 2)) # -1
t[0] = 1024
3 .5 张量维度交换
torch.transpose(input,dim1,dim2)
torch.transpose
t = torch.rand((2, 3, 4))
t_transpose = torch.transpose(t, dim0=1, dim1=2) # c*h*w h*w*c
(1)维度变换之后，数据是如何变化的？
（2）torch.t()二维张量（矩阵）转置
3 .6 张量压缩
torch.sequeeze(input,dim)
t = torch.rand((1, 2, 3, 1))
t_sq = torch.squeeze(t)
t_0 = torch.squeeze(t, dim=0)
t_1 = torch.squeeze(t, dim=1)
（1）默认压缩所有为1的维度，也可以指定维度，若指定维度不为1，则不会压缩。
（2）torch.unsequeeze()，扩展维度的值。
4 . 张量的数学运算
t_0 = torch.randn((3, 3))
t_1 = torch.ones_like(t_0)
t_add = torch.add(t_0, 10, t_1)
- torch.add可同时执行乘法运算。
5 . 计算图
计算图是用来描述运算的有向无环图，包括结点（node）和边（edge）。结点表示数据，如向量，矩阵，张量等，边表示运算，如加减乘除卷积等。
import torch
w = torch.tensor([1.], requires_grad=True)
x = torch.tensor([2.], requires_grad=True)
a = torch.add(w, x) # retain_grad()
b = torch.add(w, 1)
y = torch.mul(a, b)
y.backward()
print(w.grad)
查看叶子结点
print("is_leaf:\n", w.is_leaf, x.is_leaf, a.is_leaf, b.is_leaf, y.is_leaf)
查看梯度
print("gradient:\n", w.grad, x.grad, a.grad, b.grad, y.grad)
查看 grad_fn
print("grad_fn:\n", w.grad_fn, x.grad_fn, a.grad_fn, b.grad_fn, y.grad_fn)
6. 自动求导
torch.autograd.backward(tensors,retain_graph)
w = torch.tensor([1.], requires_grad=True)
x = torch.tensor([2.], requires_grad=True)
a = torch.add(w, x)
b = torch.add(w, 1)
y = torch.mul(a, b)
y.backward(retain_graph=True)
print(w.grad)
y.backward()
w = torch.tensor([1.], requires_grad=True)
x = torch.tensor([2.], requires_grad=True)
a = torch.add(w, x) # retain_grad()
b = torch.add(w, 1)
y0 = torch.mul(a, b) # y0 = (x+w) * (w+1)
y1 = torch.add(a, b) # y1 = (x+w) + (w+1) dy1/dw = 2
loss = torch.cat([y0, y1], dim=0) # [y0, y1]
grad_tensors = torch.tensor([1., 2.])
loss.backward(gradient=grad_tensors) # gradient 传入 torch.autograd.backward()中的grad_tensors
torch.autograd.grad(outputs,inputs,retain_graph)
x = torch.tensor([3.], requires_grad=True)
y = torch.pow(x, 2) # y = x**2
grad_1 = torch.autograd.grad(y, x, create_graph=True) # grad_1 = dy/dx = 2x = 2 * 3 = 6
grad_2 = torch.autograd.grad(grad_1[0], x) # grad_2 = d(dy/dx)/dx = d(2x)/dx = 2
- autograd.grad()会返回梯度张量供保存。