torch.nn【总结笔记】

torch.nn

torch.nn.Parameter()

torch.nn.Module

torch.nn.Sequential(* args)

torch.nn.ModuleList(modules=None)

torch.nn.Conv1d

一维卷积

class torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

• in_channels(int) – 输入信号的通道。

• out_channels(int) – 卷积产生的通道。

• kerner_size(int or tuple) - 卷积核的尺寸。

• stride(int or tuple, optional) - 卷积步长。

• padding (int or tuple, optional)- 输入的每一条边补充 0 的层数。

• dilation(int or tuple, `optional``) – 卷积核元素之间的间距。

• groups(int, optional) – 从输入通道到输出通道的阻塞连接数。

• bias(bool, optional) - 如果 bias=True，添加偏置。

torch.nn.Conv2d

二维卷积

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

• in_channels(int) – 输入信号的通道。

• out_channels(int) – 卷积产生的通道。

• kerner_size(int or tuple) - 卷积核的尺寸。

• stride(int or tuple, optional) - 卷积步长。

• padding(int or tuple, optional) - 输入的每一条边补充 0 的层数。

• dilation(int or tuple, optional) – 卷积核元素之间的间距。

• groups(int, optional) – 从输入通道到输出通道的阻塞连接数。

• bias(bool, optional) - 如果 bias=True，添加偏置。

torch.nn.MaxPool1d

一维maxpooling

torch.nn.MaxPool1d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

参数：

• kernel_size(int or tuple) - max pooling 的窗口大小。

• stride(int or tuple, optional) - max pooling 的窗口移动的步长。默认值是 kernel_size。

• padding(int or tuple, optional) - 输入的每一条边补充 0 的层数。

• dilation(int or tuple, optional) – 一个控制窗口中元素步幅的参数。

• return_indices - 如果等于 True，会返回输出最大值的序号，对于上采样操作会有帮助。

• ceil_mode - 如果等于 True，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的。

torch.nn.MaxPool2d

二维maxpooling

torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

• kernel_size(int or tuple) - max pooling 的窗口大小。

• stride(int or tuple, optional) - max pooling 的窗口移动的步长。默认值是 kernel_size。

• padding(int or tuple, optional) - 输入的每一条边补充 0 的层数。

• dilation(int or tuple, optional) – 一个控制窗口中元素步幅的参数。

• return_indices - 如果等于 True，会返回输出最大值的序号，对于上采样操作会有帮助。

• ceil_mode - 如果等于 True，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的。

torch.nn.AvgPool1d

torch.nn.AvgPool1d(kernel_size, stride=None, padding=0, ceil_mode=False, 
count_include_pad=True)

• kernel_size(int or tuple) - 池化窗口大小。

• stride(int or tuple, optional) - max pooling 的窗口移动的步长。默认值是 kernel_size。

• padding(int or tuple, optional) - 输入的每一条边补充 0 的层数。

• dilation(int or tuple, optional) – 一个控制窗口中元素步幅的参数。

• return_indices - 如果等于 True，会返回输出最大值的序号，对于上采样操作会有帮助。

• ceil_mode - 如果等于 True，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的。

torch.nn.AvgPool2d

torch.nn.AvgPool2d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True)

• kernel_size(int or tuple) - 池化窗口大小。

• stride(int or tuple, optional) - max pooling 的窗口移动的步长。默认值是 kernel_size。

• padding(int or tuple, optional) - 输入的每一条边补充 0 的层数。

• dilation(int or tuple, optional) – 一个控制窗口中元素步幅的参数。

• ceil_mode - 如果等于 True，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的操作。

• count_include_pad - 如果等于 True，计算平均池化时，将包括 padding 填充的 0。

torch.nn.AdaptiveMaxPool1d

 torch.nn.AdaptiveMaxPool1d(output_size, return_indices=False)

对输入信号，提供 1 维的自适应最大池化操作 对于任何输入大小的输入，可以将输出尺寸指定为 H，但是输入和输出特征的数目不会变化。

• output_size: 输出信号的尺寸。
• return_indices: 如果设置为 True，会返回输出的索引。对 nn.MaxUnpool1d 有用，默认值是 False。

torch.nn.AdaptiveMaxPool2d

对输入信号，提供 2 维的自适应最大池化操作 对于任何输入大小的输入，可以将输出尺寸指定为
H*W，但是输入和输出特征的数目不会变化。

torch.nn.AdaptiveMaxPool2d(output_size, return_indices=False)

• output_size: 输出信号的尺寸,可以用（H,W）表示 HxW 的输出，也可以使用数字 H 表示 HxH 大小
  的输出。
• return_indices: 如果设置为 True，会返回输出的索引。对 nn.MaxUnpool2d 有用，默认值是 False。

torch.nn.AdaptiveAvgPool1d

对输入信号，提供 1 维的自适应平均池化操作。

torch.nn.AdaptiveAvgPool1d(output_size)

• output_size: 输出信号的尺寸。

torch.nn.AdaptiveAvgPool2d

对输入信号，提供 2 维的自适应平均池化操作 对于任何输入大小的输入，可以将输出尺寸指定为
HxW，但是输入和输出特征的数目不会变化。

torch.nn.AdaptiveAvgPool2d(output_size)

• output_size: 输出信号的尺寸,可以用(H,W)表示 HxW 的输出，也可以使用耽搁数字 H 表示 HxH 大
  小的输出。

torch.nn.ReLU

torch.nn.ReLU(inplace=False)

• inplace-选择是否进行覆盖运算。

torch.nn.LeakyReLU

 torch.nn.LeakyReLU(negative_slope=0.01, inplace=False)

• negative_slope：控制负斜率的角度，默认等于 0.01。
• inplace-选择是否进行覆盖运算。

torch.nn.Sigmoid

对每个元素运用 Sigmoid 函数,输入和输出一样不会改变

torch.nn.Sigmoid()

torch.nn.Softmax

对 n 维输入张量运用 Softmax 函数，将张量的每个元素缩放到（0,1）区间且和为 1。
返回结果是一个与输入维度相同的张量，每个元素的取值范围在（0,1）区间。

torch.nn.Softmax

torch.nn.BatchNorm1d

对小批量(mini-batch)的 2d 或 3d 输入进行批标准化(Batch Normalization)操作。在每一个小批量（mini-batch）数据中，计算输入各个维度的均值和标准差。在训练时，该层计算每次输入的均值与方差，并进行移动平均。移动平均默认的动量值为 0.1。在验证时，训练求得的均值/方差将用于标准化验证数据。

 torch.nn.BatchNorm1d(num_features, eps=1e-05, momentum=0.1, affine=True)

• num_features： 来自期望输入的特征数。
• eps： 为保证数值稳定性（分母不能趋近或取 0）,给分母加上的值。默认为 1e-5。
• momentum： 动态均值和动态方差所使用的动量。默认为 0.1。
• affine： 一个布尔值，当设为 true，给该层添加可学习的仿射变换参数。

torch.nn.BatchNorm2d

对小批量(mini-batch)3d 数据组成的 4d 输入进行批标准化(Batch Normalization)操作。

torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True)

• num_features： 来自期望输入的特征数。
• eps： 为保证数值稳定性（分母不能趋近或取 0）,给分母加上的值。默认为 1e-5。
• momentum： 动态均值和动态方差所使用的动量。默认为 0.1。
• affine： 一个布尔值，当设为 true，给该层添加可学习的仿射变换参数。

torch.nn.Linear

对输入数据做线性变换：y=Ax+b。

torch.nn.Linear(in_features, out_features, bias=True)

• in_features - 每个输入样本的大小。
• out_features - 每个输出样本的大小。
• bias - 若设置为 False，这层不会学习偏置。默认值：True。

变量：

• weight -形状为(out_features x in_features)的模块中可学习的权值。
• bias -形状为(out_features)的模块中可学习的偏置。

torch.nn.Dropout

随机将输入张量中部分元素设置为 0。对于每次前向调用，被置 0 的元素都是随机的。
输入输出形状一样。

torch.nn.Dropout(p=0.5, inplace=False)

• p - 将元素置 0 的概率。默认值：0.5。
• in-place - 若设置为 True，会在原地执行操作。默认值：False。

torch.nn.Embedding

一个保存了固定字典和大小的简单查找表。
这个模块常用来保存词嵌入和用下标检索它们。模块的输入是一个下标的列表，输出是对应的词嵌入。

torch.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, max_norm=None, 
norm_type=2, scale_grad_by_freq=False, sparse=False)

• num_embeddings (int) - 嵌入字典的大小。
• embedding_dim (int) - 每个嵌入向量的大小。
• padding_idx (int, optional) - 如果提供的话，输出遇到此下标时用零填充。
• max_norm (float, optional) - 如果提供的话，会重新归一化词嵌入，使它们的范数小于提供的值。
• norm_type (float, optional) - 对于 max_norm 选项计算 p 范数时的 p。
• scale_grad_by_freq (boolean, optional) - 如果提供的话，会根据字典中单词频率缩放梯度。

torch.nn.MSELoss

创建一个衡量输入 x(模型预测输出)和目标 y 之间均方误差标准。

 torch.nn.MSELoss(size_average=True)

torch.nn.CrossEntropyLoss

此标准将 LogSoftMax 和 NLLLoss 集成到一个类中。
当训练一个多类分类器的时候，这个方法是十分有用的。

 torch.nn.CrossEntropyLoss(weight=None, size_average=True)

torch.nn.functional

torch.nn.functional.conv1d

torch.nn.functional.conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)

torch.nn.functional.conv2d

torch.nn.functional.conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)

pooling函数

torch.nn.functional.avg_pool1d(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True)

torch.nn.functional.avg_pool2d(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True)

torch.nn.functional.max_pool1d(input, kernel_size, stride=None, padding=0, dilation=1, ceil_mode=False, 
return_indices=False)

torch.nn.functional.max_pool2d(input, kernel_size, stride=None, padding=0, dilation=1, ceil_mode=False, 
return_indices=False)

torch.nn.functional.max_pool3d(input, kernel_size, stride=None, padding=0, dilation=1, ceil_mode=False, 
return_indices=False)

torch.nn.functional.max_unpool1d(input, indices, kernel_size, stride=None, padding=0, output_size=None)

torch.nn.functional.max_unpool2d(input, indices, kernel_size, stride=None, padding=0, output_size=None)

torch.nn.functional.max_unpool3d(input, indices, kernel_size, stride=None, padding=0, output_size=None)

torch.nn.functional.lp_pool2d(input, norm_type, kernel_size, stride=None, ceil_mode=False)

torch.nn.functional.adaptive_max_pool1d(input, output_size, return_indices=False)

torch.nn.functional.adaptive_max_pool2d(input, output_size, return_indices=False)

torch.nn.functional.adaptive_avg_pool1d(input, output_size)

torch.nn.functional.adaptive_avg_pool2d(input, output_size)

torch.nn.functional.batch_norm

torch.nn.functional.batch_norm(input, running_mean, running_var, weight=None, 
bias=None, training=False, momentum=0.1, eps=1e-05)

torch.nn.functional.linear

torch.nn.functional.linear(input, weight, bias=None)

torch.nn.functional.dropout

torch.nn.functional.dropout(input, p=0.5, training=False, inplace=False)

torch.nn.functional.nll_loss

torch.nn.functional.nll_loss(input, target, weight=None, size_average=True)

torch.nn.functional.cross_entropy

torch.nn.functional.cross_entropy(input, target, weight=None, size_average=True)

torch.nn.init.uniform

从均匀分布 U(a, b)中生成值，填充输入的张量或变量。

torch.nn.init.uniform(tensor, a=0, b=1)

torch.nn.init.normal

从给定均值和标准差的正态分布 N(mean, std)中生成值，填充输入的张量或变量

torch.nn.init.normal(tensor, mean=0, std=1)

torch.nn.init.constant

用 val 的值填充输入的张量或变量

torch.nn.init.constant(tensor, val)

torch.optim

torch.optim 是是一个实现了各种优化算法的库。
为了使用 torch.optim，你需要构建一个 optimizer 对象。这个对象能够保持当前参数状态并基于计算
得到的梯度进行参数更新。
例如:

optimizer = optim.SGD(model.parameters(), lr = 0.01, momentum=0.9)
optimizer = optim.Adam([var1, var2], lr = 0.0001)

所有的 optimizer 都实现了 step()方法，这个方法会更新所有的参数。它能按两种方式来使用：
optimizer.step()。这是大多数 optimizer 所支持的简化版本。一旦梯度被如 backward()之类的函数计算好后，我们就可以
调用这个函数。
常用的基本模版:

for input, target in dataset:
	optimizer.zero_grad()
	output = model(input)
	loss = loss_fn(output, target)
	loss.backward()
	optimizer.step()
optimizer.step(closure)

torch.optim.SGD

实现随机梯度下降算法（momentum 可选）。

torch.optim.SGD(params, lr=, monentum=0, dampening=0, weight_decay=0, nesterov=False)

• params (iterable) – 待优化参数的 iterable 或者是定义了参数组的 dict。
• lr (float) – 学习率。
• momentum (float, 可选) – 动量因子（默认：0）。
• weight_decay (float, 可选) – 权重衰减（L2 惩罚）（默认：0）。
• dampening (float, 可选) – 动量的抑制因子（默认：0）。
• nesterov (bool, 可选) – 使用 Nesterov 动量（默认：False）。

torch.cuda

该包增加了对 CUDA 张量类型的支持，实现了与 CPU 张量相同的功能，但使用 GPU 进行计算。
它是懒惰的初始化，所以你可以随时导入它，并使用 is_available()来确定系统是否支持 CUDA。

torch.cuda.current_blas_handle()
返回 cublasHandle_t 指针，指向当前 cuBLAS 句柄

torch.cuda.current_device()
返回当前所选设备的索引。

torch.cuda.current_stream()
返回一个当前所选的 Stream

class torch.cuda.device(idx)
上下文管理器，可以更改所选设备
	参数： - idx (int) – 设备索引选择。如果这个参数是负的，则是无效操作。
	
torch.cuda.device_count()
返回可得到的 GPU 数量。

torch.cuda.device_of(obj)
将当前设备更改为给定对象的上下文管理器。
可以使用张量和存储作为参数。如果给定的对象不是在 GPU 上分配的，这是一个无效操作。
	参数： - obj (Tensor or Storage) – 在选定设备上分配的对象。
	
torch.cuda.is_available()
返回一个 bool 值，指示 CUDA 当前是否可用。

torch.cuda.set_device(device)
设置当前设备。
不鼓励使用此函数来设置。在大多数情况下，最好使用 CUDA_VISIBLE_DEVICES 环境变量。
	参数： - device (int) – 所选设备。如果此参数为负，则此函数是无效操作。

torch.utils.data

torch.utils.data.DataLoader

数据加载器。组合数据集和采样器，并在数据集上提供单进程或多进程迭代器。

torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, num_workers=0, 
collate_fn=<function default_collate>, pin_memory=False, drop_last=False)

• dataset (Dataset) – 加载数据的数据集。
• batch_size (int, optional) – 每个 batch 加载多少个样本(默认: 1)。
• shuffle (bool, optional) – 设置为 True 时会在每个 epoch 重新打乱数据(默认: False)。
• sampler (Sampler, optional) – 定义从数据集中提取样本的策略。如果指定，则忽略 shuffle 参数。
• num_workers (int, optional) – 用多少个子进程加载数据。0 表示数据将在主进程中加载(默认: 0)。
• collate_fn (callable, optional) –
• pin_memory (bool, optional) –
• drop_last (bool, optional) – 如果数据集大小不能被 batch size 整除，则设置为 True 后可删除最后一
  个不完整的 batch。如果设为 False 并且数据集的大小不能被 batch size 整除，则最后一个 batch 将更小。
  (默认: False)。