落叶无痕
0%

1

发表于 分类于 Changyan：

自动摘要: torch.eye() torch.eye(n,m=None,*,out=None,dtype=None,layout=torch.strided,device=None,requ ……..

torch.eye()

torch.eye(n, m=None, *, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor返回值：一个二维张量，对角线上有 1，其他地方有零返回类型：tensor参数：

  • n(int) - 行数
  • m(int, optional) - 可选参数，列数，默认值为n

关键词参数：optional –> 可选参数

  • out (Tensor, optional) – 输出张量
  • dtype (torch.dtype, optional) – 返回张量的数据类型。默认值: 如果无，则使用全局默认值
  • layout (torch.layout, optional) – 返回张量的期望布局。默认值: torch.strided
  • device(torch.device, optional) – 返回张量所需的装置(CPU or CUDA)。默认值: 如果没有，则使用当前设备的默认张量类型(参见 torch.set _ Default _ tensor _ type ())。设备将 CPU 为 CPU 张量类型和当前 CUDA 设备为 CUDA 张量类型。
  • requires_grad (bool, optional) – 如果 autograd 应该记录返回张量的操作。默认：False

例：

1
torch.eye(3)

输出结果：

1
2
3
tensor([[ 1.,  0.,  0.],
        [ 0.,  1.,  0.],
        [ 0.,  0.,  1.]])

torch.eq

1
torch.eq(input, other, *, out=None) → Tensor

计算元素相等第二个参数可以是一个数字或张量，其形状与第一个参数一起是可广播的。

参数：input (Tensor) – 要比较的张量；other (Tensor or float) – 要比较的张量或值；

关键字参数：out (Tensor, optional) – 输出张量。

返回值：一个布尔张量，为 True，input等于 other，否则为 False。

示例：

1
torch.eq(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[1, 1], [4, 4]]))

输出结果：

1
2
tensor([[ True, False],
        [False, True]])

torch.nn.Conv1d

CLASS torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode=’zeros’, device=None, dtype=None)

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

在最简单的情况下，输入大小为(N,
,L)的层的输出值(N,
,
)可以精确地描述为:
其中，*是矩阵乘法， N为批量大小(每次输入数据的个数)， C为通道数(特征数)，L代表序列的长度(最内维度的长度)。

此模块支持 TensorFloat32。在某些 ROCm 显卡设备上，当使用 float16输入时，该模块将使用不同的向后精度。

  • stride：控制互相关、单个数字或一个元素元组的步长(卷积步长)。
  • padding：控制应用于输入的填充量。它可以是一个字符串{‘ valid’, ‘same’} ，也可以是一个整数元组，给出两边应用的隐式填充量。
  • dilation：控制卷积核元素之间的间距; 也称为多孔算法。这很难描述，但是这个链接可以很好地显示dilation的作用。
  • groups：控制输入和输出之间的连接。 in _ channel 和 out _ channel 都必须被组整除。例如：
    • 当 groups = 1时，所有的输入都卷积到所有的输出；
    • 当 groups = 2时，操作变得相当于有两个并排的 conv 层，每个层看到一半的输入通道，产生一半的输出通道，并随后连接；
    • 在 groups = in _ channel 时，每个输入通道都与自己的一组过滤器相关联(
      )。

NOTE:

  • 当 group = = in _ channel 和 out _ channel = = K * in _ channel 时，其中 K 是一个正整数，这个操作也称为“纵向卷积”；
  • 换句话说，输入一个大小为(N,
    ,
    )，可以使用这些参数执行带有纵向乘子 K 的纵向卷积(
    ,
    )。

NOTE:

  • 在某些情况下，当 CUDA 设备上给定张量并使用 CuDNN 时，该算子可以选择一种不确定算法来提高性能。如果不希望这样，可以通过设置 torch.backends.cudnn.deterministic = True 使操作具有确定性(可能以性能开销为代价)。有关更多信息，请参见重复性。

NOTE:

  • Padding = ‘valid’ 与 no padding 是相同的。Pding = ‘same’ 填充输入，以便输出具有作为输入的形状。但是，此模式不支持除1以外的任何步长值。

NOTE:

  • 这个模块支持复杂的数据类型，例如: complex32, complex64, complex128.

参数：

  • in_channels (int) – 输入图像数量的渠道(一般为特征数)；
  • out_channels (int) – 卷积产生的通道数；
  • kernel_size (int or tuple) – 卷积内核的大小，卷积核的大小为(k,)，第二个维度是由in_channels来决定的，所以实际上卷积大小为kernel_size*in_channels；
  • stride (int or tuple, optional) – 卷积的步长，默认：1；
  • padding (int, tuple or str, optional) – 添加到输入两侧的填充层数，默认：0；
  • padding_mode (str, optional) – ‘zeros’, ‘reflect’, ‘replicate’ or ‘circular’. 默认： ‘zeros’；
  • dilation (int or tuple, optional) – 卷积核元素之间的间距，默认：1；
  • groups (int, optional) – 从输入通道到输出通道的阻塞连接数，默认：1；
  • bias (bool, optional) – 如果为 True，则在输出中添加一个可学习的偏置，默认：True。

Shape:

  • Input: (N,
    ,
    ,
    )；
  • Output: (N,
    ,
    ,
    ) ，其中


。

变量：

  • weight (Tensor) – shape模块可学习权重 (out_channels，
    ，kernel_size) ，这些权重的值是从
    ，其中
    ；
  • bias (Tensor) – shape模块的可学习偏差 (out_channels)。如果bias 为 True，然后这些权重的值来自
    。

示例：

1
2
3
m = nn.Conv1d(16, 33, 3, stride=2)
input = torch.randn(20, 16, 50)
output = m(input)

torch.nn.Conv2d

CLASS torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode=’zeros’, device=None, dtype=None)

在由几个输入平面组成的输入信号上应用二维卷积。

在最简单的情况下，输入大小为(
其中 * 是有效的二维互相关运算符，N 是批量大小，C 表示通道数，H 是以像素为单位的输入平面的高度，W 是以像素为单位的宽度。

此模块支持 TensorFloat32。

在某些 ROCm 设备上，当使用 float16输入时，该模块将使用不同的向后精度。

  • Stride 控制互相关、单个数字或元组的步长。
  • padding：控制应用于输入的填充量。它可以是一个字符串{‘ valid’，‘ same’} ，也可以是一个整数元组，给出两边应用的隐式填充量。
  • dilation控制卷积核元素之间的间距; 也称为多孔算法。这很难描述，但是这个链接可以很好地显示dilation的作用。
  • group 控制输入和输出之间的连接. in _ channel 和 out _ channel 都必须被 groups整除, 例如,
    • 在groups = 1时，卷积的输入数 = 输出数。
    • 在groups = 2时，操作变得相当于有两个并排的 conv 层，每个层看到一半的输入通道，产生一半的输出通道，并随后连接。
    • 在 group = in _ channels 时，每个输入通道都有自己的过滤器组(of size
      )。

Kernel _ size、 stride、 pding、 dilation 参数可以是:

  • 单个 int - 在这种情况下，高度和宽度维度使用相同的值；
  • 两个整数的tuple - 在这种情况下，第一个整数用于高度维度，第二个整数用于宽度维度。

注意：

  • 当 group = = in _ channel 和 out _ channel = = K * in _ channel 时，其中 K 是一个正整数，这个操作也称为“纵向卷积”。
  • 换句话说，输入一个大小为(N,
    ,
    )，可以使用这些参数执行带有纵向乘子 K 的纵向卷积(
    ,
    )

注意：

  • 在某些情况下，当 CUDA 设备上给定张量并使用 CuDNN 时，该算子可以选择一种不确定算法来提高性能。如果不希望这样，可以通过设置 torch.backends.cudnn.deterministic = True 使操作具有确定性(可能以性能开销为代价)。有关更多信息，请参见Reproducibility。

注意：

  • Padding = ‘ valid’ 与 no padding 是相同的。Padding = ‘same’ 将填充输入，以便输出具有作为输入的形状。但是，此模式不支持除1以外的任何步长值。

注意：

  • 这个模块支持复杂的数据类型，例如: 错综复杂的数据类型32，错综复杂的数据类型64，错综复杂的数据类型128。

参数：

  • In _ channel (int) - 输入图像的通道数；
  • out _ channel (int) - 卷积产生的通道数；
  • Kernel _ Size (int 或 tuple) - 卷积内核的大小；
  • Stride (int 或 tuple，可选) - 卷积的步长。默认值: 1；
  • padding(int、 tuple 或 str，可选) - 将填充添加到输入的所有四边。默认值: 0；
  • padding _ mode (str，可选) -‘ zeros’，‘ response’，‘ copy’或‘ circulal’。默认值: ‘ zeros’；
  • dilation (int 或 tuple，可选) - 内核元素之间的间距。默认值: 1；
  • group (int，可选) - 从输入通道到输出通道的阻塞连接数；
  • bias(bool，可选) - 如果为True，则在输出中添加一个可学习的偏见。默认值：True。

Shape：输入：(
) or (
)输出：
or
，其中

变量：

  • weight (Tensor) – 模型可学习权重的形状(out_channels,
    其中
    。
  • bias (Tensor) – 形状(通道)模块的可学习偏差。如果bias为True，则这些权重的值从
    其中
    。

示例：

1
2
3
4
5
6
7
8
# With square kernels and equal stride
m = nn.Conv2d(16, 33, 3, stride=2)
# non-square kernels and unequal stride and with padding
m = nn.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))
# non-square kernels and unequal stride and with padding and dilation
m = nn.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2), dilation=(3, 1))
input = torch.randn(20, 16, 50, 100)
output = m(input)

torch.nn.Linear

CLASS torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)

对传入的数据应用线性映射：

此模块支持 TensorFloat32。

在某些 ROCm 设备上，当使用 float16输入时，该模块将使用不同的向后精度。

参数：

  • in_features (int) – 每个输入样本的大小；
  • out_features (int) – 每个输出样本的大小；
  • bias (bool) – 如果设置为 False，图层将不会学习附加偏置。默认值: True。

Shape:

  • Input: (∗,
    )其中 * 表示任意数量的尺寸包括none，
    = in_features ；
  • Output: (∗,
    )除了最后一个维度外，其他所有维度的形状都与输入相同，
    = out_features 。

变量：weight (torch.Tensor) – 模块的可学的权重的形状(out_features, in_features)。初始化值
，其中

示例：

1
2
3
4
m = nn.Linear(20, 30)
input = torch.randn(128, 20)
output = m(input)
print(output.size())

输出结果：

1
torch.Size([128, 30])

torch.nn.BatchNorm1d

CLASS torch.nn.BatchNorm1d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None)

在2D 或3D 输入上应用批量标准化，如文中所述的批量标准化: 通过减少内部协变量移位加速深度网络训练。
平均值和标准偏差是在小批量上每维计算的，γ 和 β 是大小为 C 的可学习参数向量(其中 C 是输入的特征或通道的数目)。默认情况下，γ 的元素被设置为1，而 β 的元素被设置为 0 。标准偏差是通过有偏估计器计算的，等效于 torch.var (input, unbiased = False)。

默认情况下，在训练期间，这一层保持运行其计算出的平均值和方差的估计值，然后在评估期间使用这些估计值进行归一化。运行估计保持默认 momentum 为0.1。

如果 track _ running _ stats 被设置为 False，那么这个层就不会保留运行估计值，而是在评估期间使用批量统计信息。

NOTE:这个momentum参数不同于优化器类中使用的动量参数和传统的动量概念。从数学上讲，这里运行统计信息的更新规则是
，其中
是估计的统计量和
是新的观测值。

因为批处理标准化是在 C 维度上完成的，在(N，L)切片上计算统计信息，所以常用的术语称之为时态批处理标准化。

参数：

  • num_features (int) – 输入的特征数或通道数C；
  • eps (float) – 数值稳定性分母的附加值，默认：1e-5；
  • momentum (float) – 用于 running _ mean 和 running _ var 计算的值。累积移动平均数(即简单平均数)可设定为None。默认：0.1；
  • affine (bool) – 一个布尔值，当设置为 True 时，该模块具有可学习的仿射参数。默认：True；
  • track_running_stats (bool) – 一个布尔值，当设置为 True 时，该模块跟踪正在运行的均值和方差，当设置为 False 时，该模块不跟踪这样的统计信息，并将统计缓冲区 running _ mean 和 running _ var 初始化为 Nothing。当这些缓冲区为 Nothing 时，此模块始终使用批处理统计信息。在训练和评估两种模式下。默认：True。

Shape:

  • Input: (N，C)或(N，C，L)，其中 N 是批量大小，C 是特征或通道的数目，L 是序列长度；
  • Output: (N, C)或(N，C，L) ，与输入形状相同。

示例：

1
2
3
4
5
6
7
#有可学习的参数
m = nn.BatchNorm1d(100)
#没有可学习的参数
m = nn.BatchNorm1d(100, affine=False)
input = torch.randn(20, 100)
output = m(input)
print(output)

torch.nn.BatchNorm2d

CLASS torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, device=None, dtype=None)

在一个4D 输入上应用批量标准化(一个附加通道尺寸的小批量2D 输入) ，正如文章中描述的批量标准化: 通过减少内部协变量移位加速深度网络训练。
平均值和标准偏差是在小批量上每维计算的，γ 和 β 是大小 C (其中 C 是输入大小)的可学习的参数向量。默认情况下，将 γ 的元素设置为1，将 β 的元素设置为0。标准偏差是通过有偏估计器计算的，等效于 torch.var (input, unbiased = False)。

默认情况下，在训练期间，这一层保持运行其计算出的平均值和方差的估计值，然后在评估期间使用这些估计值进行归一化。运行估计保持默认 momentum为0.1。

如果 track _ running _ stats 被设置为 False，那么这个层就不会保留运行估计值，而是在评估期间使用批量统计信息。

NOTE:这个 momentum 参数不同于优化器类中使用的动量参数和传统的动量概念。从数学上讲，这里运行统计信息的更新规则是
，其中
是估计的统计量和
是新的观测值。

因为批量标准化是在 C 维度上完成的，在(N，H，W)切片上计算统计信息，所以常用的术语称之为空间批量标准化。

参数：

  • num_features (int) – C 来源于期望输入的大小(N，C，H，W)；
  • eps (float) – 增加到数值稳定性分母的值。默认值: 1e-5；
  • momentum (float) – 用于 running _ mean 和 running _ var 计算的值。累积移动平均数(即简单平均数)可设定为无。默认值: 0.1；
  • affine (bool) – 一个布尔值，当设置为 True 时，该模块具有可学习的仿射参数；
  • track_running_stats (bool) – 一个布尔值，当设置为 True 时，该模块跟踪正在运行的均值和方差，当设置为 False 时，该模块不跟踪这样的统计信息，并将统计缓冲区 running _ mean 和 running _ var 初始化为 None。当这些缓冲区为 None 时，此模块始终使用批处理统计信息。在训练和评估两种模式下。默认值: True；

Shape:

  • Input: (N, C, H, W)
  • Output: (N, C, H, W) (same shape as input)

示例：

1
2
3
4
5
6
# With Learnable Parameters
m = nn.BatchNorm2d(100)
# Without Learnable Parameters
m = nn.BatchNorm2d(100, affine=False)
input = torch.randn(20, 100, 35, 45)
output = m(input)

torch.nn.ReLU

CLASS torch.nn.ReLU(inplace=False)激活函数用于校正线性函数的权重：

参数：inplace (bool) – 可以选择就地进行操作，默认：False。

Shape：Input: (∗)，其中 ∗ 表示任意数量的尺寸；Output: (∗), 与输入形状相同。

torch.nn.Sequential

CLASS torch.nn.Sequential(*args: Module)CLASS torch.nn.Sequential(arg: OrderedDict[str, Module])顺序容器。模块将按照它们在构造函数中传递的顺序添加到它。或者，也可以传入模块的 OrderedDect。Sequential 的 forward ()方法接受任何输入，并将其转发给它包含的第一个模块。然后，它将输出“链接”到每个后续模块的输入，最后返回最后一个模块的输出。

Sequential 通过手动调用模块序列提供的价值在于，它允许将整个容器视为一个单独的模块，例如，对Sequential 执行转换将应用于它存储的每个模块(每个模块都是 Sequential 的注册子模块)。

Sequential 和 torch.nn.ModuleList 有什么区别？ModuleList 就像它听起来的那样——一个用于存储 Modules 的列表！另一方面，在一个顺序的层是连接在一个级联的方式。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Using Sequential to create a small model. When `model` is run,
# input will first be passed to `Conv2d(1,20,5)`. The output of
# `Conv2d(1,20,5)` will be used as the input to the first
# `ReLU`; the output of the first `ReLU` will become the input
# for `Conv2d(20,64,5)`. Finally, the output of
# `Conv2d(20,64,5)` will be used as input to the second `ReLU`
model = nn.Sequential(
          nn.Conv2d(1,20,5),
          nn.ReLU(),
          nn.Conv2d(20,64,5),
          nn.ReLU()
        )

# Using Sequential with OrderedDict. This is functionally the
# same as the above code
model = nn.Sequential(OrderedDict([
          ('conv1', nn.Conv2d(1,20,5)),
          ('relu1', nn.ReLU()),
          ('conv2', nn.Conv2d(20,64,5)),
          ('relu2', nn.ReLU())
        ]))

append(module)：将给定模块追加到末尾。Parameters:module (nn.Module) – 要添加的Module。Return type:Sequential。

torch.nn.ModuleList

CLASS torch.nn.ModuleList(modules=None)

将子模块保存在列表中。

ModuleList 可以像普通 Python 列表一样进行索引，但是它包含的模块已经自动注册整个网络上，并且所有 Module 方法都可以看到它。

参数：modules (iterable, optional) – 添加可迭代的模块

示例：

1
2
3
4
5
6
7
8
9
10
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

append(module)：将给定模块追加到列表的末尾。参数：module (nn.Module) – 要追加的模块。返回类型:ModuleList

extend(modules)将 Python 中的模块可迭代地追加到列表的末尾。参数：modules (iterable) – 添加可迭代模块。返回类型：ModuleList

insert(index, module)在列表中的给定索引前插入给定模块。参数：index (int) – 要插入的索引；module (nn.Module) – 要插入的模块。

欢迎关注我的其它发布渠道