torch.nn.functional

1. Convolution 函数
2. Pooling 函数
3. 非线性激活函数
4. Normalization 函数
5. 线性函数
6. Dropout 函数
7. 距离函数（Distance functions）
8. 损失函数（Loss functions）
9. Vision functions）

Convolution 函数

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

对由几个输入平面组成的输入信号应用一维卷积。

详细信息和输出形状，查看Conv1d

参数：

1. input – 输入张量的形状 (minibatch x in_channels x iW)
2. weight – 过滤器的形状 (out_channels, in_channels, kW)
3. bias – 可选偏置的形状(out_channels)。默认值：None
4. stride – 卷积内核的步长，默认为1
5. padding – 输入上的隐含零填充。可以是单个数字或元组。默认值:0
6. dilation – 内核元素之间的间距。默认值:1
7. groups – 将输入分成组，in_channels应该被组数整除。默认值：1

例子：

>>> filters = autograd.Variable(torch.randn(33, 16, 3))
>>> inputs = autograd.Variable(torch.randn(20, 16, 50))
>>> F.conv1d(inputs, filters)

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

在由几个输入平面组成的输入图像上应用2D卷积。

有关详细信息和输出形状，查看Conv2d。

参数：

1. input – 输入的张量 (minibatch x in_channels x iH x iW)
2. weight – 过滤器 (out_channels, in_channels/groups, kH, kW)
3. bias – 可选偏置张量(外通道)。默认值：None
4. stride – 卷积核的步长，可以是单个数字或元组（sh x sw）。默认值：1
5. padding – 输入上的隐含零填充。可以是单个数字或元组。默认值:0
6. dilation – 内核元素之间的间距。默认值：1
7. groups – 将输入分成组，in_channels应该被组数整除。默认值：1

例子：

>>> # With square kernels and equal stride
>>> filters = autograd.Variable(torch.randn(8,4,3,3))
>>> inputs = autograd.Variable(torch.randn(1,4,5,5))
>>> F.conv2d(inputs, filters, padding=1)

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

在由几个输入平面组成的输入图像上应用3D卷积。

有关详细信息和输出形状， 查看Conv3d。

参数：

1. input – 输入张量的形状 (minibatch x in_channels x iH x iW)
2. weight – 过滤器的形状 (out_channels, in_channels/groups, kH, kW)
3. bias – 可选偏差的形状(外通道)
4. stride – 卷积核的步长，可以是单个数字或元组（st x sh x sw）。默认值：1
5. padding – 在输入中隐式的零填充。可以是单个数字或元组。默认值:0
6. dilation – 内核元素之间的间距。默认值：1
7. groups – 将输入分成组，in_channels应该被组数整除。默认值：1

例子：

>>> filters = autograd.Variable(torch.randn(33, 16, 3, 3, 3))
>>> inputs = autograd.Variable(torch.randn(20, 16, 50, 10, 20))
>>> F.conv3d(inputs, filters)

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

在由几个输入平面组成的输入图像上应用1D转置卷积，有时也被称为去卷积。 有关详细信息和输出形状，参考ConvTranspose1d。 参数：

1. input – 输入张量的形状 (minibatch x in_channels x iW)
2. weight – 过滤器的形状 (in_channels x out_channels x kW)
3. bias – 可选偏差的形状(外通道)
4. stride – 卷积核的步长，可以是单个数字或元组（st x sh x sw）。默认值：1
5. output_padding – 在输入中隐式的零填充。可以是单个数字或元组。默认值:0
6. dilation – 内核元素之间的间距。默认值：1
7. groups – 将输入分成组，in_channels应该被组数整除。默认值：1

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

在由几个输入平面组成的输入图像上应用二维转置卷积，有时也称为“去卷积”。

有关详细信息和输出形状，查看ConvTranspose2d。

参数：

1. input – 输入张量的形状 (minibatch x in_channels x iH x iW)
2. weight – 过滤器的形状 (in_channels x out_channels x kH x kW)
3. bias – 可选偏差的形状(外通道)
4. stride – 卷积核的步长，可以是单个数字或元组（st x sh x sw）。默认值：1
5. output_padding – 在输入中隐式的零填充。可以是单个数字或元组。默认值:0
6. padding – 在输入中隐式的零填充，可以是一个数字或一个元组(padh x padw)。默认值:0
7. dilation – 内核元素之间的间距。默认值：1
8. groups – 将输入分成组，in_channels应该被组数整除。默认值：1
9. dilation - 内核元素之间的间距。默认值：1

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

在由几个输入平面组成的输入图像上应用三维转置卷积，有时也称为“去卷积”。

有关详细信息和输出形状，参考ConvTranspose3d。

参数：

1. input – 输入张量的形状 (minibatch x in_channels x iT x iH x iW)
2. weight – 过滤器的形状 (in_channels x out_channels x kH x kW)
3. bias – 可选偏差的形状(外通道)
4. stride – 卷积核的步长，可以是单个数字或元组（st x sh x sw）。默认值：1
5. output_padding – 在输入中隐式的零填充。可以是单个数字或元组。默认值:0
6. padding – 在输入中隐式的零填充，可以是一个数字或一个元组(padh x padw)。默认值:0
7. dilation – 内核元素之间的间距。默认值：1
8. groups – 将输入分成组，in_channels应该被组数整除。默认值：1
9. dilation - 内核元素之间的间距。默认值：1

Pooling 函数

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

对由几个输入平面组成的输入信号进行一维平均池化。

有关详细信息和输出形状，参考AvgPool1d。

参数：

1. kernel_size – 窗口的大小
2. stride – 窗口的步长。默认值为kernel_size
3. padding – 在两边添加隐式零填充
4. ceil_mode – 当为True时，将使用ceil代替floor来计算输出形状
5. count_include_pad – 当为True时，将包括平均计算中的零填充。默认值：True

例子：

>>> # pool of square window of size=3, stride=2
>>> input = Variable(torch.Tensor([[[1,2,3,4,5,6,7]]]))
>>> F.avg_pool1d(input, kernel_size=3, stride=2)
Variable containing:
(0 ,.,.) =
  2  4  6
[torch.FloatTensor of size 1x1x3]

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

通过步长dh x dw步骤在kh x kw区域中应用二维平均池操作。输出特征的数量等于输入平面的数量。

有关详细信息和输出形状，参考AvgPool2d。

参数：

1. input – 输入的张量 (minibatch x in_channels x iH x iW)
2. kernel_size – 池化区域的大小，可以是单个数字或者元组 (kh x kw)
3. stride – 池化操作的步长，可以是单个数字或者元组 (sh x sw)。默认值等于内核大小
4. padding – 在输入上隐式的零填充，可以是单个数字或者一个元组 (padh x padw)，默认: 0
5. ceil_mode – 当为True时，公式中将使用ceil而不是floor来计算输出形状。默认值：False
6. count_include_pad – 当为True时，将包括平均计算中的零填充。默认值：True

torch.nn.functional.avg_pool3d(input, kernel_size, stride=None)

通过步长dt x dh x dw步骤在kt x kh x kw区域中应用3D平均池操作。输出功能的数量等于输入平面数/ dt。

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)

在由几个输入平面组成的输入信号上应用1D自适应最大池化。

有关详细信息和输出形状，参考AdaptiveMaxPool1d。

参数：

1. output_size – 目标输出大小（单个整数）
2. return_indices – 是否返回池索引。默认值：False

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

在由几个输入平面组成的输入信号上应用2D自适应最大池化。

有关详细信息和输出形状，参考AdaptiveMaxPool2d。

参数：

1. output_size – 目标输出大小（单整数或双整数元组）
2. return_indices – 是否返回池索引。默认值：False

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

在由几个输入平面组成的输入信号上应用1D自适应平均池化。

有关详细信息和输出形状，参考AdaptiveAvgPool1d。

参数：

1. output_size – 目标输出大小（单整数）

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

在由几个输入平面组成的输入信号上应用2D自适应平均池化。

有关详细信息和输出形状，参考AdaptiveAvgPool2d。

参数：

1. output_size – 目标输出大小（单整数或双整数元组）

非线性激活函数

torch.nn.functional.threshold(input, threshold, value, inplace=False)

torch.nn.functional.relu(input, inplace=False)

torch.nn.functional.hardtanh(input, min_val=-1.0, max_val=1.0, inplace=False)

torch.nn.functional.relu6(input, inplace=False)

torch.nn.functional.elu(input, alpha=1.0, inplace=False)

torch.nn.functional.leaky_relu(input, negative_slope=0.01, inplace=False)

torch.nn.functional.prelu(input, weight)

torch.nn.functional.rrelu(input, lower=0.125, upper=0.3333333333333333, training=False, inplace=False)

torch.nn.functional.logsigmoid(input)

torch.nn.functional.hardshrink(input, lambd=0.5)

torch.nn.functional.tanhshrink(input)

torch.nn.functional.softsign(input)

torch.nn.functional.softplus(input, beta=1, threshold=20)

torch.nn.functional.softmin(input)

torch.nn.functional.softmax(input)

torch.nn.functional.softshrink(input, lambd=0.5)

torch.nn.functional.log_softmax(input)

torch.nn.functional.tanh(input)

torch.nn.functional.sigmoid(input)

Normalization 函数

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

在指定维度上执行输入的（L_p \）归一化。 请问： [v = \frac{v}{\max(\lVert v \rVert_p, \epsilon)}]

对于每个子感应器v超过输入的尺寸变暗。每个子传感器被平坦化为向量，即\（\ lVert v \ rVert_p \）不是矩阵范数。

使用默认参数，通过欧几里德范数对第二维进行规范化。

参数：

1. input - 输入张量的形状
2. p（float） - 规范公式中的指数值。默认值：2
3. dim（int） - 要缩小的维度。默认值：1
4. eps（float） - 小值以避免除以零。默认值：1e-12

线性函数

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

Dropout 函数

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

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

将Alpha退出应用于输入。 详情查看AlphaDropout。

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

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

距离函数（Distance functions）

torch.nn.functional.pairwise_distance(x1, x2, p=2, eps=1e-06)

计算向量v1、v2之间的距离（成次或者成对，意思是可以计算多个，可以参看后面的参数）

参数：

1. x1 - 第一个输入的张量,
2. x2 - 第二个输入的张量
3. p - 矩阵范数的维度。默认值是2，即二范数。
4. eps(float，可选) - 小值以避免除以零。默认值：1e-8

规格：

1. 输入 - (N,D)其中D等于向量的维度
2. 输出 - (N,1)其中1位于dim。

例子：

>>> input1 = autograd.Variable(torch.randn(100, 128))
>>> input2 = autograd.Variable(torch.randn(100, 128))
>>> output = F.pairwise_distance(input1, input2, p=2)
>>> output.backward()

torch.nn.functional.cosine_similarity(x1, x2, dim=1, eps=1e-08)

计算向量v1、v2之间的距离（成次或者成对，意思是可以计算多个，可以参看后面的参数）

参数:

1. x1 (Variable) – 首先输入参数.
2. x2 (Variable) – 第二个输入参数 (of size matching x1).
3. dim (int, optional) – 向量维数. 默认为: 1
4. eps (float, optional) – 小值避免被零分割。默认为: 1e-8 模型：
5. 输入: (∗1,D,∗2)(∗1,D,∗2) D点定位
6. 输出: (∗1,∗2)(∗1,∗2) 1点定位

>>> input1 = autograd.Variable(torch.randn(100, 128))
>>> input2 = autograd.Variable(torch.randn(100, 128))
>>> output = F.cosine_similarity(input1, input2)
>>> print(output)

损失函数（Loss functions）

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

可能损失负对数,详细请看NLLLoss.

参数：

1. input - (N,C) C=类别的个数或者在例子2D-loss中的(N, C, H, W)
2. target - (N) 其大小是 0 <= targets[i] <= C-1 1. weight (Variable, optional) – 每个类都有一个手动的重新分配的重量。如果给定，则必须是一个大小为“nclasses”的变量

3. size_average (bool, optional) – 默认情况下，是mini-batchloss的平均值；如果size_average=False，则是mini-batchloss的总和。

4. ignore_index (int, optional) - 指定一个被忽略的目标值，并且不影响输入梯度。当size平均值为真时，在非被忽略的目标上的损失是平均的。

例子：

>>> # input is of size nBatch x nClasses = 3 x 5
>>> input = autograd.Variable(torch.randn(3, 5))
>>> # each element in target has to have 0 <= value < nclasses
>>> target = autograd.Variable(torch.LongTensor([1, 0, 4]))
>>> output = F.nll_loss(F.log_softmax(input), target)
>>> output.backward()

torch.nn.functional.poisson_nll_loss(input, target, log_input=True, full=False, size_average=True)

负的log likelihood损失函数. 详细请看NLLLoss.

参数说明:

1. input – 对Poisson的潜在分配的预期值。
2. target – 随机样本目标目标target∼Pois(input).
3. log_input – 如果True，则将损失计算为 exp（input） - target input，如果False则输入损失 - target log（input）。默认值：True
4. full – 是否计算全部损失，即添加斯特林近似项。默认值：False target log（target） - target + 0.5 log（2 pi target）。
5. size_average – 默认情况下，每个小型服务器的损失是平均的。然而，如果字段sizeAverage设置为False，则相应的损失代替每个minibatch的求和。默认值：True

torch.nn.functional.cosine_embedding_loss(input1, input2, target, margin=0, size_average=True)

torch.nn.functional.kl_div(input, target, size_average=True)

KL 散度损失函数，详细请看KLDivLoss

参数：

1. input – 变量的任意形状
2. target - 与输入相同形状的变量
3. size_average – 如果是真的，输出就除以输入张量中的元素个数

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

此标准将log_softmax和nll_loss组合在一个函数中。详细请看CrossEntropyLoss

参数：

1. input - (N,C) 其中，C 是类别的个数
2. target - (N) 其大小是 0 <= targets[i] <= C-1 1. weight (Variable, optional) – (N) 其大小是 0 <= targets[i] <= C-1
3. weight (Variable, optional) – 为每个类别提供的手动权重。如果给出，必须是大小“nclasses”的张量
4. size_average (bool, optional) – 默认情况下，是mini-batchloss的平均值；如果size_average=False，则是mini-batchloss的总和。
5. ignore_index（int，可选） - 指定被忽略且不对输入渐变有贡献的目标值。当size_average为True时，对非忽略目标的损失是平均的。默认值：-100

torch.nn.functional.hinge_embedding_loss（input，target，margin = 1.0，size_average = True ）

torch.nn.functional.l1_loss(input, target, size_average=True)

torch.nn.functional.mse_loss(input, target, size_average=True)

torch.nn.functional.margin_ranking_loss(input1, input2, target, margin=0, size_average=True)

torch.nn.functional.multilabel_margin_loss(input, target, size_average=True)

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

torch.nn.functional.multi_margin_loss(input, target, p=1, margin=1, weight=None, size_average=True)

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

负对数似然损失。 详情看NLLLoss。

参数：

1. input - \（（N，C）\）其中C =类的数量或（ 2D，Loss ）的情况下的（N，C，H，W） target - \（（N）\），其中每个值为0 <= targets [i] <= C-1
2. weight（可变，可选） - 给每个类别的手动重新调整重量。如果给定，必须是大小变量“nclasses”
3. size_average（bool，可选） - 默认情况下，损失是对每个小型服务器的观察值进行平均。如果size_average为False，则对于每个minibatch都会将损失相加。默认值：True
4. ignore_index（int，可选） - 指定被忽略且不对输入渐变有贡献的目标值。当size_average为True时，对非忽略目标的损失是平均的。默认值：-100

例子：

>>> # input is of size nBatch x nClasses = 3 x 5
>>> input = autograd.Variable(torch.randn(3, 5))
>>> # each element in target has to have 0 <= value < nclasses
>>> target = autograd.Variable(torch.LongTensor([1, 0, 4]))
>>> output = F.nll_loss(F.log_softmax(input), target)
>>> output.backward()

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

测量目标和输出逻辑之间二进制十进制熵的函数： 详情看BCEWithLogitsLoss。 参数：

1. input - 任意形状的变量
2. target - 与输入形状相同的变量
3. weight（可变，可选） - 手动重量重量，如果提供重量以匹配输入张量形状
4. size_average（bool，可选） - 默认情况下，损失是对每个小型服务器的观察值进行平均。然而，如果字段sizeAverage设置为False，则相应的损失代替每个minibatch的求和。默认值：True

torch.nn.functional.smooth_l1_loss(input, target, size_average=True)

torch.nn.functional.soft_margin_loss(input, target, size_average=True)

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

该函数计算了输出与target之间的二进制交叉熵，详细请看BCELoss

参数：

1. input – 变量的任意形状
2. target – 与输入相同形状的变量
3. weight (Variable, optional) – 每个类都有一个手动的重新分配的重量。如果给定，则必须是一个大小为“nclasses”的变量
4. size_average (bool, optional) – 默认情况下，是mini-batchloss的平均值；如果size_average=False，则是mini-batchloss的总和。

torch.nn.functional.smooth_l1_loss(input, target, size_average=True)

torch.nn.functional.triplet_margin_loss(anchor, positive, negative, margin=1.0, p=2, eps=1e-06, swap=False)

创建一个标准来衡量一个三元组的损失，给定一个输入张量x1，x2，x3和一个大于0的值。这用于测量样本之间的相对相似性。三元组由A、p和n组成:分别是锚、正的例子和负的例子。所有输入变量的形状应该是(N，D)(N，D)。 在V.Balntas、V.Balntas等人的研究中，详细地描述了“距离交换”的细节描述。 参数：

1. anchor – 输入固定的张量
2. positive – 输入正面的张量
3. negative – 输入否定的张量
4. p – 规范程度. 默认: 2
5. eps – 小量数值避免数值问题
6. swap – 计算距离交换 模型：
7. Input: (N,D)， D = 向量的维数
8. Output: (N,1)

>>> input1 = autograd.Variable(torch.randn(100, 128))
>>> input2 = autograd.Variable(torch.randn(100, 128))
>>> input3 = autograd.Variable(torch.randn(100, 128))
>>> output = F.triplet_margin_loss(input1, input2, input3, p=2)
>>> output.backward()

视觉 函数（vision functions）

torch.nn.functional.pixel_shuffle(input, upscale_factor)[source]

将形状为[*, C*r^2, H, W]的张量重新排列成形状为[C, H*r, W*r]的张量.详细请看PixelShuffle.

参数说明:

1. input (Variable) – 输入
2. upscale_factor (int) – 增加空间分辨率的因子.

例子:

>>> ps = nn.PixelShuffle(3)
>>> input = autograd.Variable(torch.Tensor(1, 9, 4, 4))
>>> output = ps(input)
>>> print(output.size())
torch.Size([1, 1, 12, 12])

torch.nn.functional.pad(input, pad, mode='constant', value=0)

填充张量.

目前为止,只支持2D和3D填充. Currently only 2D and 3D padding supported. 当输入为4D Tensor的时候,pad应该是一个4元素的tuple (pad_l, pad_r, pad_t, pad_b ) ,当输入为5D Tensor的时候,pad应该是一个6元素的tuple (pleft, pright, ptop, pbottom, pfront, pback).

形参说明:

1. input (Variable) – 4D 或 5D tensor
2. pad (tuple) – 4元素 或 6-元素 tuple
3. mode – ‘constant’, ‘reflect’ or ‘replicate’
4. value – 用于constant padding 的值.

torch.nn.functional.upsample(input, size=None, scale_factor=None, mode='nearest')

Upsamples输入内容要么就是给定的size或者scale_factor 用于采样的算法是由模型决定的 目前支持的是空间和容量的采样，即期望输入的形状是4-d或5-d。 输入尺寸被解释为:迷你批x通道x深度x高度x宽度 用于up抽样的模式是:最近的，双线性的(4d)，三线性(5d)

参数说明：

1. input (Variable) – 输入内容
2. size (int or Tuple[int, int] or Tuple[int, int, int]) – 输出空间的大小。
3. scale_factor (int) – 乘数的空间大小。必须是一个整数。
4. mode (string) – 用于向上采样的算法: ‘nearest’ | ‘bilinear’ | ‘trilinear’

torch.nn.functional.upsample_nearest(input, size=None, scale_factor=None)

使用最接近的邻居的像素值来对输入进行采样。 注意:这个函数是被弃用的。使用nn.functional。upsample相反 目前支持的空间和容量的采样是支持的(例如，预期的输入是4或5维)。 参数说明： input (Variable) – 输入内容 size (int or Tuple[int, int] or Tuple[int, int, int]) – 输出空间的大小。 scale_factor (int) – 乘数的空间大小。必须是一个整数。

torch.nn.functional.upsample_bilinear(input, size=None, scale_factor=None)

使用双线性向上采样来扩展输入。 注意:这个函数是被弃用的。使用nn.functional。upsample相反 预期的输入是空间的(4维)。使用upsampletri线性来进行体积(5维)输入。 参数说明：

1. input (Variable) – 输入内容
2. size (int or Tuple[int, int]) – 输出空间的大小。
3. scale_factor (int or Tuple[int, int]) – 乘数的空间大小