目录
https://blog.csdn.net/qjk19940101/article/details/79557204
#encoding=utf8
import torch
from torch.autograd import Variable
x = Variable(torch.Tensor([2]), requires_grad=True)
y = x + 2
z = y ** 2 + 3
print z
## 输出tensor([19.], grad_fn=<AddBackward>)
z.backward()
## z=(x+2)^2+3==>dz/dx=2(x+2)
print x.grad
## 输出tensor([8.])
参考https://www.cnblogs.com/luckyscarlett/p/10552747.html
https://blog.csdn.net/xholes/article/details/81667211
https://pytorch-cn.readthedocs.io/zh/latest/package_references/torch-nn/
Efficient softmax approximation for GPUs
torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)
正常的卷积如下：
卷积操作就是，将这个三维的filter（例如3x3x3）与输入图像的对应位置相乘，再将这27个数相加，得到的结果就是output的一个元素。
对于复杂的卷积，假设输入的尺度是\((N, C_{in},H,W)\)，输出尺度\((N,C_out,H_out,W_out)\)
\[
out(N_i, C_{out_j})=bias(C_{out_j})+\sum^{C_{in}-1}_{k=0}weight(C_{out_j},k)\bigotimes input(N_i,k)
\]
\(\bigotimes\): 表示二维的相关系数计算 stride: 控制相关系数的计算步长参数kernel_size，stride,padding，dilation也可以是一个int的数据，此时卷积height和width值相同;也可以是一个tuple数组，tuple的第一维度表示height的数值，tuple的第二维度表示width的数值
shape：
\((N,C_{in},H_{in},W_{in})\)\((N,C_{out},H_{out},W_{out})\)
\(H_{out}=floor((H_{in}+2padding[0]-dilation[0](kernerl\_size[0]-1)-1)/stride[0]+1)\)\(W_{out}=floor((W_{in}+2padding[1]-dilation[1](kernerl\_size[1]-1)-1)/stride[1]+1)\)torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
pooling的基本思想，与卷积的运算基本一样，区别在于，filter和原图像做的不是卷积操作，而是对原图像的filter大小的区域做max/min之类的操作，而且filter并没有第三维，输入和输出的第三维是一样的。
针对pooling，并没有需要学习的参数。
如果输入的大小是(N,C,H,W)，那么输出的大小是(N,C,H_out,W_out)和池化窗口大小(kH,kW)的关系是：
\[
out(N_i, C_j,k)=\max^{kH-1}_{m=0}\max^{kW-1}_{m=0}input(N_{i},C_j,stride[0]h+m,stride[1]w+n)
\]
如果padding不是0，会在输入的每一边添加相应数目0
dilation用于控制内核点之间的距离，详细描述在https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md
参数kernel_size，stride, padding，dilation数据类型： 可以是一个int类型的数据，此时卷积height和width值相同; 也可以是一个tuple数组（包含来两个int类型的数据），第一个int数据表示height的数值，tuple的第二个int类型的数据表示width的数值
shape:
\((N,C,H_{in},W_{in})\)\((N,C,H_{out},W_{out})\)
\(H_{out}=floor((H_{in} + 2padding[0] - dilation[0](kernel\_size[0] - 1) - 1)/stride[0] + 1\)\(W_{out}=floor((W_{in} + 2padding[1] - dilation[1](kernel\_size[1] - 1) - 1)/stride[1] + 1\)https://pytorch-cn.readthedocs.io/zh/latest/package_references/torch-nn/#sparse-layers。一个保存了固定字典和大小的简单查找表。这个模块常用来保存词嵌入和用下标检索它们。模块的输入是一个下标的列表，输出是对应的词嵌入。torch.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, max_norm=None, norm_type=2, scale_grad_by_freq=False, sparse=False)。
https://pytorch-cn.readthedocs.io/zh/latest/package_references/torch/
对矩阵mat1和mat2进行矩阵乘操作(用@表示)。矩阵mat加到最终结果。out=(beta∗M)+(alpha∗mat1@mat2)。torch.addmm(beta=1, mat, alpha=1, mat1, mat2, out=None)
对矩阵mat1和mat2进行相乘。torch.mm(mat1, mat2, out=None)
对存储在两个批batch1和batch2内的矩阵进行批矩阵乘操作。torch.bmm(batch1, batch2, out=None)
用法：
>>> batch1 = torch.randn(10, 3, 4)
>>> batch2 = torch.randn(10, 4, 5)
>>> res = torch.bmm(batch1, batch2)
>>> res.size()
torch.Size([10, 3, 5])
返回一个新的张量，对输入的指定位置插入维度1。注意： 返回张量与输入张量共享内存，所以改变其中一个的内容会改变另一个。
用法：
>>> max_len=10
>>> position = torch.arange(0, max_len).float().unsqueeze(1)
>>> position
tensor([[0.],
[1.],
[2.],
[3.],
[4.],
[5.],
[6.],
[7.],
[8.],
[9.]])
>>> position = torch.arange(0, max_len).float().unsqueeze(0)
>>> position
tensor([[0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]])
>>>
https://pytorch-cn.readthedocs.io/zh/latest/package_references/Tensor/
view(*args): 返回一个有相同数据但大小不同的tensor。 返回的tensor必须有与原tensor相同的数据和相同数目的元素，但可以有不同的大小。(类似reshape)
masked_fill_(mask, value): 在mask值为1的位置处用value填充。mask的元素个数需和本tensor相同，但尺寸可以不同。