国产欧美另类精品,屌嗨软件

原文：PyTorth torch功能

卷積函數(shù)

轉(zhuǎn)換

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

在由多個輸入平面組成的輸入信號上應(yīng)用一維卷積。

注意

在某些情況下，將 CUDA 后端與 CuDNN 一起使用時，該運(yùn)算符可能會選擇不確定的算法來提高性能。如果不希望這樣做，則可以通過設(shè)置torch.backends.cudnn.deterministic = True來使操作具有確定性(可能會降低性能）。請參閱關(guān)于可再現(xiàn)性的注意事項(xiàng)作為背景。

參數(shù)

輸入 –形狀為的輸入張量
重量 –形狀為的過濾器
偏差-形狀的可選偏差。默認(rèn)值：None
步幅 –卷積內(nèi)核的步幅。可以是一個整數(shù)或一個元素的元組<cite>(sW，）</cite>。默認(rèn)值：1
填充 –輸入兩側(cè)的隱式填充。可以是一個整數(shù)或一個元素的元組<cite>(padW，）</cite>。默認(rèn)值：0
膨脹 –內(nèi)核元素之間的間距。可以是一個整數(shù)或一個元素的元組<cite>(dW，）</cite>。默認(rèn)值：1
組 –將輸入分成組，應(yīng)該可被組數(shù)整除。默認(rèn)值：1

例子：

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

轉(zhuǎn)換 2d

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

在由多個輸入平面組成的輸入圖像上應(yīng)用 2D 卷積。

Note

In some circumstances when using the CUDA backend with CuDNN, this operator may select a nondeterministic algorithm to increase performance. If this is undesirable, you can try to make the operation deterministic (potentially at a performance cost) by setting torch.backends.cudnn.deterministic = True. Please see the notes on Reproducibility for background.

Parameters

輸入 –形狀為的輸入張量
重量 –形狀為的過濾器
偏差-形狀的可選偏差張量。默認(rèn)值：None
步幅 –卷積內(nèi)核的步幅。可以是單個數(shù)字或元組<cite>(sH，sW）</cite>。默認(rèn)值：1
填充 –輸入兩側(cè)的隱式填充。可以是單個數(shù)字或元組<cite>(padH，padW）</cite>。默認(rèn)值：0
膨脹 –內(nèi)核元素之間的間距。可以是單個數(shù)字或元組<cite>(dH，dW）</cite>。默認(rèn)值：1
組 –將輸入分成組，應(yīng)該可被組數(shù)整除。默認(rèn)值：1

Examples:

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

conv3d

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

在由多個輸入平面組成的輸入圖像上應(yīng)用 3D 卷積。

Note

Parameters

輸入 –形狀為的輸入張量
重量 –形狀為的過濾器
偏置-形狀為的可選偏置張量。默認(rèn)值：無
步幅 –卷積內(nèi)核的步幅。可以是單個數(shù)字或元組<cite>(sT，sH，sW）</cite>。默認(rèn)值：1
填充 –輸入兩側(cè)的隱式填充。可以是單個數(shù)字或元組<cite>(padT，padH，padW）</cite>。默認(rèn)值：0
膨脹 –內(nèi)核元素之間的間距。可以是單個數(shù)字或元組<cite>(dT，dH，dW）</cite>。默認(rèn)值：1
groups – split input into groups, should be divisible by the number of groups. Default: 1

Examples:

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

conv_transpose1d

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

在由幾個輸入平面組成的輸入信號上應(yīng)用一維轉(zhuǎn)置卷積運(yùn)算符，有時也稱為“反卷積”。

Note

Parameters

input – input tensor of shape
重量 –形狀為的過濾器
偏差-形狀的可選偏差。默認(rèn)值：無
步幅 –旋轉(zhuǎn)內(nèi)核的步幅。可以是單個數(shù)字或元組(sW,)。默認(rèn)值：1
填充 – dilation * (kernel_size - 1) - padding零填充將添加到輸入中每個尺寸的兩側(cè)。可以是單個數(shù)字或元組(padW,)。默認(rèn)值：0
output_padding –在輸出形狀的每個尺寸的一側(cè)添加了附加尺寸。可以是單個數(shù)字或元組(out_padW)。默認(rèn)值：0
groups – split input into groups, should be divisible by the number of groups. Default: 1
膨脹 –內(nèi)核元素之間的間距。可以是單個數(shù)字或元組(dW,)。默認(rèn)值：1

Examples:

>>> inputs = torch.randn(20, 16, 50)
>>> weights = torch.randn(16, 33, 5)
>>> F.conv_transpose1d(inputs, weights)

conv_transpose2d

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

在由多個輸入平面組成的輸入圖像上應(yīng)用二維轉(zhuǎn)置卷積運(yùn)算符，有時也稱為“反卷積”。

Note

Parameters

input – input tensor of shape
重量 –形狀為的過濾器
bias – optional bias of shape . Default: None
步幅 –旋轉(zhuǎn)內(nèi)核的步幅。可以是單個數(shù)字或元組(sH, sW)。默認(rèn)值：1
填充 – dilation * (kernel_size - 1) - padding零填充將添加到輸入中每個尺寸的兩側(cè)。可以是單個數(shù)字或元組(padH, padW)。默認(rèn)值：0
output_padding –在輸出形狀的每個尺寸的一側(cè)添加了附加尺寸。可以是單個數(shù)字或元組(out_padH, out_padW)。默認(rèn)值：0
groups – split input into groups, should be divisible by the number of groups. Default: 1
膨脹 –內(nèi)核元素之間的間距。可以是單個數(shù)字或元組(dH, dW)。默認(rèn)值：1

Examples:

>>> # With square kernels and equal stride
>>> inputs = torch.randn(1, 4, 5, 5)
>>> weights = torch.randn(4, 8, 3, 3)
>>> F.conv_transpose2d(inputs, weights, padding=1)

conv_transpose3d

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

在由多個輸入平面組成的輸入圖像上應(yīng)用 3D 轉(zhuǎn)置卷積運(yùn)算符，有時也稱為“反卷積”

Note

Parameters

input – input tensor of shape
重量 –形狀為的過濾器
bias – optional bias of shape . Default: None
步幅 –旋轉(zhuǎn)內(nèi)核的步幅。可以是單個數(shù)字或元組(sT, sH, sW)。默認(rèn)值：1
填充 – dilation * (kernel_size - 1) - padding零填充將添加到輸入中每個尺寸的兩側(cè)。可以是單個數(shù)字或元組(padT, padH, padW)。默認(rèn)值：0
output_padding –在輸出形狀的每個尺寸的一側(cè)添加了附加尺寸。可以是單個數(shù)字或元組(out_padT, out_padH, out_padW)。默認(rèn)值：0
groups – split input into groups, should be divisible by the number of groups. Default: 1
dilation – the spacing between kernel elements. Can be a single number or a tuple <cite>(dT, dH, dW)</cite>. Default: 1

Examples:

>>> inputs = torch.randn(20, 16, 50, 10, 20)
>>> weights = torch.randn(16, 33, 3, 3, 3)
>>> F.conv_transpose3d(inputs, weights)

展開

torch.nn.functional.unfold(input, kernel_size, dilation=1, padding=0, stride=1)?

從批處理輸入張量中提取滑動局部塊。

警告

當(dāng)前，僅支持 4D 輸入張量(像圖像一樣的批狀張量）。

Warning

展開張量中的一個以上元素可以引用單個存儲位置。結(jié)果，就地操作(尤其是矢量化的操作）可能會導(dǎo)致錯誤的行為。如果您需要寫張量，請先克隆它。

折

torch.nn.functional.fold(input, output_size, kernel_size, dilation=1, padding=0, stride=1)?

將一系列滑動局部塊組合成一個大型的張量。

Warning

當(dāng)前，僅支持 4D 輸出張量(像圖像一樣的批狀張量）。

池化功能

avg_pool1d

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

在由多個輸入平面組成的輸入信號上應(yīng)用一維平均池。

Parameters

input – input tensor of shape
kernel_size –窗口的大小。可以是單個數(shù)字或元組<cite>(kW，）</cite>
步幅 –窗口的步幅。可以是單個數(shù)字或元組<cite>(sW，）</cite>。默認(rèn)值：kernel_size
填充 –輸入兩側(cè)的隱式零填充。可以是單個數(shù)字或元組<cite>(padW，）</cite>。默認(rèn)值：0
ceil_mode –為 True 時，將使用 <cite>ceil</cite> 代替 <cite>floor</cite> 計(jì)算輸出形狀。默認(rèn)值：False
count_include_pad –為 True 時，將在平均計(jì)算中包括零填充。默認(rèn)值：True

Examples:

>>> # pool of square window of size=3, stride=2
>>> input = torch.tensor([[[1, 2, 3, 4, 5, 6, 7]]], dtype=torch.float32)
>>> F.avg_pool1d(input, kernel_size=3, stride=2)
tensor([[[ 2.,  4.,  6.]]])

avg_pool2d

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

以步長步長在區(qū)域中應(yīng)用 2D 平均合并操作。輸出要素的數(shù)量等于輸入平面的數(shù)量。

Parameters

輸入 –輸入張量
kernel_size –池區(qū)域的大小。可以是單個數(shù)字或元組<cite>(kH，kW）</cite>
跨度 –合并操作的跨度。可以是單個數(shù)字或元組<cite>(sH，sW）</cite>。默認(rèn)值：kernel_size
填充 –輸入兩側(cè)的隱式零填充。可以是單個數(shù)字或元組<cite>(padH，padW）</cite>。默認(rèn)值：0
ceil_mode –為 True 時，將在公式中使用 <cite>ceil</cite> 而不是 <cite>floor</cite> 計(jì)算輸出形狀。默認(rèn)值：False
count_include_pad – when True, will include the zero-padding in the averaging calculation. Default: True
divisor_override –如果指定，它將用作除數(shù)，否則將使用池化區(qū)域的大小。默認(rèn)值：無

avg_pool3d

torch.nn.functional.avg_pool3d(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None) → Tensor?

以步長步長在區(qū)域中應(yīng)用 3D 平均合并操作。輸出特征的數(shù)量等于。

Parameters

輸入 –輸入張量
kernel_size –池區(qū)域的大小。可以是單個數(shù)字或元組<cite>(kT，kH，kW）</cite>
跨度 –合并操作的跨度。可以是單個數(shù)字或元組<cite>(sT，sH，sW）</cite>。默認(rèn)值：kernel_size
填充 –輸入兩側(cè)的隱式零填充。可以是單個數(shù)字或元組<cite>(padT，padH，padW）</cite>，默認(rèn)值：0
ceil_mode –為 True 時，將在公式中使用 <cite>ceil</cite> 代替 <cite>floor</cite> 來計(jì)算輸出形狀
count_include_pad –為 True 時，將在平均計(jì)算中包括零填充
divisor_override – if specified, it will be used as divisor, otherwise size of the pooling region will be used. Default: None

max_pool1d

torch.nn.functional.max_pool1d(*args, **kwargs)?

在由多個輸入平面組成的輸入信號上應(yīng)用一維最大池化。

max_pool2d

torch.nn.functional.max_pool2d(*args, **kwargs)?

在由多個輸入平面組成的輸入信號上應(yīng)用 2D 最大合并。

max_pool3d

torch.nn.functional.max_pool3d(*args, **kwargs)?

在由多個輸入平面組成的輸入信號上應(yīng)用 3D 最大池化。

max_unpool1d

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

計(jì)算MaxPool1d的部分逆。

max_unpool2d

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

計(jì)算MaxPool2d的部分逆。

max_unpool3d

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

計(jì)算MaxPool3d的部分逆。

lp_pool1d

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

在由多個輸入平面組成的輸入信號上應(yīng)用一維功率平均池。如果 <cite>p</cite> 的所有輸入的總和為零，則梯度也設(shè)置為零。

lp_pool2d

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

在由多個輸入平面組成的輸入信號上應(yīng)用 2D 功率平均池。如果 <cite>p</cite> 的所有輸入的總和為零，則梯度也設(shè)置為零。

adaptive_max_pool1d

torch.nn.functional.adaptive_max_pool1d(*args, **kwargs)?

在由多個輸入平面組成的輸入信號上應(yīng)用一維自適應(yīng)最大池化。

Parameters

output_size –目標(biāo)輸出大小(單個整數(shù)）
return_indices –是否返回池索引。默認(rèn)值：False

adaptive_max_pool2d

torch.nn.functional.adaptive_max_pool2d(*args, **kwargs)?

在由多個輸入平面組成的輸入信號上應(yīng)用 2D 自適應(yīng)最大池化。

Parameters

output_size –目標(biāo)輸出大小(單整數(shù)或雙整數(shù)元組）
return_indices – whether to return pooling indices. Default: False

adaptive_max_pool3d

torch.nn.functional.adaptive_max_pool3d(*args, **kwargs)?

在由多個輸入平面組成的輸入信號上應(yīng)用 3D 自適應(yīng)最大池化。

Parameters

output_size –目標(biāo)輸出大小(單整數(shù)或三整數(shù)元組）
return_indices – whether to return pooling indices. Default: False

adaptive_avg_pool1d

torch.nn.functional.adaptive_avg_pool1d(input, output_size) → Tensor?

在由多個輸入平面組成的輸入信號上應(yīng)用一維自適應(yīng)平均池。

Parameters

output_size – the target output size (single integer)

adaptive_avg_pool2d

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

在由多個輸入平面組成的輸入信號上應(yīng)用 2D 自適應(yīng)平均池。

Parameters

output_size – the target output size (single integer or double-integer tuple)

adaptive_avg_pool3d

torch.nn.functional.adaptive_avg_pool3d(input, output_size)?

在由多個輸入平面組成的輸入信號上應(yīng)用 3D 自適應(yīng)平均池。

Parameters

output_size – the target output size (single integer or triple-integer tuple)

非線性激活功能

閾

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

設(shè)置輸入張量的每個元素的閾值。

torch.nn.functional.threshold_(input, threshold, value) → Tensor?

threshold() 的就地版本。

露露

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

torch.nn.functional.relu_(input) → Tensor?

relu() 的就地版本。

Hardtanh

torch.nn.functional.hardtanh(input, min_val=-1., max_val=1., inplace=False) → Tensor?

torch.nn.functional.hardtanh_(input, min_val=-1., max_val=1.) → Tensor?

hardtanh() 的就地版本。

relu6

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

應(yīng)用逐元素函數(shù)。

lu

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

按元素應(yīng)用。

torch.nn.functional.elu_(input, alpha=1.) → Tensor?

elu() 的就地版本。

塞盧

torch.nn.functional.selu(input, inplace=False) → Tensor?

將與和逐元素應(yīng)用。

塞盧

torch.nn.functional.celu(input, alpha=1., inplace=False) → Tensor?

按元素應(yīng)用。

leaky_relu

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

按元素應(yīng)用

torch.nn.functional.leaky_relu_(input, negative_slope=0.01) → Tensor?

leaky_relu() 的就地版本。

前路

torch.nn.functional.prelu(input, weight) → Tensor?

逐個應(yīng)用功能，其中權(quán)重是可學(xué)習(xí)的參數(shù)。

雷雷魯

torch.nn.functional.rrelu(input, lower=1./8, upper=1./3, training=False, inplace=False) → Tensor?

隨機(jī)泄漏的 ReLU。

torch.nn.functional.rrelu_(input, lower=1./8, upper=1./3, training=False) → Tensor?

rrelu() 的就地版本。

谷氨酸

torch.nn.functional.glu(input, dim=-1) → Tensor?

門控線性單元。計(jì)算：

其中<cite>輸入</cite>沿<cite>暗淡</cite>分成兩半，形成 <cite>a</cite> 和 <cite>b</cite> ，是 S 型函數(shù)，是矩陣之間的按元素乘積。

請參閱帶門控卷積網(wǎng)絡(luò)的語言建模。

Parameters

輸入 (tensor)–輸入張量
暗淡的 (python：int )–分割輸入的維度。默認(rèn)值：-1

格魯

torch.nn.functional.gelu(input) → Tensor?

逐元素應(yīng)用功能

其中是高斯分布的累積分布函數(shù)。

請參見高斯誤差線性單位(GELU）。

對數(shù)乙狀結(jié)腸

torch.nn.functional.logsigmoid(input) → Tensor?

按元素應(yīng)用

有關(guān)更多詳細(xì)信息，請參見 LogSigmoid 。

硬縮

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

逐個應(yīng)用硬收縮功能

有關(guān)更多詳細(xì)信息，請參見 Hardshrink 。

tanhshrink

torch.nn.functional.tanhshrink(input) → Tensor?

按元素應(yīng)用

有關(guān)更多詳細(xì)信息，請參見 Tanhshrink 。

軟簽

torch.nn.functional.softsign(input) → Tensor?

按元素應(yīng)用功能

有關(guān)更多詳細(xì)信息，請參見 Softsign 。

軟加

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

軟敏

torch.nn.functional.softmin(input, dim=None, _stacklevel=3, dtype=None)?

應(yīng)用 softmin 函數(shù)。

注意。有關(guān)數(shù)學(xué)公式，請參見 softmax 定義。

有關(guān)更多詳細(xì)信息，請參見 Softmin 。

Parameters

輸入 (tensor)–輸入
dim (python：int )–將計(jì)算 softmin 的維度(因此，沿著 dim 的每個切片的總和為 1）。
dtype (torch.dtype，可選）–返回張量的所需數(shù)據(jù)類型。如果指定，則在執(zhí)行操作之前將輸入張量轉(zhuǎn)換為dtype。這對于防止數(shù)據(jù)類型溢出很有用。默認(rèn)值：無。

軟最大

torch.nn.functional.softmax(input, dim=None, _stacklevel=3, dtype=None)?

應(yīng)用 softmax 函數(shù)。

Softmax 定義為：

它將沿著暗淡應(yīng)用于所有切片，并將對其進(jìn)行重新縮放，以使元素位于 <cite>[0，1]</cite> 范圍內(nèi)，總和為 1。

有關(guān)更多詳細(xì)信息，請參見 Softmax 。

Parameters

input (Tensor) – input
暗淡的 (python：int )–將沿著其計(jì)算 softmax 的尺寸。
dtype (torch.dtype, optional) – the desired data type of returned tensor. If specified, the input tensor is casted to dtype before the operation is performed. This is useful for preventing data type overflows. Default: None.

Note

此函數(shù)不能直接與 NLLLoss 一起使用，后者希望 Log 是在 Softmax 及其自身之間計(jì)算的。請改用 log_softmax(速度更快，并且具有更好的數(shù)值屬性）。

軟縮

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

逐個應(yīng)用軟收縮功能

有關(guān)更多詳細(xì)信息，請參見 Softshrink 。

gumbel_softmax

torch.nn.functional.gumbel_softmax(logits, tau=1, hard=False, eps=1e-10, dim=-1)?

來自 Gumbel-Softmax 分布的樣本，并且可以離散化。

Parameters

logits – <cite>[…，num_features]</cite> 未標(biāo)準(zhǔn)化的日志概率
tau –非負(fù)標(biāo)量溫度
硬性 –如果True，返回的樣本將被離散為一熱向量，但將被區(qū)分為好像是 autograd 中的軟樣本
暗淡的 (python：int )–將沿著其計(jì)算 softmax 的尺寸。默認(rèn)值：-1。

退貨

Gumbel-Softmax 分布中與<cite>形狀相同的采樣張量對數(shù)為</cite>。如果hard=True，則返回的樣本將是一個熱點(diǎn)，否則它們將是在 <cite>dim</cite> 上總計(jì)為 1 的概率分布。

Note

此函數(shù)是出于遺留原因而存在，將來可能會從 nn.Functional 中刪除。

Note

<cite>硬性</cite>的主要技巧是執(zhí)行 <cite>y_hard-y_soft.detach(）+ y_soft</cite>

它實(shí)現(xiàn)了兩件事：-使輸出值恰好為一熱(因?yàn)槲覀兿燃尤缓鬁p去 y_soft 值）-使梯度等于 y_soft 梯度(因?yàn)槲覀儎冸x所有其他梯度）

Examples::
>>> logits = torch.randn(20, 32)
>>> # Sample soft categorical using reparametrization trick:
>>> F.gumbel_softmax(logits, tau=1, hard=False)
>>> # Sample hard categorical using "Straight-through" trick:
>>> F.gumbel_softmax(logits, tau=1, hard=True)

log_softmax

torch.nn.functional.log_softmax(input, dim=None, _stacklevel=3, dtype=None)?

應(yīng)用 softmax，后跟對數(shù)。

雖然在數(shù)學(xué)上等效于 log(softmax(x）），但是分別執(zhí)行這兩個操作比較慢，并且在數(shù)值上不穩(wěn)定。此函數(shù)使用替代公式來正確計(jì)算輸出和漸變。

有關(guān)更多詳細(xì)信息，請參見 LogSoftmax 。

Parameters

input (Tensor) – input
暗淡的 (python：int )–將沿 log_softmax 計(jì)算的維。
dtype (torch.dtype, optional) – the desired data type of returned tensor. If specified, the input tensor is casted to dtype before the operation is performed. This is useful for preventing data type overflows. Default: None.

譚

torch.nn.functional.tanh(input) → Tensor?

按元素應(yīng)用

乙狀結(jié)腸

torch.nn.functional.sigmoid(input) → Tensor?

應(yīng)用逐元素函數(shù)

歸一化功能

batch_norm

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

對一批數(shù)據(jù)中的每個通道應(yīng)用批標(biāo)準(zhǔn)化。

instance_norm

torch.nn.functional.instance_norm(input, running_mean=None, running_var=None, weight=None, bias=None, use_input_stats=True, momentum=0.1, eps=1e-05)?

批量對每個數(shù)據(jù)樣本中的每個通道應(yīng)用實(shí)例歸一化。

layer_norm

torch.nn.functional.layer_norm(input, normalized_shape, weight=None, bias=None, eps=1e-05)?

將圖層歸一化應(yīng)用于最后一定數(shù)量的尺寸。

local_response_norm

torch.nn.functional.local_response_norm(input, size, alpha=0.0001, beta=0.75, k=1.0)?

在由多個輸入平面組成的輸入信號上應(yīng)用本地響應(yīng)歸一化，其中通道占據(jù)第二維。跨通道應(yīng)用標(biāo)準(zhǔn)化。

歸一化

torch.nn.functional.normalize(input, p=2, dim=1, eps=1e-12, out=None)?

對指定尺寸的輸入執(zhí)行歸一化。

對于大小為的張量input，沿維度dim的每個-元素矢量都將轉(zhuǎn)換為

使用默認(rèn)參數(shù)時，它將沿向量的矢量使用歐幾里得范數(shù)進(jìn)行歸一化。

Parameters

輸入 –任何形狀的輸入張量
p (python：float )–規(guī)范制定中的指數(shù)值。默認(rèn)值：2
暗淡的 (python：int )–縮小的尺寸。默認(rèn)值：1
eps (python：float )–避免被零除的較小值。默認(rèn)值：1e-12
輸出 (tensor ， 可選）–輸出張量。如果使用out，則此操作將不可區(qū)分。

線性功能

線性的

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

對輸入數(shù)據(jù)應(yīng)用線性變換：。

形狀：

輸入：其中 <cite&*</cite& 表示任意數(shù)量的附加尺寸

- 重量：

- 偏差：

- 輸出：

雙線性

torch.nn.functional.bilinear(input1, input2, weight, bias=None)?

對輸入數(shù)據(jù)應(yīng)用雙線性變換：

Shape:

輸入 1：，其中和表示任意數(shù)量的附加尺寸。除了最后輸入的維度外，其他所有維度均應(yīng)相同。

- 輸入 2：，其中

- 重量：

- 偏倚：

- 輸出：，其中和除最后一個尺寸外的所有尺寸都與輸入相同。

輟學(xué)功能

退出

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

在訓(xùn)練期間，使用伯努利分布的樣本以概率p將輸入張量的某些元素隨機(jī)歸零。

有關(guān)詳細(xì)信息，請參見 Dropout 。

Parameters

p –元素歸零的概率。默認(rèn)值：0.5
訓(xùn)練 –如果為True，則申請輟學(xué)。默認(rèn)值：True
就地 –如果設(shè)置為True，將就地執(zhí)行此操作。默認(rèn)值：False

alpha_dropout

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

將 Alpha 濾除應(yīng)用于輸入。

dropout2d

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

將所有通道隨機(jī)調(diào)零(通道是 2D 特征圖，例如，批處理輸入中第個樣本的第個通道是 2D 張量）。使用伯努利分布中的樣本，每個信道將在每次前向呼叫中以概率p獨(dú)立清零。

Parameters

p –信道歸零的概率。默認(rèn)值：0.5
training – apply dropout if is True. Default: True
inplace – If set to True, will do this operation in-place. Default: False

dropout3d

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

將所有通道隨機(jī)調(diào)零(通道是 3D 特征圖，例如，批處理輸入中第個樣本的第個通道是 3D 張量）。使用伯努利分布中的樣本，每個信道將在每次前向呼叫中以概率p獨(dú)立清零。

Parameters

p – probability of a channel to be zeroed. Default: 0.5
training – apply dropout if is True. Default: True
inplace – If set to True, will do this operation in-place. Default: False

稀疏功能

嵌入

torch.nn.functional.embedding(input, weight, padding_idx=None, max_norm=None, norm_type=2.0, scale_grad_by_freq=False, sparse=False)?

一個簡單的查找表，用于以固定的字典和大小查找嵌入。

該模塊通常用于使用索引檢索單詞嵌入。模塊的輸入是索引列表和嵌入矩陣，而輸出是相應(yīng)的詞嵌入。

Parameters

輸入 (LongTensor )–包含嵌入矩陣的索引的張量
權(quán)重 (tensor)–行數(shù)等于最大可能索引+ 1，并且行數(shù)等于嵌入大小的嵌入矩陣
padding_idx (python：int ， 可選）–如果給定，則在padding_idx處嵌入輸出以填充輸出(初始化為零）。
max_norm (python：float ， 可選）–如果給定，則范數(shù)大于max_norm的每個嵌入向量都將重新規(guī)范化為具有規(guī)范max_norm。注意：這將就地修改weight。
norm_type (python：float ，可選）–為max_norm選項(xiàng)計(jì)算的 p 范數(shù)的 p。默認(rèn)值2。
scale_grad_by_freq (布爾值 ，可選））–如果給定，則將按照最小批量。默認(rèn)值False。
稀疏 (bool ， 可選）–如果True，則梯度 w.r.t. weight將是一個稀疏張量。有關(guān)稀疏梯度的更多詳細(xì)信息，請參見 torch.nn.Embedding 下的注釋。

Shape:

輸入：包含要提取的索引的任意形狀的 LongTensor

Weight: Embedding matrix of floating point type with shape (V, embedding_dim),

其中 V =最大索引+ 1，embedding_dim =嵌入大小

輸出：<cite>(，embedding_dim）</cite>，其中 <cite></cite> 是輸入形狀

Examples:

>>> # a batch of 2 samples of 4 indices each
>>> input = torch.tensor([[1,2,4,5],[4,3,2,9]])
>>> # an embedding matrix containing 10 tensors of size 3
>>> embedding_matrix = torch.rand(10, 3)
>>> F.embedding(input, embedding_matrix)
tensor([[[ 0.8490,  0.9625,  0.6753],
         [ 0.9666,  0.7761,  0.6108],
         [ 0.6246,  0.9751,  0.3618],
         [ 0.4161,  0.2419,  0.7383]],


        [[ 0.6246,  0.9751,  0.3618],
         [ 0.0237,  0.7794,  0.0528],
         [ 0.9666,  0.7761,  0.6108],
         [ 0.3385,  0.8612,  0.1867]]])


>>> # example with padding_idx
>>> weights = torch.rand(10, 3)
>>> weights[0, :].zero_()
>>> embedding_matrix = weights
>>> input = torch.tensor([[0,2,0,5]])
>>> F.embedding(input, embedding_matrix, padding_idx=0)
tensor([[[ 0.0000,  0.0000,  0.0000],
         [ 0.5609,  0.5384,  0.8720],
         [ 0.0000,  0.0000,  0.0000],
         [ 0.6262,  0.2438,  0.7471]]])

embedding_bag

torch.nn.functional.embedding_bag(input, weight, offsets=None, max_norm=None, norm_type=2, scale_grad_by_freq=False, mode='mean', sparse=False, per_sample_weights=None)?

在不實(shí)例化中間嵌入的情況下，計(jì)算嵌入的<cite>袋</cite>的總和，平均值或最大值。

Note

當(dāng)使用 CUDA 后端時，此操作可能會在其向后傳遞中引起不確定的行為，這種行為很難關(guān)閉。有關(guān)背景，請參見重現(xiàn)性的注釋。

Parameters

輸入 (LongTensor )–將包含索引袋的張量放入嵌入矩陣
weight (Tensor) – The embedding matrix with number of rows equal to the maximum possible index + 1, and number of columns equal to the embedding size
偏移量 (LongTensor ，可選）–僅在input為 1D 時使用。 offsets確定input中每個袋子(序列）的起始索引位置。
max_norm (python:float__, optional) – If given, each embedding vector with norm larger than max_norm is renormalized to have norm max_norm. Note: this will modify weight in-place.
norm_type (python：float ， 可選）– p -norm 中的p用于計(jì)算max_norm ] 選項(xiàng)。默認(rèn)2。
scale_grad_by_freq (布爾 ， 可選）–如果指定，則將按比例縮小坡度中單詞的頻率批量。默認(rèn)值False。注意：mode="max"時不支持此選項(xiàng)。
模式(字符串 ， 可選）– "sum"，"mean"或"max"。指定減少袋子的方式。默認(rèn)值："mean"
稀疏 (bool ， 可選）–如果True，則梯度為 w.r.t.。 weight將是一個稀疏張量。注意：mode="max"時不支持此選項(xiàng)。
per_sample_weights (tensor ， 可選）–浮點(diǎn)/雙權(quán)重的張量，或無表示所有值權(quán)重應(yīng)取為 1。如果指定，則per_sample_weights的形狀必須與輸入的形狀完全相同，并且如果不是[None]，則將其視為具有相同的offsets。

Shape:

input(LongTensor）和offsets(LongTensor，可選）

* 如果`input`是形狀為<cite&(B，N）</cite&的二維，它將被視為`B`袋(序列），每個袋子的長度都是固定長度`N`，這將返回`B`值的匯總值取決于`mode`。在這種情況下，`offsets`被忽略，必須為`None`。 * 如果`input`是形狀為<cite&(N）</cite&的 1D，它將被視為多個包(序列）的串聯(lián)。 `offsets`必須是一維張量，其中包含`input`中每個包的起始索引位置。因此，對于形狀為<cite&(B）</cite&的`offsets`，`input`將被視為具有`B`袋。空袋子(即長度為 0 的袋子）將返回由零填充的向量。

- weight(張量）：形狀為<cite&的模塊的可學(xué)習(xí)權(quán)重(num_embeddings，embedding_dim）</cite&

- per_sample_weights(張量，可選）。具有與input相同的形狀。

- output：形狀為<cite&的匯總嵌入值(B，embedding_dim）</cite&

Examples:

>>> # an Embedding module containing 10 tensors of size 3
>>> embedding_matrix = torch.rand(10, 3)
>>> # a batch of 2 samples of 4 indices each
>>> input = torch.tensor([1,2,4,5,4,3,2,9])
>>> offsets = torch.tensor([0,4])
>>> F.embedding_bag(embedding_matrix, input, offsets)
tensor([[ 0.3397,  0.3552,  0.5545],
        [ 0.5893,  0.4386,  0.5882]])

one_hot

torch.nn.functional.one_hot(tensor, num_classes=-1) → LongTensor?

接受具有形狀為(*)的索引值的 LongTensor，并返回形狀為(*, num_classes)的張量，該張量在所有地方都為零，除非最后一個維度的索引與輸入張量的對應(yīng)值匹配，在這種情況下它將為 1。

另請參閱維基百科上的熱門。

Parameters

張量 (LongTensor )–任何形狀的類值。
num_classes (python：int )–類的總數(shù)。如果設(shè)置為-1，則將類數(shù)推斷為比輸入張量中的最大類值大一。

Returns

LongTensor 具有一個維度，在輸入指示的最后維度的索引處具有 1 個值，在其他地方均為 0。

例子

>>> F.one_hot(torch.arange(0, 5) % 3)
tensor([[1, 0, 0],
        [0, 1, 0],
        [0, 0, 1],
        [1, 0, 0],
        [0, 1, 0]])
>>> F.one_hot(torch.arange(0, 5) % 3, num_classes=5)
tensor([[1, 0, 0, 0, 0],
        [0, 1, 0, 0, 0],
        [0, 0, 1, 0, 0],
        [1, 0, 0, 0, 0],
        [0, 1, 0, 0, 0]])
>>> F.one_hot(torch.arange(0, 6).view(3,2) % 3)
tensor([[[1, 0, 0],
         [0, 1, 0]],
        [[0, 0, 1],
         [1, 0, 0]],
        [[0, 1, 0],
         [0, 0, 1]]])

距離功能

pairwise_distance

torch.nn.functional.pairwise_distance(x1, x2, p=2.0, eps=1e-06, keepdim=False)?

余弦相似度

torch.nn.functional.cosine_similarity(x1, x2, dim=1, eps=1e-8) → Tensor?

返回沿 dim 計(jì)算的 x1 和 x2 之間的余弦相似度。

Parameters

x1 (tensor)–第一個輸入。
x2 (tensor)–第二個輸入(大小匹配 x1）。
昏暗的 (python：int ，可選）–向量的尺寸。默認(rèn)值：1
eps (python：float ，可選）–避免被零除的小值。默認(rèn)值：1e-8

Shape:

輸入：其中 D 在位置<cite>變暗</cite>處。
輸出：其中 1 處于位置<cite>暗淡</cite>。

例：

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

pdist

torch.nn.functional.pdist(input, p=2) → Tensor?

計(jì)算輸入中每對行向量之間的 p 范數(shù)距離。這與 <cite>torch.norm(input [:, None]-input，dim = 2，p = p）</cite>的對角線之外的上三角部分相同。如果行是連續(xù)的，此功能將更快。

如果輸入的形狀為，則輸出的形狀為。

如果，則此函數(shù)等效于 <cite>scipy.spatial.distance.pdist(input，'minkowski'，p = p）</cite>。當(dāng)等于 <cite>scipy.spatial.distance.pdist(input，'hamming'）* M</cite> 。當(dāng)時，最接近的 scipy 函數(shù)是 <cite>scipy.spatial.distance.pdist(xn，lambda x，y：np.abs(x-y）.max(））</cite>。

Parameters

輸入-形狀為的輸入張量。
p -p 范數(shù)距離的 p 值，以計(jì)算每個向量對之間的距離。

損失函數(shù)

binary_cross_entropy

torch.nn.functional.binary_cross_entropy(input, target, weight=None, size_average=None, reduce=None, reduction='mean')?

測量目標(biāo)和輸出之間的二進(jìn)制交叉熵的函數(shù)。

Parameters

輸入 –任意形狀的張量
目標(biāo) –與輸入形狀相同的張量
重量 (tensor ， 可選）–手動調(diào)整重量(如果重復(fù)以匹配輸入張量形狀）
size_average (布爾，可選）–已棄用(請參見reduction）。默認(rèn)情況下，損失是批次中每個損失元素的平均數(shù)。請注意，對于某些損失，每個樣本有多個元素。如果將字段size_average設(shè)置為False，則每個小批量的損失總和。當(dāng) reduce 為False時將被忽略。默認(rèn)值：True
還原(布爾 ， 可選）–已棄用(請參閱reduction）。默認(rèn)情況下，取決于size_average，對每個小批量的觀測值求平均或求和。當(dāng)reduce為False時，返回每批元素?fù)p失，并忽略size_average。默認(rèn)值：True
縮減(字符串 ，可選）–指定要應(yīng)用于輸出的縮減：'none' | 'mean' | 'sum'。 'none'：不應(yīng)用任何減少量； 'mean'：輸出的總和除以輸出中元素的數(shù)量； 'sum'：將對輸出求和。注意：size_average和reduce正在淘汰中，與此同時，指定這兩個 args 中的任何一個將覆蓋reduction。默認(rèn)值：'mean'

Examples:

>>> input = torch.randn((3, 2), requires_grad=True)
>>> target = torch.rand((3, 2), requires_grad=False)
>>> loss = F.binary_cross_entropy(F.sigmoid(input), target)
>>> loss.backward()

binary_cross_entropy_with_logits

torch.nn.functional.binary_cross_entropy_with_logits(input, target, weight=None, size_average=None, reduce=None, reduction='mean', pos_weight=None)?

測量目標(biāo)和輸出對數(shù)之間的二進(jìn)制交叉熵的函數(shù)。

有關(guān)詳細(xì)信息，請參見 BCEWithLogitsLoss 。

Parameters

input – Tensor of arbitrary shape
target – Tensor of the same shape as input
weight (*Tensor*, optional) – a manual rescaling weight if provided it's repeated to match input tensor shape
size_average (bool__, optional) – Deprecated (see reduction). By default, the losses are averaged over each loss element in the batch. Note that for some losses, there multiple elements per sample. If the field size_average is set to False, the losses are instead summed for each minibatch. Ignored when reduce is False. Default: True
reduce (bool__, optional) – Deprecated (see reduction). By default, the losses are averaged or summed over observations for each minibatch depending on size_average. When reduce is False, returns a loss per batch element instead and ignores size_average. Default: True
reduction (string__, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Note: size_average and reduce are in the process of being deprecated, and in the meantime, specifying either of those two args will override reduction. Default: 'mean'
pos_weight (tensor ， 可選）–正例的權(quán)重。必須是長度等于類數(shù)的向量。

Examples:

>>> input = torch.randn(3, requires_grad=True)
>>> target = torch.empty(3).random_(2)
>>> loss = F.binary_cross_entropy_with_logits(input, target)
>>> loss.backward()

poisson_nll_loss

torch.nn.functional.poisson_nll_loss(input, target, log_input=True, full=False, size_average=None, eps=1e-08, reduce=None, reduction='mean')?

泊松負(fù)對數(shù)似然損失。

Parameters

輸入 –基本泊松分布的期望。
目標(biāo)-隨機(jī)樣本。
log_input –如果將True的損失計(jì)算為，如果將False的損失計(jì)算為。默認(rèn)值：True
full –是否計(jì)算全部損耗，即。 e。添加斯特林近似項(xiàng)。默認(rèn)值：False 。
size_average (bool__, optional) – Deprecated (see reduction). By default, the losses are averaged over each loss element in the batch. Note that for some losses, there multiple elements per sample. If the field size_average is set to False, the losses are instead summed for each minibatch. Ignored when reduce is False. Default: True
eps (python：float ， 可選）–較小的值，以避免在log_input=False時評估。默認(rèn)值：1e-8
reduce (bool__, optional) – Deprecated (see reduction). By default, the losses are averaged or summed over observations for each minibatch depending on size_average. When reduce is False, returns a loss per batch element instead and ignores size_average. Default: True
reduction (string__, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Note: size_average and reduce are in the process of being deprecated, and in the meantime, specifying either of those two args will override reduction. Default: 'mean'

cosine_embedding_loss

torch.nn.functional.cosine_embedding_loss(input1, input2, target, margin=0, size_average=None, reduce=None, reduction='mean') → Tensor?

交叉熵

torch.nn.functional.cross_entropy(input, target, weight=None, size_average=None, ignore_index=-100, reduce=None, reduction='mean')?

該標(biāo)準(zhǔn)將 <cite>log_softmax</cite> 和 <cite>nll_loss</cite> 合并在一個函數(shù)中。

Parameters

輸入 (tensor)– 其中 <cite>C =類別損失</cite>或，如果出現(xiàn) 2D 損失，或[ 在 K 維丟失的情況下。
目標(biāo) (tensor)– ，其中每個值是，或，其中對于 K 維損耗。
重量 (tensor ， 可選）–為每個類別提供手動縮放比例的重量。如果給定，則其張量必須為 <cite>C</cite>
size_average (bool__, optional) – Deprecated (see reduction). By default, the losses are averaged over each loss element in the batch. Note that for some losses, there multiple elements per sample. If the field size_average is set to False, the losses are instead summed for each minibatch. Ignored when reduce is False. Default: True
ignore_index (python：int ，可選）–指定目標(biāo)值，該目標(biāo)值將被忽略并且不會對輸入梯度產(chǎn)生影響。當(dāng)size_average為True時，損耗是在不可忽略的目標(biāo)上平均的。默認(rèn)值：-100
reduce (bool__, optional) – Deprecated (see reduction). By default, the losses are averaged or summed over observations for each minibatch depending on size_average. When reduce is False, returns a loss per batch element instead and ignores size_average. Default: True
reduction (string__, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Note: size_average and reduce are in the process of being deprecated, and in the meantime, specifying either of those two args will override reduction. Default: 'mean'

Examples:

>>> input = torch.randn(3, 5, requires_grad=True)
>>> target = torch.randint(5, (3,), dtype=torch.int64)
>>> loss = F.cross_entropy(input, target)
>>> loss.backward()

ctc_loss

torch.nn.functional.ctc_loss(log_probs, targets, input_lengths, target_lengths, blank=0, reduction='mean', zero_infinity=False)?

連接主義者的時間分類損失。

Note

When using the CUDA backend, this operation may induce nondeterministic behaviour in its backward pass that is not easily switched off. Please see the notes on Reproducibility for background.

Parameters

log_probs – ，其中 <cite>C =字母字符數(shù)，包括空白</cite>， <cite>T =輸入長度</cite>，和 <cite>N =批處理大小</cite> 。輸出的對數(shù)概率(例如，使用 torch.nn.functional.log_softmax() 獲得的概率）。
目標(biāo)為 – 或<cite>(sum(target_lengths））</cite>。目標(biāo)不能為空。在第二種形式中，假定目標(biāo)是串聯(lián)的。
input_lengths – 。輸入的長度(每個必須為）
target_lengths – 。目標(biāo)長度
空白 (python：int ， 可選）–空白標(biāo)簽。默認(rèn)值。
縮減(字符串 ，可選）–指定要應(yīng)用于輸出的縮減：'none' | 'mean' | 'sum'。 'none'：不應(yīng)用減少量，'mean'：將輸出損失除以目標(biāo)長度，然后取批次的平均值，'sum'：將輸出相加。默認(rèn)值：'mean'
zero_infinity (bool ，可選）–是否將無限大損失和相關(guān)的梯度歸零。默認(rèn)值：False無限損失主要發(fā)生在輸入太短而無法與目標(biāo)對齊時。

Example:

>>> log_probs = torch.randn(50, 16, 20).log_softmax(2).detach().requires_grad_()
>>> targets = torch.randint(1, 20, (16, 30), dtype=torch.long)
>>> input_lengths = torch.full((16,), 50, dtype=torch.long)
>>> target_lengths = torch.randint(10,30,(16,), dtype=torch.long)
>>> loss = F.ctc_loss(log_probs, targets, input_lengths, target_lengths)
>>> loss.backward()

鉸鏈嵌入損耗

torch.nn.functional.hinge_embedding_loss(input, target, margin=1.0, size_average=None, reduce=None, reduction='mean') → Tensor?

kl_div

torch.nn.functional.kl_div(input, target, size_average=None, reduce=None, reduction='mean')?

Kullback-Leibler 散度損失。

Parameters

input – Tensor of arbitrary shape
target – Tensor of the same shape as input
size_average (bool__, optional) – Deprecated (see reduction). By default, the losses are averaged over each loss element in the batch. Note that for some losses, there multiple elements per sample. If the field size_average is set to False, the losses are instead summed for each minibatch. Ignored when reduce is False. Default: True
reduce (bool__, optional) – Deprecated (see reduction). By default, the losses are averaged or summed over observations for each minibatch depending on size_average. When reduce is False, returns a loss per batch element instead and ignores size_average. Default: True
縮減(字符串 ，可選）–指定要應(yīng)用于輸出的縮減：'none' | 'batchmean' | 'sum' | 'mean'。 'none'：不應(yīng)用縮減項(xiàng)'batchmean'：輸出的總和除以批處理大小'sum'：輸出的總和'mean'：輸出除以輸出中的元素?cái)?shù) 默認(rèn)值：'mean'

Note

size_average和reduce正在棄用的過程中，與此同時，指定這兩個 args 中的任何一個將覆蓋reduction。

Note

：attr：reduction = 'mean'不返回真實(shí)的 kl 散度值，請使用：attr：reduction = 'batchmean'，該值與 KL 數(shù)學(xué)定義一致。在下一個主要版本中，'mean'將更改為與“ batchmean”相同的名稱。

l1_ 損失

torch.nn.functional.l1_loss(input, target, size_average=None, reduce=None, reduction='mean') → Tensor?

取平均逐元素絕對值差的函數(shù)。

mse_loss

torch.nn.functional.mse_loss(input, target, size_average=None, reduce=None, reduction='mean') → Tensor?

測量按元素的均方誤差。

margin_ranking_loss

torch.nn.functional.margin_ranking_loss(input1, input2, target, margin=0, size_average=None, reduce=None, reduction='mean') → Tensor?

multilabel_margin_loss

torch.nn.functional.multilabel_margin_loss(input, target, size_average=None, reduce=None, reduction='mean') → Tensor?

multilabel_soft_margin_loss

torch.nn.functional.multilabel_soft_margin_loss(input, target, weight=None, size_average=None) → Tensor?

multi_margin_loss

torch.nn.functional.multi_margin_loss(input, target, p=1, margin=1.0, weight=None, size_average=None, reduce=None, reduction='mean')?
multi_margin_loss(input, target, p=1, margin=1, weight=None, size_average=None,

reduce = None，reduction ='mean'）->張量

nll_loss

torch.nn.functional.nll_loss(input, target, weight=None, size_average=None, ignore_index=-100, reduce=None, reduction='mean')?

負(fù)對數(shù)似然損失。

Parameters

輸入 – ，其中 <cite>C =二維損失時的類數(shù)</cite>或，或，如果發(fā)生 K 維損失則為。
目標(biāo) – ，其中每個值為，或，其中用于 K 維損耗。
weight (*Tensor*, optional) – a manual rescaling weight given to each class. If given, has to be a Tensor of size <cite>C</cite>
size_average (bool__, optional) – Deprecated (see reduction). By default, the losses are averaged over each loss element in the batch. Note that for some losses, there multiple elements per sample. If the field size_average is set to False, the losses are instead summed for each minibatch. Ignored when reduce is False. Default: True
ignore_index (python:int__, optional) – Specifies a target value that is ignored and does not contribute to the input gradient. When size_average is True, the loss is averaged over non-ignored targets. Default: -100
reduce (bool__, optional) – Deprecated (see reduction). By default, the losses are averaged or summed over observations for each minibatch depending on size_average. When reduce is False, returns a loss per batch element instead and ignores size_average. Default: True
reduction (string__, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Note: size_average and reduce are in the process of being deprecated, and in the meantime, specifying either of those two args will override reduction. Default: 'mean'

Example:

>>> # input is of size N x C = 3 x 5
>>> input = torch.randn(3, 5, requires_grad=True)
>>> # each element in target has to have 0 <= value < C
>>> target = torch.tensor([1, 0, 4])
>>> output = F.nll_loss(F.log_softmax(input), target)
>>> output.backward()

smooth_l1_loss

torch.nn.functional.smooth_l1_loss(input, target, size_average=None, reduce=None, reduction='mean')?

如果逐個元素的絕對誤差低于 1，則使用平方項(xiàng)的函數(shù)，否則使用 L1 項(xiàng)。

soft_margin_loss

torch.nn.functional.soft_margin_loss(input, target, size_average=None, reduce=None, reduction='mean') → Tensor?

Triplet_margin_loss

torch.nn.functional.triplet_margin_loss(anchor, positive, negative, margin=1.0, p=2, eps=1e-06, swap=False, size_average=None, reduce=None, reduction='mean')?

視覺功能

pixel_shuffle

torch.nn.functional.pixel_shuffle()?

將形狀為的張量中的元素重新排列為形狀為的張量中的元素。

Parameters

輸入 (tensor)–輸入張量
upscale_factor (python：int )–通過提高空間分辨率的因子

Examples:

>>> input = torch.randn(1, 9, 4, 4)
>>> output = torch.nn.functional.pixel_shuffle(input, 3)
>>> print(output.size())
torch.Size([1, 1, 12, 12])

墊

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

填充張量。

Padding size:

從最后一個尺寸開始，往前介紹填充input某些尺寸的填充尺寸。將填充input的尺寸。例如，要僅填充輸入張量的最后一個維度，則 pad 的形式為；填充輸入張量的最后兩個維度，然后使用；要填充最后 3 個尺寸，請使用。

Padding mode:

恒定填充用于任意尺寸。復(fù)制填充用于填充 5D 輸入張量的最后 3 個維度，4D 輸入張量的最后 2 個維度或 3D 輸入張量的最后一個維度。反射填充僅用于填充 4D 輸入張量的最后 2 個維度或 3D 輸入張量的最后一個維度。

Note

When using the CUDA backend, this operation may induce nondeterministic behaviour in its backward pass that is not easily switched off. Please see the notes on Reproducibility for background.

Parameters

輸入 (tensor)– N 維張量
填充(元組）– m 元素元組，其中輸入尺寸和是偶數(shù)。
模式 – 'constant'，'reflect'，'replicate'或'circular'。默認(rèn)值：'constant'
值 – 'constant'填充的填充值。默認(rèn)值：0

Examples:

>>> t4d = torch.empty(3, 3, 4, 2)
>>> p1d = (1, 1) # pad last dim by 1 on each side
>>> out = F.pad(t4d, p1d, "constant", 0)  # effectively zero padding
>>> print(out.data.size())
torch.Size([3, 3, 4, 4])
>>> p2d = (1, 1, 2, 2) # pad last dim by (1, 1) and 2nd to last by (2, 2)
>>> out = F.pad(t4d, p2d, "constant", 0)
>>> print(out.data.size())
torch.Size([3, 3, 8, 4])
>>> t4d = torch.empty(3, 3, 4, 2)
>>> p3d = (0, 1, 2, 1, 3, 3) # pad by (0, 1), (2, 1), and (3, 3)
>>> out = F.pad(t4d, p3d, "constant", 0)
>>> print(out.data.size())
torch.Size([3, 9, 7, 3])

插

torch.nn.functional.interpolate(input, size=None, scale_factor=None, mode='nearest', align_corners=None)?

向下/向上采樣輸入給定size或給定scale_factor的輸入

用于插值的算法由mode確定。

當(dāng)前支持時間，空間和體積采樣，即，預(yù)期輸入的形狀為 3-D，4-D 或 5-D。

輸入尺寸以以下形式解釋：<cite>微型批處理 x 通道 x [可選深度] x [可選高度] x 寬度</cite>。

可用于調(diào)整大小的模式為：<cite>最接近</cite>，<cite>線性</cite>(僅 3D），<cite>雙線性</cite>，<cite>雙三次</cite>(僅 4D），[ <cite>三線性</cite>(僅限 5D），<cite>區(qū)域</cite>

Parameters

input (Tensor) – the input tensor
大小 (python：int 或元組 [ python：int ]或元組 [ python：int ， python：int ]或元組 [ python：int ， python：int ， python：int ] )–輸出空間大小。
scale_factor (python：float 或元組 [ python：float ] )–空間大小的乘數(shù)。如果是元組，則必須匹配輸入大小。
模式 (str )–用于上采樣的算法：'nearest' | 'linear' | 'bilinear' | 'bicubic' | 'trilinear' | 'area'。默認(rèn)值：'nearest'
align_corners (布爾 ， 可選）–在幾何上，我們將輸入和輸出的像素視為正方形而不是點(diǎn)。如果設(shè)置為True，則輸入和輸出張量將按其角點(diǎn)像素的中心對齊，并保留角點(diǎn)像素處的值。如果設(shè)置為False，則輸入和輸出張量按其角點(diǎn)像素的角點(diǎn)對齊，并且插值對邊界值使用邊緣值填充，從而使此操作獨(dú)立于輸入 scale_factor保持相同時的尺寸。僅當(dāng)mode為'linear'，'bilinear'，'bicubic'或'trilinear'時才有效。默認(rèn)值：False

Note

使用mode='bicubic'可能會導(dǎo)致過沖，換句話說，它可能會產(chǎn)生負(fù)值或大于 255 的圖像值。如果要減少顯示圖像時的過沖，請明確調(diào)用result.clamp(min=0, max=255)。

Warning

使用align_corners = True時，線性插值模式(<cite>線性</cite>，<cite>雙線性</cite>和<cite>三線性</cite>）不會按比例對齊輸出像素和輸入像素，因此輸出值可以取決于輸入大小。這是這些模式(0.3.1 版之前）的默認(rèn)行為。從那時起，默認(rèn)行為是align_corners = False。

Note

When using the CUDA backend, this operation may induce nondeterministic behaviour in its backward pass that is not easily switched off. Please see the notes on Reproducibility for background.

上采樣

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

將輸入上采樣到給定的size或給定的scale_factor

Warning

不推薦使用此功能，而推薦使用 torch.nn.functional.interpolate() 。與nn.functional.interpolate(...)等效。

Note

When using the CUDA backend, this operation may induce nondeterministic behaviour in its backward pass that is not easily switched off. Please see the notes on Reproducibility for background.

用于上采樣的算法由mode確定。

當(dāng)前支持時間，空間和體積上采樣，即，預(yù)期輸入的形狀為 3D，4D 或 5D。

The input dimensions are interpreted in the form: <cite>mini-batch x channels x [optional depth] x [optional height] x width</cite>.

可用于上采樣的模式為：<cite>最接近</cite>，<cite>線性</cite>(僅 3D），<cite>雙線性</cite>，<cite>雙三次</cite>(僅 4D），<cite>三線性</cite>(僅限 5D）

Parameters

input (Tensor) – the input tensor
size (python:int or Tuple[python:int__] or Tuple[python:int__, python:int__] or Tuple[python:int__, python:int__, python:int__]) – output spatial size.
scale_factor (python：float 或元組 [ python：float ] )–空間大小的乘數(shù)。必須是整數(shù)。
模式(字符串）–用于上采樣的算法：'nearest' | 'linear' | 'bilinear' | 'bicubic' | 'trilinear'。默認(rèn)值：'nearest'
align_corners (bool__, optional) – Geometrically, we consider the pixels of the input and output as squares rather than points. If set to True, the input and output tensors are aligned by the center points of their corner pixels, preserving the values at the corner pixels. If set to False, the input and output tensors are aligned by the corner points of their corner pixels, and the interpolation uses edge value padding for out-of-boundary values, making this operation independent of input size when scale_factor is kept the same. This only has an effect when mode is 'linear', 'bilinear', 'bicubic' or 'trilinear'. Default: False

Note

With mode='bicubic', it's possible to cause overshoot, in other words it can produce negative values or values greater than 255 for images. Explicitly call result.clamp(min=0, max=255) if you want to reduce the overshoot when displaying the image.

Warning

With align_corners = True, the linearly interpolating modes (<cite>linear</cite>, <cite>bilinear</cite>, and <cite>trilinear</cite>) don't proportionally align the output and input pixels, and thus the output values can depend on the input size. This was the default behavior for these modes up to version 0.3.1. Since then, the default behavior is align_corners = False. See Upsample for concrete examples on how this affects the outputs.

upsample_nearest

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

使用最近鄰的像素值對輸入進(jìn)行上采樣。

Warning

不推薦使用此功能，而推薦使用 torch.nn.functional.interpolate() 。與nn.functional.interpolate(..., mode='nearest')等效。

當(dāng)前支持空間和體積上采樣(即，預(yù)期輸入為 4 維或 5 維）。

Parameters

input (Tensor) – input
大小 (python：int 或元組 [ python：int ， python：int ]或元組 [ python：int ， python：int ， python：int ] )–輸出空間大小。
scale_factor (python：int )–空間大小的乘數(shù)。必須是整數(shù)。

Note

When using the CUDA backend, this operation may induce nondeterministic behaviour in its backward pass that is not easily switched off. Please see the notes on Reproducibility for background.

upsample_bilinear

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

使用雙線性上采樣對輸入進(jìn)行上采樣。

Warning

不推薦使用此功能，而推薦使用 torch.nn.functional.interpolate() 。與nn.functional.interpolate(..., mode='bilinear', align_corners=True)等效。

預(yù)期的輸入是空間(4 維）。對于體積(5 維）輸入使用 <cite>upsample_trilinear</cite> 。

Parameters

input (Tensor) – input
大小 (python：int 或元組 [ python：int ， python：int ] )–輸出空間大小。
scale_factor (python：int 或元組 [ python：int ， python：int ] )–空間大小的乘數(shù)

Note

When using the CUDA backend, this operation may induce nondeterministic behaviour in its backward pass that is not easily switched off. Please see the notes on Reproducibility for background.

grid_sample

torch.nn.functional.grid_sample(input, grid, mode='bilinear', padding_mode='zeros', align_corners=None)?

給定input和流場grid，則使用input值和來自grid的像素位置來計(jì)算output。

當(dāng)前，僅支持空間(4-D）和體積(5-D）input。

在空間(4-D）情況下，對于形狀為的input和形狀為的grid，輸出將具有形狀。

對于每個輸出位置output[n, :, h, w]，大小為 2 的向量grid[n, h, w]指定input像素位置x和y，用于對輸出值output[n, :, h, w]進(jìn)行插值。在 5D 輸入的情況下，grid[n, d, h, w]指定用于內(nèi)插output[n, :, d, h, w]的x，y，z像素位置。 mode自變量指定nearest或bilinear內(nèi)插方法以對輸入像素進(jìn)行采樣。

grid指定通過input空間尺寸歸一化的采樣像素位置。因此，它應(yīng)具有[-1, 1]范圍內(nèi)的大多數(shù)值。例如，值x = -1, y = -1是input的左上像素，值x = 1, y = 1是input的右下像素。

如果grid的值超出[-1, 1]范圍，則按padding_mode定義處理相應(yīng)的輸出。選項(xiàng)是

padding_mode="zeros"：將0用于出站網(wǎng)格位置，

- padding_mode="border"：將邊界值用于出站網(wǎng)格位置，

- padding_mode="reflection"：將邊界所反映的位置的值用于邊界外的網(wǎng)格位置。對于遠(yuǎn)離邊界的位置，它將一直被反射直到成為邊界，例如，(標(biāo)準(zhǔn)化）像素位置x = -3.5被邊界-1反射并變?yōu)?code>x' = 1.5，然后被邊界1反射并變?yōu)閇 x'' = -0.5。

Note

此功能通常與 affine_grid() 結(jié)合使用，以構(gòu)建空間變壓器網(wǎng)絡(luò)。

Note

When using the CUDA backend, this operation may induce nondeterministic behaviour in its backward pass that is not easily switched off. Please see the notes on Reproducibility for background.

Parameters

輸入 (tensor)–輸入形狀(4-D 情況）或(5-D 情況）
網(wǎng)格 (tensor)–形狀為(4-D 情況）或(5-D 情況）的流場
模式 (str )–插值模式以計(jì)算輸出值'bilinear' | 'nearest'。默認(rèn)值：'bilinear'
padding_mode (str )–外部網(wǎng)格值的填充模式'zeros' | 'border' | 'reflection'。默認(rèn)值：'zeros'
align_corners (布爾 ， 可選）–在幾何上，我們將輸入像素視為正方形而不是點(diǎn)。如果設(shè)置為True，則極值(-1和1）被視為參考輸入角像素的中心點(diǎn)。如果設(shè)置為False，則它們將被視為參考輸入的角像素的角點(diǎn)，從而使采樣更加不可知。此選項(xiàng)與 interpolate() 中的align_corners選項(xiàng)相似，因此在網(wǎng)格采樣之前，此處使用的任何選項(xiàng)也應(yīng)用于調(diào)整輸入圖像的大小。默認(rèn)值：False

Returns

輸出張量

返回類型

輸出(張量）

Warning

當(dāng)align_corners = True時，網(wǎng)格位置取決于相對于輸入圖像大小的像素大小，因此對于以不同分辨率給出的同一輸入， grid_sample() 采樣的位置將有所不同(也就是說，上采樣或下采樣）。直到版本 1.2.0，默認(rèn)行為是align_corners = True。從那時起，默認(rèn)行為已更改為align_corners = False，以使其與 interpolate() 的默認(rèn)行為保持一致。

仿射網(wǎng)格

torch.nn.functional.affine_grid(theta, size, align_corners=None)?

給定一批仿射矩陣theta，生成 2D 或 3D 流場(采樣網(wǎng)格）。

Note

此功能通常與 grid_sample() 結(jié)合使用，以構(gòu)建空間變壓器網(wǎng)絡(luò)。

Parameters

theta (tensor)–輸入仿射矩陣，其形狀為(D）(2D）或(）3D
大小(torch大小）–目標(biāo)輸出圖像大小。 (用于 2D 的或用于 3D 的）示例：torch.Size((32，3，24，24））
align_corners (bool ， 可選）–如果True，請考慮-1和1指的是角像素而不是圖像角。由 affine_grid() 生成的網(wǎng)格應(yīng)傳遞至 grid_sample() ，并為此選項(xiàng)設(shè)置相同。默認(rèn)值：False

Returns

輸出張量大小(）

Return type

output ([]()Tensor)

Warning

When align_corners = True, the grid positions depend on the pixel size relative to the input image size, and so the locations sampled by grid_sample() will differ for the same input given at different resolutions (that is, after being upsampled or downsampled). The default behavior up to version 1.2.0 was align_corners = True. Since then, the default behavior has been changed to align_corners = False, in order to bring it in line with the default for interpolate().

Warning

當(dāng)align_corners = True時，對 1D 數(shù)據(jù)的 2D 仿射變換和對 2D 數(shù)據(jù)的 3D 仿射變換(即，當(dāng)空間維度之一具有單位大小時）定義不明確，而不是預(yù)期的用例。當(dāng)align_corners = False時這不是問題。在版本 1.2.0 之前的版本中，沿單位維度的所有網(wǎng)格點(diǎn)都被視為任意-1。從版本 1.3.0 開始，在align_corners = True下，單位尺寸上的所有網(wǎng)格點(diǎn)都被認(rèn)為位于`0(輸入圖像的中心）處。

DataParallel 功能(多 GPU，分布式）

data_parallel

torch.nn.parallel.data_parallel(module, inputs, device_ids=None, output_device=None, dim=0, module_kwargs=None)?

跨 device_ids 中提供的 GPU 并行評估模塊(輸入）。

這是 DataParallel 模塊的功能版本。

Parameters

模塊 (模塊)–并行評估的模塊
輸入 (tensor)–模塊的輸入
device_ids (python：int 的列表： 或 Torch.device)–在其上復(fù)制模塊的 GPU ID
output_device (python：int 的列表： 或 Torch.device)–輸出的 GPU 位置使用- 1 表示 CPU。 (默認(rèn)值：device_ids [0]）

Returns

一個 Tensor，包含位于 output_device 上的 module(input）的結(jié)果

PyTorch torch功能

卷積函數(shù)

轉(zhuǎn)換

轉(zhuǎn)換 2d

conv3d

conv_transpose1d

conv_transpose2d

conv_transpose3d

展開

折

池化功能

avg_pool1d

avg_pool2d

avg_pool3d

max_pool1d

max_pool2d

max_pool3d

max_unpool1d

max_unpool2d

max_unpool3d

lp_pool1d

lp_pool2d

adaptive_max_pool1d

adaptive_max_pool2d

adaptive_max_pool3d

adaptive_avg_pool1d

adaptive_avg_pool2d

adaptive_avg_pool3d

非線性激活功能

閾

露露

Hardtanh

relu6

lu

塞盧

塞盧

leaky_relu

前路

雷雷魯

谷氨酸

格魯

對數(shù)乙狀結(jié)腸

硬縮

tanhshrink

軟簽

軟加

軟敏

軟最大

軟縮

gumbel_softmax

log_softmax

譚

乙狀結(jié)腸

歸一化功能

batch_norm

instance_norm

layer_norm

local_response_norm

歸一化

線性功能

線性的

雙線性

輟學(xué)功能

退出

alpha_dropout

dropout2d

dropout3d

稀疏功能

嵌入

embedding_bag

one_hot

距離功能

pairwise_distance

余弦相似度

pdist

損失函數(shù)

binary_cross_entropy