1. 函数常见入参
   1. input：Tensor格式
   2. requires_grad：布尔值，aotugrad这里是否需要记录Tensor上的操作
   3. size：一般来说，测量尺寸的数据可以是多个数字或collection格式（如list或tuple等）
   4. device：Tensor所处的设备（cuda或CPU），可以用torch.device（见5.2部分)或直接使用字符串和数值（torch.device替代。 使用torch.device以入参为例：torch.randn((2,3), device=torch.device('cuda:1')) 以字符串直接作为入参的示例：torch.randn((2,3), device='cuda:1') 以数值直接作为入参示例：torch.rand((2,3), device=1)
2. 函数名前加_是原地操作
3. Parameters是可以直接按照顺序放的，Keyword Arguments则必须指定参数名（用*作为区分）

1. is_tensor(obj) 如果obj是Tensor，就返回True 注意：官方建议使用 isinstance(obj, Tensor) 作为代替

注意：通过随机取样生成Tensor的函数放在了Random sampling部分。

1. tensor(data, *, dtype=None, device=None, requires_grad=False, pin_memory=False) 将data转换为Tensor。data可以是list, tuple, NumPy ndarray, scalar等呈现数组形式的数据
2. from_numpy(ndarray) 将一个numpy.ndarray转换为Tensor。注意这一函数的两个数据对象占用同一储存空间，修改后变化也会体现在另一对象上
3. zeros(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) 返回一个尺寸为size的Tensor，所有元素都为0
4. ones(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) 返回一个尺寸为size的Tensor，所有元素都为1
5. ones_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) 返回一个与input有相同尺寸的Tensor，所有元素都为1
6. arange(start=0, end, step=1, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) 示例：

>>> torch.arange(5)
tensor([ 0,  1,  2,  3,  4])
>>> torch.arange(1, 4)
tensor([ 1,  2,  3])
>>> torch.arange(1, 2.5, 0.5)
tensor([ 1.0000,  1.5000,  2.0000])

1. cat(tensors, dim=0, *, out=None) 串接tensors（一串Tensor，非空Tensor在非dim维度必须形状相同），返回结果
2. reshape(input, shape) 示例：

>>> a = torch.arange(4.)
>>> torch.reshape(a, (2, 2))
tensor([[ 0.,  1.],
        [ 2.,  3.]])
>>> b = torch.tensor([[0, 1], [2, 3]])
>>> torch.reshape(b, (-1,))
tensor([ 0,  1,  2,  3])

3. squeeze(input, dim=None, *, out=None) 去掉input（Tensor）中长度为1的维度，返回这个Tensor。如果有dim就只对指定维度进行squeeze操作。 返回值与input共享储存空间。 示例代码：

>>> x = torch.zeros(2, 1, 2, 1, 2)
>>> x.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x)
>>> y.size()
torch.Size([2, 2, 2])
>>> y = torch.squeeze(x, 0)
>>> y.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x, 1)
>>> y.size()
torch.Size([2, 2, 1, 2])

4. stack(tensors, dim=0, *, out=None) 连接tensors（一串形状相同的Tensor），返回结果
5. t(input) 零维和一维input不变，二维input转置，返回结果
6. transpose(input, dim0, dim1) 返回input转置的Tensor，dim0和dim1交换。 返回值与input共享储存空间。 示例代码：

>>> x = torch.randn(2, 3)
>>> x
tensor([[ 1.0028, -0.9893,  0.5809],
        [-0.1669,  0.7299,  0.4942]])
>>> torch.transpose(x, 0, 1)
tensor([[ 1.0028, -0.1669],
        [-0.9893,  0.7299],
        [ 0.5809,  0.4942]])

7. unsqueeze(input, dim) 在input指定维度插入一个长度为1的维度，返回Tensor 示例代码：

>>> x = torch.tensor([1, 2, 3, 4])
>>> torch.unsqueeze(x, 0)
tensor([[ 1,  2,  3,  4]])
>>> torch.unsqueeze(x, 1)
tensor([[ 1],
        [ 2],
        [ 3],
        [ 4]])

8. nonzero(input, *, out=None, as_tuple=False)

①as_tuple=False：返回一个二维Tensor，每一行是一个input非零元素的索引 示例代码：

>>> torch.nonzero(torch.tensor([1, 1, 1, 0, 1]))
tensor([[ 0],
        [ 1],
        [ 2],
        [ 4]])
>>> torch.nonzero(torch.tensor([[0.6, 0.0, 0.0, 0.0],
...                             [0.0, 0.4, 0.0, 0.0],
...                             [0.0, 0.0, 1.2, 0.0],
...                             [0.0, 0.0, 0.0,-0.4]]))
tensor([[ 0,  0],
        [ 1,  1],
        [ 2,  2],
        [ 3,  3]])

②as_tuple=True：返回一个由一维索引Tensor组成的tuple（每个元素是一个维度上的索引） 示例代码：

>>> torch.nonzero(torch.tensor([1, 1, 1, 0, 1]), as_tuple=True)
(tensor([0, 1, 2, 4]),)
>>> torch.nonzero(torch.tensor([[0.6, 0.0, 0.0, 0.0],
...                             [0.0, 0.4, 0.0, 0.0],
...                             [0.0, 0.0, 1.2, 0.0],
...                             [0.0, 0.0, 0.0,-0.4]]), as_tuple=True)
(tensor([0, 1, 2, 3]), tensor([0, 1, 2, 3]))
>>> torch.nonzero(torch.tensor(5), as_tuple=True)
(tensor([0]),)

10. where()
    1. where(condition) 和 torch.nonzero(condition, as_tuple=True) 相同

1. manual_seed(seed)
2. randperm(n, *, generator=None, out=None, dtype=torch.int64, layout=torch.strided, device=None, requires_grad=False, pin_memory=False)：返回 0 - n-1 整数的一个随机permutation 示例：

>>> torch.randperm(4)
tensor([2, 1, 0, 3])

返回默认的CPU torch.Generator

1. rand(*size, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) 返回一个尺寸为size的Tensor，所有元素通过[0,1)的均匀分布采样生成
2. rand_like(input, *, dtype=None, layout=None, device=None, requires_grad=False, memory_format=torch.preserve_format) 返回一个跟input有相同尺寸的Tensor，所有元素通过[0,1)的均匀分布采样生成

1. save(obj, f, pickle_module=pickle, pickle_protocol=2, _use_new_zipfile_serialization=True)
2. load(f, map_location=None, pickle_module=pickle, **pickle_load_args)

1. add()返回结果Tensor
   1. add(input, other, *, out=None) other是标量，对input每个元素加上other
   2. add(input, other, *, alpha=1, out=None) other是Tensor，other先逐元素乘标量alpha再逐元素加input
2. mul(input, other, *, out=None) 若other是标量：对input每个元素乘以other 若other是Tensor：input和other逐元素相乘 返回结果Tensor
3. tanh(input, *, out=None) 对input逐元素做tanh运算。返回Tensor

1. max()
   1. max(input)
   2. max(input, dim, keepdim=False, *, out=None)
   3. max(input, other, *, out=None) 见1.7.3 maximum()
2. sum(input, *, dtype=None) 返回input（Tensor）中所有元素的加和，返回Tensor dtype是期望返回值的dtype
3. mean(input) 返回input（Tensor）中所有元素的平均值，返回Tensor

1. maximum(input, other, *, out=None) 逐元素计算input和other中较大的元素

1. flatten(input, start_dim=0, end_dim=- 1) 示例：

>>> t = torch.tensor([[[1, 2],
...                    [3, 4]],
...                   [[5, 6],
...                    [7, 8]]])
>>> torch.flatten(t)
tensor([1, 2, 3, 4, 5, 6, 7, 8])
>>> torch.flatten(t, start_dim=1)
tensor([[1, 2, 3, 4],
        [5, 6, 7, 8]])

BLAS简介 LAPACK

1. Module 所有神经网络单元的基本类，神经网络模型应当是Module的子类。可以在Module对象里面放Module对象（以树形结构存储），在__init__方法中将这些子Module定义为属性即可
   1. eval() 将Module设置为evaluation mode，相当于 self.train(False)。
   2. parameters(recurse=True) 返回Module参数（一堆Tensor）的迭代器，一般都是用来传入优化器的
   3. train(mode=True) 如果入参为True，则将Module设置为training mode，training随之变为True；反之则设置为evaluation mode，training为False。
   4. zero_grad(set_to_none=False) 设置所有模型参数的梯度为0，类似于21.2 优化器的zero_grad()
2. Sequential(*args) 顺序容器。Module就按照被传入构造器的顺序添加。也可以传入ordered dict 示例代码：

# Example of using Sequential
model = nn.Sequential(
          nn.Conv2d(1,20,5),
          nn.ReLU(),
          nn.Conv2d(20,64,5),
          nn.ReLU()
        )

# Example of using Sequential with OrderedDict
model = nn.Sequential(OrderedDict([
          ('conv1', nn.Conv2d(1,20,5)),
          ('relu1', nn.ReLU()),
          ('conv2', nn.Conv2d(20,64,5)),
          ('relu2', nn.ReLU())
        ]))

3. ModuleList(modules=None) 以类似list的形式储存submodules。可以像标准list一样切片，但被包含的modules会自动注册，且对所有Module方法都是可见的。 示例代码：

class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(10)])

    def forward(self, x):
        # ModuleList can act as an iterable, or be indexed using ints
        for i, l in enumerate(self.linears):
            x = self.linears[i // 2](x) + l(x)
        return x

MyModule就是有10层线性网络的神经网络模型了。

1. class Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode=‘zeros’) 在输入信号（由几个平面图像构成）上应用2维卷积

1. class ReLU(inplace=False) 逐元素应用修正线性单元（ReLU： R e L U ( x ) = ( x ) + = m a x ( 0 , x ) ReLU(x)=(x) ^+ =max(0,x) ReLU(x)=(x)+=max(0,x)）

1. class LogSoftmax(dim=None)

1. class BatchNorm1d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) batch normalization¹

1. class Linear(in_features, out_features, bias=True) 对输入信号进行一个线性转换： y = x A T + b y = xA^T + b y=xAT+b

1. class torch.nn.Dropout²(p=0.5, inplace=False) 在训练过程中，随机将input tensor以概率为p的伯努利分布置0。每一次forward call独立。 这一方法被证明对正则化和防止co-adaptation of neurons（我还不知道这是啥意思）有效，文献：Improving neural networks by preventing co-adaptation of feature detectors 此外，训练时输出会乘以 1 1 − p \frac{1}{1-p} 1−p1​，则在评估模型时直接输出结果即可。

1. class torch.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, max_norm=None, norm_type=2.0, scale_grad_by_freq=False, sparse=False, _weight=None) embedding词典。相当于一个大矩阵，每一行存储一个word的embedding。Embedding.weight是这个矩阵的值（Tensor），weight.data可以改变该值。 输入是索引的列表（IntTensor或LongTensor），输出是对应的词嵌入（尺寸为 (input尺寸,embedding_dim) ）。 num_embeddings是词典长度（int）。 embedding_dim是表示向量维度（int）。
   1. weight：尺寸为 (num_embeddings, embedding_dim) ，从 N ( 0 , 1 ) \mathcal{N}(0,1) N(0,1) 中初始化数据。

示例代码：