# mypy: 允许未类型化定义
导入
数学
来自
打字
导入
任何
导入
火炬
来自
火炬
导入
张量
来自 torch.nn
导入
功能性
作为 F,
初始化
来自
torch.nn 参数
导入
参数,
未初始化的参数
来自
.懒
导入 LazyModuleMixin
来自
.模块
导入
模块
__all__ = [
双线性,
标识符,
"LazyLinear",
"线性",
]
[文档]类 Identity(Module):
r"""一个对参数不敏感的占位符身份运算符。"""
Args:
args: 任意参数（未使用）
kwargs: 任意关键字参数（未使用）
Shape:
输入：:math:`(*)`，其中 :math:`*` 表示任意维数。
输出：:math:`(*)`，与输入具有相同的形状。
示例::
>>> 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: Any, **kwargs: Any) -> None:
super().__init__()
def forward(self, input: Tensor) -> Tensor:
返回输入
[文档]
类
线性(
模块):
r对输入数据应用仿射线性变换：:math:`y = xA^T + b`
本模块支持：:ref:`TensorFloat32`.
在某些 ROCm 设备上，当使用 float16 输入时，此模块将使用：ref:`不同精度`进行反向操作。
Args:
in_features: 每个输入样本的大小
out_features: 每个输出样本的大小
偏差：如果设置为“False”，则该层将不会学习一个加性偏差。
默认：``True``
形状：
输入：:math:`(*, H_\text{in})` 其中 :math:`*` 表示任意数量的
尺寸包括无和 :math:`H_\text{in} = \text{in\_features}`。
输出：:math:`(*, H_\text{out})` 其中除了最后一个维度
输入和 :math:`H_\text{out} = \text{out\_features}` 形状相同。
属性：
weight：模块的可学习权重，形状为
math:`(\text{out\_features}, \text{in\_features})`。这些值从 :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` 初始化。
其中，从 :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` 初始化。
\( k = \frac{1}{\text{in\_features}} \)
偏置：该模块的可学习偏置，形状为 \( (\text{out\_features}) \)。
如果 :attr:`bias` 为 ``True``，则值从
\( \mathcal{U}(-\sqrt{k}, \sqrt{k}) \) 中初始化
`k = 1 / in_features`
示例：
>>> m = nn.Linear(20, 30)
>>> input = torch.randn(128, 20)
>>> 输出 = m(输入)
>>> 打印(output.size())
torch.Size([128, 30])
"源代码"
__constants__ = [in_features,
out_features]
输入特征:
整型
输出特征:
整型
重量:
张量
def 初始化(
self,
输入特征: int,
输出特征: int,
偏差:
布尔类型 = True,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化()
self.输入特征 =
输入特征
self.输出特征 =
输出特征
self.权重 =
参数(
火炬.
空的((
输出特征,
输入特征), **
工厂参数)
)
如果
偏差:
self.bias = 参数(
火炬.
空的(
输出特征, **
工厂参数))
否则:
self.注册参数(
偏差,
无)
self.重置参数()
def 重置参数(self) ->
无:
在 kaiming_uniform 中将 a=sqrt(5)设置与用
# 均匀分布(-1/sqrt(in_features), 1/sqrt(in_features))。详细信息请参阅
# https://github.com/pytorch/pytorch/issues/57109
初始化.kaiming_uniform_(self.
重量, a=
数学.
平方根(5))
如果 self.bias
是 not
无:
风扇进, _ =
初始化.
_计算扇入和扇出(self.
重量)
限制 = 1 /
数学.
平方根(
风扇进)
如果
扩展输入 > 0
否则 0
初始化.
均匀的(self.
偏差, -
绑定,
绑定)
def 前向(self,
输入:
张量) ->
张量:
返回 F.
线性(
输入, self.
重量, self.
偏差)
def 额外表示(self) ->
字符串:
返回 f
in_features={self.in_features}, out_features={self.out_features}
, 偏差={self.bias
是 not
无}"
# 此类仅用于避免在脚本中触发一个罕见的错误
# 一个不正确量化的注意力层。有关详细信息，请参阅此问题：
# https://github.com/pytorch/pytorch/issues/58969
# TODO: 在量化 API 使用错误时快速失败，然后删除此类
# 将对它的使用替换为普通的线性
类
非动态量化的线性(
线性):
def 初始化(
self,
输入特征: int,
输出特征: int,
偏差:
布尔类型 = True,
设备=
无,
数据类型=
无,
) -> 无:
超级().
初始化(
in_features, out_features, 偏差=
偏差,
设备=
设备,
数据类型=dtype
)
[文档]
类
双线性(
模块):
r对传入数据进行双线性变换：:math:`y = x_1^T A x_2 + b`
Args:
in1_features: 每个第一个输入样本的大小
in2_features: 每个第二个输入样本的大小
out_features: 每个输出样本的大小
如果设置为 ``False``，则层将不会学习加性偏置。
默认：``True``
形状：
- 输入 1: :math:`(*, H_\text{in1})` 其中 :math:`H_\text{in1}=\text{in1\_features}`
math:`*` 表示任何数量的额外维度，包括没有。除了最后一个维度之外的所有输入维度都应该相同。
应该相同。
- 输入 2：:math:`(*, H_\text{in2})` 其中 :math:`H_\text{in2}=\text{in2\_features}`。
- 输出：:math:`(*, H_\text{out})` 其中 :math:`H_\text{out}=\text{out\_features}`
并且除了最后一个维度外，其余维度都与输入相同。
属性：
weight: 该模块的可学习权重，形状为
math:`(\text{out\_features}, \text{in1\_features}, \text{in2\_features})`。
值从 :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` 初始化
math:`k = \frac{1}{\text{in1\_features}}`
偏置: 模块的 learnable 偏置，形状为 :math:`(\text{out\_features})`
如果 :attr:`bias` 为 ``True``，则值从
math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})`, 其中
math:`k = \frac{1}{\text{in1\_features}}`
示例：
>>> m = nn.Bilinear(20, 30, 40)
>>> input1 = torch.randn(128, 20)
>>> input2 = torch.randn(128, 30)
>>> output = m(input1, input2)
>>> 打印(output.size())
torch.Size([128, 40])
"源代码"
__constants__ = ["in1_features", in2 特征,
out 特征]
in1 特征:
整型
in2 特征:
整型
输出特征:
整型
重量:
张量
def 初始化(
self,
输入 1 特征: int,
输入 2 特征: int,
输出特征: int,
偏差:
布尔类型 = True,
设备=
无,
数据类型=
无,
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
超级().
初始化()
self.in1 功能 =
in1 功能
self.in2 功能 =
in2 功能
self.输出特征 =
输出特征
self.权重 =
参数(
火炬.
空的((
输出特征,
输入 1 特征, in2_features), **
工厂参数)
)
如果
偏差:
self.bias = 参数(
火炬.
空的(
输出特征, **
工厂参数))
否则:
self.注册参数(
偏差,
无)
self.重置参数()
def 重置参数(self) ->
无:
限制 = 1 /
数学.
平方根(self.
重量.
尺寸(1))
初始化.
均匀的(self.
重量, -
绑定,
绑定)
如果 self.bias
是 not
无:
初始化.
均匀的(self.
偏差, -
绑定,
绑定)
def 前向(self,
输入 1:
张量,
输入 2:
张量) ->
张量:
返回 F.
双线性(
输入 1,
输入 2, self.
重量, self.
偏差)
def 额外表示(self) ->
字符串:
返回 (
fin1_features={self.in1_features}, in2_features={self.in2_features}
，"
fout_features={self.
输出特征}
, 偏置={self.bias
是 not
无}"
)
[文档]
类
懒加载线性(
LazyModule 混入,
线性):
r这是一个推断 `in_features` 的 :class:`torch.nn.Linear` 模块。
在此模块中，`weight` 和 `bias` 是 :class:`torch.nn.UninitializedParameter` 类型的。它们将在第一次调用 `forward` 方法后进行初始化。
类。它们将在第一次调用 `forward` 方法后进行初始化。
该模块将变为一个常规的 :class:`torch.nn.Linear` 模块。`in_features` 参数
的 :class:`Linear` 的 `in_features` 从 `input.shape[-1]` 推断得出。
查看文档 :class:`torch.nn.modules.lazy.LazyModuleMixin` 以获取更多说明
关于懒加载模块及其限制。
Args:
`out_features`：每个输出样本的大小
`bias`：如果设置为 `False`，则该层将不会学习一个加性偏置。
默认：``True``
属性：
权重：该模块的可学习权重的形状
(out_features, in_features) 的值从 :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` 初始化
其中，从 :math:`\mathcal{U}(-\sqrt{k}, \sqrt{k})` 初始化
\( k = \frac{1}{\text{in\_features}} \)
偏置：该模块的可学习偏置，形状为 \( (\text{out\_features}) \)。
如果 :attr:`bias` 为 ``True``，则值从
\( \mathcal{U}(-\sqrt{k}, \sqrt{k}) \) 中初始化
\( k = \frac{1}{\text{in\_features}} \)
"源代码"
cls_to_become = 线性
# 类型：忽略[赋值]
重量:
未初始化的参数
偏差:
未初始化的参数
# 类型：忽略[赋值]
def 初始化(
self, 输出特征: int,
偏差:
布尔类型 = True,
设备=
无,
数据类型=
无
) -> 无:
工厂参数 = {
"设备":
设备, "dtype":
数据类型}
# 偏置被硬编码为 False 以避免创建张量
# 将很快被覆盖。
超级().
初始化(0, 0,
错误)
self.权重 =
未初始化参数(**
工厂参数)
self.输出特征 =
输出特征
如果
偏差:
self.bias = 未初始化参数(**
工厂参数)
def 重置参数(self) ->
无:
如果 not self.has_uninitialized_params()
和 self.
输入特征 != 0:
超级().
重置参数()
def initialize_parameters(self, 输入) ->
无:
# 类型：忽略[覆盖]
如果 self.has_uninitialized_params():
与
火炬.
不梯度():
self.输入特征 =
输入.shape[-1]
self.重量.
实现化((self.
输出特征, self.
输入特征))
如果 self.bias
是 not
无:
self.偏差.
实现化((self.
输出特征,))
self.重置参数()
# TODO: 可能是在稀疏中 - 可能线性？
