pytorch nn.linear,pytorch linear

2022-08-25 04:58:41 分类：python 阅读()

　　pytorch nn.linear,pytorch linear

　　Torch.nn是一个包，包含了构造神经网络结构的基本元素，任何神经网络层都可以在这个包中找到。下面文章主要介绍PyTorch中torch.nn.Linear的相关信息，通过示例代码非常详细的介绍。有需要的可以参考一下。

　　00-1010前言1。NN的原理。线性：2。神经网络的使用。线性33603。神经网络的源代码定义。线性3360补充：很多细节需要声明和总结。

　　

目录

　　学变形金刚的时候，遇到过非常频繁的nn。线性()函数。下面是nn.linear的详细解释。

　　参考：3359pytorch.org/docs/stable/_模块/火炬/nn/模块/线性. html

　　

前言

　　从名字就可以看出，nn。Linear代表线性变换，原型是初等数学里学过的线性函数：Y=KX B

　　但是在深度学习中，变量是多维张量，乘法是矩阵乘法，加法是矩阵加法。因此，真正的计算由nn运行。线性()是：

　　输出=重量@输入偏差

　　@:代表python中的矩阵乘法

　　Input:表示输入张量，它可以有多个维度。

　　Weights:表示可以学习的权重，shape=(output _ feature，in _ feature)

　　Bias:表示学科学习的偏向性，shape=(output_feature)

　　in _ feature:nn . linear初始化的第一个参数，即张量最后一个维度的通道数。

　　out _ feature:nn . linear初始化的第二个参数，即返回张量最后一个维度的通道数。

　　Output:表示输入张量，它可以有多个维度。

　　

1. nn.Linear的原理：

　　常用头文件：导入torch.nn为nn

　　nn的初始化。线性():

　　nn。线性(输入特征，输出特征，偏差)

　　In_feature: int type，在forward中输入张量最后一个维度的通道数。

　　Out_feature: int类型，正向输出张量最后一个维度的通道数。

　　Bias: bool类型，线性变换中是否加偏置Bias？

　　nn的执行。Linear():(即执行前进功能)

　　out=nn。线性(输入)

　　Input:表示输入张量，它可以有多个维度。

　　Output:表示输入张量，它可以有多个维度。

　　示例：

　　二维张量

　　m=nn。线性(20，40)

　　input=torch.randn(128，20)

　　输出=m(输入)

　　print(output.size()) # [(128，40])

　　四维张量：

　　m=nn。线性(128，64)

　　input=torch.randn(512，3，128，128)

　　输出=m(输入)

　　print(output.size()) # [(512，3，128，64))

　　

2. nn.Linear的使用：

　　导入数学

　　进口火炬

　　将torch.nn作为nn导入

　　从火炬导入张量

　　从torch.nn.parameter导入参数，取消初始化参数

　　从torch.nn导入功能为F

　　从torch.nn导入初始化

　　#来自。懒人进口LazyModuleMixin

　　类myLinear(nn。模块):

　　r

　　""Applies a linear transformation to the incoming data: :math:`y = xA^T + b`

　　 This module supports :ref:`TensorFloat32<tf32_on_ampere>`.

　　 Args:

　　 in_features: size of each input sample

　　 out_features: size of each output sample

　　 bias: If set to ``False``, the layer will not learn an additive bias.

　　 Default: ``True``

　　 Shape:

　　 - Input: :math:`(*, H_{in})` where :math:`*` means any number of

　　 dimensions including none and :math:`H_{in} = \text{in\_features}`.

　　 - Output: :math:`(*, H_{out})` where all but the last dimension

　　 are the same shape as the input and :math:`H_{out} = \text{out\_features}`.

　　 Attributes:

　　 weight: the learnable weights of the module of shape

　　 :math:`(\text{out\_features}, \text{in\_features})`. The values are

　　 initialized from :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})`, where

　　 :math:`k = \frac{1}{\text{in\_features}}`

　　 bias: the learnable bias of the module of shape :math:`(\text{out\_features})`.

　　 If :attr:`bias` is ``True``, the values are initialized from

　　 :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` where

　　 :math:`k = \frac{1}{\text{in\_features}}`

　　 Examples::

　　 >>> m = nn.Linear(20, 30)

　　 >>> input = torch.randn(128, 20)

　　 >>> output = m(input)

　　 >>> print(output.size())

　　 torch.Size([128, 30])

　　 """

　　 __constants__ = [in_features, out_features]

　　 in_features: int

　　 out_features: int

　　 weight: Tensor

　　 def __init__(self, in_features: int, out_features: int, bias: bool = True,

　　 device=None, dtype=None) -> None:

　　 factory_kwargs = {device: device, dtype: dtype}

　　 super(myLinear, self).__init__()

　　 self.in_features = in_features

　　 self.out_features = out_features

　　 self.weight = Parameter(torch.empty((out_features, in_features), **factory_kwargs))

　　 if bias:

　　 self.bias = Parameter(torch.empty(out_features, **factory_kwargs))

　　 else:

　　 self.register_parameter(bias, None)

　　 self.reset_parameters()

　　 def reset_parameters(self) -> None:

　　 # Setting a=sqrt(5) in kaiming_uniform is the same as initializing with

　　 # uniform(-1/sqrt(in_features), 1/sqrt(in_features)). For details, see

　　 # https://github.com/pytorch/pytorch/issues/57109

　　 print("333")

　　 init.kaiming_uniform_(self.weight, a=math.sqrt(5))

　　 if self.bias is not None:

　　 fan_in, _ = init._calculate_fan_in_and_fan_out(self.weight)

　　 bound = 1 / math.sqrt(fan_in) if fan_in > 0 else 0

　　 init.uniform_(self.bias, -bound, bound)

　　 def forward(self, input: Tensor) -> Tensor:

　　 print("111")

　　 print("self.weight.shape=(", )

　　 return F.linear(input, self.weight, self.bias)

　　 def extra_repr(self) -> str:

　　 print("www")

　　 return in_features={}, out_features={}, bias={}.format(

　　 self.in_features, self.out_features, self.bias is not None

　　 )

　　# m = myLinear(20, 40)

　　# input = torch.randn(128, 40, 20)

　　# output = m(input)

　　# print(output.size())

　　m = myLinear(128, 64)

　　input = torch.randn(512, 3,128,128)

　　output = m(input)

　　print(output.size()) # [(512, 3,128,64))

　　

　　4. nn.Linear的官方源码:

　　

import math
　　import torch
　　from torch import Tensor
　　from torch.nn.parameter import Parameter, UninitializedParameter
　　from .. import functional as F
　　from .. import init
　　from .module import Module
　　from .lazy import LazyModuleMixin
　　class Identity(Module):
　　 r"""A placeholder identity operator that is argument-insensitive.
　　 Args:
　　 args: any argument (unused)
　　 kwargs: any keyword argument (unused)
　　 Shape:
　　 - Input: :math:`(*)`, where :math:`*` means any number of dimensions.
　　 - Output: :math:`(*)`, same shape as the input.
　　 Examples::
　　 >>> m = nn.Identity(54, unused_argument1=0.1, unused_argument2=False)
　　 >>> input = torch.randn(128, 20)
　　 >>> output = m(input)
　　 >>> print(output.size())
　　 torch.Size([128, 20])
　　 """
　　 def __init__(self, *args, **kwargs):
　　 super(Identity, self).__init__()
　　 def forward(self, input: Tensor) -> Tensor:
　　 return input
　　class Linear(Module):
　　 r"""Applies a linear transformation to the incoming data: :math:`y = xA^T + b`
　　 This module supports :ref:`TensorFloat32<tf32_on_ampere>`.
　　 Args:
　　 in_features: size of each input sample
　　 out_features: size of each output sample
　　 bias: If set to ``False``, the layer will not learn an additive bias.
　　 Default: ``True``
　　 Shape:
　　 - Input: :math:`(*, H_{in})` where :math:`*` means any number of
　　 dimensions including none and :math:`H_{in} = \text{in\_features}`.
　　 - Output: :math:`(*, H_{out})` where all but the last dimension
　　 are the same shape as the input and :math:`H_{out} = \text{out\_features}`.
　　 Attributes:
　　 weight: the learnable weights of the module of shape
　　 :math:`(\text{out\_features}, \text{in\_features})`. The values are
　　 initialized from :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})`, where
　　 :math:`k = \frac{1}{\text{in\_features}}`
　　 bias: the learnable bias of the module of shape :math:`(\text{out\_features})`.
　　 If :attr:`bias` is ``True``, the values are initialized from
　　 :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` where
　　 :math:`k = \frac{1}{\text{in\_features}}`
　　 Examples::
　　 >>> m = nn.Linear(20, 30)
　　 >>> input = torch.randn(128, 20)
　　 >>> output = m(input)
　　 >>> print(output.size())
　　 torch.Size([128, 30])
　　 """
　　 __constants__ = [in_features, out_features]
　　 in_features: int
　　 out_features: int
　　 weight: Tensor
　　 def __init__(self, in_features: int, out_features: int, bias: bool = True,
　　 device=None, dtype=None) -> None:
　　 factory_kwargs = {device: device, dtype: dtype}
　　 super(Linear, self).__init__()
　　 self.in_features = in_features
　　 self.out_features = out_features
　　 self.weight = Parameter(torch.empty((out_features, in_features), **factory_kwargs))
　　 if bias:
　　 self.bias = Parameter(torch.empty(out_features, **factory_kwargs))
　　 else:
　　 self.register_parameter(bias, None)
　　 self.reset_parameters()
　　 def reset_parameters(self) -> None:
　　 # Setting a=sqrt(5) in kaiming_uniform is the same as initializing with
　　 # uniform(-1/sqrt(in_features), 1/sqrt(in_features)). For details, see
　　 # https://github.com/pytorch/pytorch/issues/57109
　　 init.kaiming_uniform_(self.weight, a=math.sqrt(5))
　　 if self.bias is not None:
　　 fan_in, _ = init._calculate_fan_in_and_fan_out(self.weight)
　　 bound = 1 / math.sqrt(fan_in) if fan_in > 0 else 0
　　 init.uniform_(self.bias, -bound, bound)
　　 def forward(self, input: Tensor) -> Tensor:
　　 return F.linear(input, self.weight, self.bias)
　　 def extra_repr(self) -> str:
　　 return in_features={}, out_features={}, bias={}.format(
　　 self.in_features, self.out_features, self.bias is not None
　　 )
　　# This class exists solely to avoid triggering an obscure error when scripting
　　# an improperly quantized attention layer. See this issue for details:
　　# https://github.com/pytorch/pytorch/issues/58969
　　# TODO: fail fast on quantization API usage error, then remove this class
　　# and replace uses of it with plain Linear
　　class NonDynamicallyQuantizableLinear(Linear):
　　 def __init__(self, in_features: int, out_features: int, bias: bool = True,
　　 device=None, dtype=None) -> None:
　　 super().__init__(in_features, out_features, bias=bias,
　　 device=device, dtype=dtype)
　　[docs]class Bilinear(Module):
　　 r"""Applies a bilinear transformation to the incoming data:
　　 :math:`y = x_1^T A x_2 + b`
　　 Args:
　　 in1_features: size of each first input sample
　　 in2_features: size of each second input sample
　　 out_features: size of each output sample
　　 bias: If set to False, the layer will not learn an additive bias.
　　 Default: ``True``
　　 Shape:
　　 - Input1: :math:`(*, H_{in1})` where :math:`H_{in1}=\text{in1\_features}` and
　　 :math:`*` means any number of additional dimensions including none. All but the last dimension
　　 of the inputs should be the same.
　　 - Input2: :math:`(*, H_{in2})` where :math:`H_{in2}=\text{in2\_features}`.
　　 - Output: :math:`(*, H_{out})` where :math:`H_{out}=\text{out\_features}`
　　 and all but the last dimension are the same shape as the input.
　　 Attributes:
　　 weight: the learnable weights of the module of shape
　　 :math:`(\text{out\_features}, \text{in1\_features}, \text{in2\_features})`.
　　 The values are initialized from :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})`, where
　　 :math:`k = \frac{1}{\text{in1\_features}}`
　　 bias: the learnable bias of the module of shape :math:`(\text{out\_features})`.
　　 If :attr:`bias` is ``True``, the values are initialized from
　　 :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})`, where
　　 :math:`k = \frac{1}{\text{in1\_features}}`
　　 Examples::
　　 >>> m = nn.Bilinear(20, 30, 40)
　　 >>> input1 = torch.randn(128, 20)
　　 >>> input2 = torch.randn(128, 30)
　　 >>> output = m(input1, input2)
　　 >>> print(output.size())
　　 torch.Size([128, 40])
　　 """
　　 __constants__ = [in1_features, in2_features, out_features]
　　 in1_features: int
　　 in2_features: int
　　 out_features: int
　　 weight: Tensor
　　 def __init__(self, in1_features: int, in2_features: int, out_features: int, bias: bool = True,
　　 device=None, dtype=None) -> None:
　　 factory_kwargs = {device: device, dtype: dtype}
　　 super(Bilinear, self).__init__()
　　 self.in1_features = in1_features
　　 self.in2_features = in2_features
　　 self.out_features = out_features
　　 self.weight = Parameter(torch.empty((out_features, in1_features, in2_features), **factory_kwargs))
　　 if bias:
　　 self.bias = Parameter(torch.empty(out_features, **factory_kwargs))
　　 else:
　　 self.register_parameter(bias, None)
　　 self.reset_parameters()
　　 def reset_parameters(self) -> None:
　　 bound = 1 / math.sqrt(self.weight.size(1))
　　 init.uniform_(self.weight, -bound, bound)
　　 if self.bias is not None:
　　 init.uniform_(self.bias, -bound, bound)
　　 def forward(self, input1: Tensor, input2: Tensor) -> Tensor:
　　 return F.bilinear(input1, input2, self.weight, self.bias)
　　 def extra_repr(self) -> str:
　　 return in1_features={}, in2_features={}, out_features={}, bias={}.format(
　　 self.in1_features, self.in2_features, self.out_features, self.bias is not None
　　 )
　　class LazyLinear(LazyModuleMixin, Linear):
　　 r"""A :class:`torch.nn.Linear` module where `in_features` is inferred.
　　 In this module, the `weight` and `bias` are of :class:`torch.nn.UninitializedParameter`
　　 class. They will be initialized after the first call to ``forward`` is done and the
　　 module will become a regular :class:`torch.nn.Linear` module. The ``in_features`` argument
　　 of the :class:`Linear` is inferred from the ``input.shape[-1]``.
　　 Check the :class:`torch.nn.modules.lazy.LazyModuleMixin` for further documentation
　　 on lazy modules and their limitations.
　　 Args:
　　 out_features: size of each output sample
　　 bias: If set to ``False``, the layer will not learn an additive bias.
　　 Default: ``True``
　　 Attributes:
　　 weight: the learnable weights of the module of shape
　　 :math:`(\text{out\_features}, \text{in\_features})`. The values are
　　 initialized from :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})`, where
　　 :math:`k = \frac{1}{\text{in\_features}}`
　　 bias: the learnable bias of the module of shape :math:`(\text{out\_features})`.
　　 If :attr:`bias` is ``True``, the values are initialized from
　　 :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` where
　　 :math:`k = \frac{1}{\text{in\_features}}`
　　 """
　　 cls_to_become = Linear # type: ignore[assignment]
　　 weight: UninitializedParameter
　　 bias: UninitializedParameter # type: ignore[assignment]
　　 def __init__(self, out_features: int, bias: bool = True,
　　 device=None, dtype=None) -> None:
　　 factory_kwargs = {device: device, dtype: dtype}
　　 # bias is hardcoded to False to avoid creating tensor
　　 # that will soon be overwritten.
　　 super().__init__(0, 0, False)
　　 self.weight = UninitializedParameter(**factory_kwargs)
　　 self.out_features = out_features
　　 if bias:
　　 self.bias = UninitializedParameter(**factory_kwargs)
　　 def reset_parameters(self) -> None:
　　 if not self.has_uninitialized_params() and self.in_features != 0:
　　 super().reset_parameters()
　　 def initialize_parameters(self, input) -> None: # type: ignore[override]
　　 if self.has_uninitialized_params():
　　 with torch.no_grad():
　　 self.in_features = input.shape[-1]
　　 self.weight.materialize((self.out_features, self.in_features))
　　 if self.bias is not None:
　　 self.bias.materialize((self.out_features,))
　　 self.reset_parameters()
　　# TODO: PartialLinear - maybe in sparse?
　　

　　

　　

补充：许多细节需要声明

　　1）nn.Linear是一个类，使用时进行类的实例化

　　2）实例化的时候，nn.Linear需要输入两个参数，in_features为上一层神经元的个数，out_features为这一层的神经元个数

　　3）不需要定义w和b。所有nn.Module的子类，形如nn.XXX的层，都会在实例化的同时随机生成w和b的初始值。所以实例化之后，我们就可以调用属性weight和bias来查看生成的w和b。其中w是必然会生成的，b是我们可以控制是否要生成的。在nn.Linear类中，有参数bias，默认 bias = True。如果我们希望不拟合常量b，在实例化时将参数bias设置为False即可。

　　4）由于w和b是随机生成的，所以同样的代码多次运行后的结果是不一致的。如果我们希望控制随机性，则可以使用torch中的random类。如：torch.random.manual_seed(420) #人为设置随机数种子

　　5）由于不需要定义常量b，因此在特征张量中，不需要留出与常数项相乘的那一列，只需要输入特征张量。

　　6）输入层只有一层，并且输入层的结构（神经元的个数）由输入的特征张量X决定，因此在PyTorch中构筑神经网络时，不需要定义输入层。

　　7）实例化之后，将特征张量输入到实例化后的类中。

　　

　　

总结

　　到此这篇关于PyTorch中torch.nn.Linear实例详解的文章就介绍到这了,更多相关PyTorchtorch.nn.Linear详解内容请搜索盛行IT软件开发工作室以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT软件开发工作室！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

标签： python

相关文章阅读

  • python命令函数 python函数教学
  • python简单函数编程 如何用python编写函数
  • python随机函数种子 python随机数种子怎么用
  • python画兔子代码，python语言绘制小兔子源代码怎么运行
  • range函数是从0开始吗,python中range(0)
  • python多线程坑,python多线程阻塞
  • python怎么画k线,python绘制k线及均线
  • python调用安卓so库,python .so文件
  • python赋值运算符-=的作用是,在Python中关系运算符中,表示“不等于”
  • python语言是一种脚本编程语言,python属于脚本语言还是编程语言
  • python想获取字符串str的长度,python str转char
  • python从键盘不断输入整数,python控制键盘输入数字
  • python输入姓名输出姓,python输入名字输出你好代码
  • python怎么实现黑客攻击,python网络攻防
  • python@property,python中的property函数
    • 留言与评论（共有 条评论）
       
    验证码：