torch.functional 源代码

# mypy: 允许未类型化定义
导入 itertools
导入 操作符
from collections.abc 导入 序列
from 打字 导入 任何, 可选, 类型检查, 联合

导入 火炬
导入 torch.nn.functional as F
from 火炬 导入 _VF, 张量
from torch._C 导入 添加文档字符串
from torch._jit_internal 导入 覆盖 as 过载, boolean 分派
from torch._低秩 导入 pca 低秩, svd 低秩
from torch.overrides 导入 (
    handle_torch_function,
    有 torch 功能,
    has_torch_function_unary,
    has_torch_function_variadic,
)


全部 = [
    "至少_1 天",
    "至少_2 天",
    "至少_3 天",
    "对齐张量",
    "广播形状",
    "广播张量",
    "笛卡尔积",
    "块对角矩阵",
    "cdist",
    "chain_matmul",
    "einsum",
    "istft",
    "lu",
    "norm",
    "meshgrid",
    "pca_lowrank",
    "拆分",
    "stft",
    "SVD 低秩",
    "张量点",
    "唯一",
    独特连续,
    "unravel_index",
]


[文档]def broadcast_tensors(*tensors): 
广播张量(*tensors)
广播张量(*tensors) -> 张量列表

广播给定的张量，根据：:ref:`广播语义`.

Args:
*tensors: 同类型张量的任意数量

.. warning::

超过广播张量的一个元素可能指向单个
内存位置。因此，原地操作（尤其是那些
可能因向量化而导致行为不正确。如果您需要编写
请先克隆这些张量。

示例：

>>> x = torch.arange(3).view(1, 3)
>>> y = torch.arange(2).view(2, 1)
>>> a, b = torch.broadcast_tensors(x, y)
>>> a.size()
torch.Size([2, 3])
>>> a
tensor([[0, 1, 2],
[0, 1, 2]])
"""
# 此包装器存在以支持可变参数。
if has_torch_function(tensors):
return handle_torch_function(broadcast_tensors, tensors, *tensors)
return _VF.broadcast_tensors(tensors)  # 忽略未定义的属性


定义 广播形状(*形状):
    r"""broadcast_shapes(*shapes) -> 大小

类似于 :func:`broadcast_tensors` 但用于形状。

这相当于
    ``torch.broadcast_tensors(*map(torch.empty, shapes))[0].shape``
但避免了创建中间张量的需求。这在某些情况下很有用
广播具有相同批量形状但不同最右形状的张量，
例如，将均值向量广播到协方差矩阵。

示例::

        >>> torch.broadcast_shapes((2,), (3, 1), (1, 1, 1))
        torch.Size([1, 3, 2])

参数：
\*shapes (torch.Size): 张量的形状。

返回值：
shape (torch.Size): 与所有输入形状兼容的形状。

抛出异常：
RuntimeError: 如果形状不兼容。
    """
    # 此包装器存在是为了支持可变参数。
    一旦 jit 对 torch.Size 的支持更好，就将其移动到 C++
    如果 not 火炬.算子.is_tracing():
        最大长度 = 0
        对于 形状 进入 形状:
            如果 isinstance(形状, (int, 火炬.SymInt)):
                如果 最大长度 < 1:
                    最大长度 = 1
            elif isinstance(形状, (元组, 列表)):
                s = 长度(形状)
                如果 最大长度 < s:
                    最大长度 = s
        结果 = [1] * 最大长度

        from torch.fx.experimental.symbolic_shapes 导入 (
            守护大小无关,
            是否嵌套整型,
        )

        对于 形状 进入 形状:
            如果 isinstance(形状, (int, 火炬.SymInt)):
                形状 = (形状,)
            如果 isinstance(形状, (元组, 列表)):
                对于 i 进入 范围(-1, -1 - 长度(形状), -1):
                    如果 形状[i] < 0:
                        抛出 RuntimeError(
                            f尝试创建具有负维度的张量（{形状[i]}): ({形状[i]})"
                        )

                    # NB: 处理嵌套整数特别小心，以避免在 Ne(j0, 1) 上无效的守卫。
                    如果 是否嵌套整型(形状[i)]
                        # 允许广播为 (j0, 1) 或 (j0, j0)；
                        # 不允许 (j0, j1)，(j0, 5) 等。
                        如果 是否嵌套整型(结果[i]) 和 守护大小无关(
                            形状[i] == 结果[i]
                        ):
                            continue
                    否则:
                        # NB: 结果初始化为 1 所以这实际上是一个
                        # 等于一个测试
                        如果 守护大小无关(形状[i] == 1) 或者 守护大小无关(
                            形状[i] == 结果[i]
                        ):
                            continue

                    如果 结果[i] != 1:
                        抛出 RuntimeError(
                            形状不匹配：对象无法广播到单个形状
                        )
                    结果[i] = 形状[i]
            否则:
                抛出 RuntimeError(
                    输入形状应为 int 类型、int 元组或 int 列表，却得到了,
                    形状,
                )
        返回 火炬.尺寸(结果)
    否则:
        在上述实现中，torch.jit.trace 会硬编码大小，这导致后续重放失败
        替换为 火炬.不梯度():
            标量 = 火炬.零值((), 设备="cpu")
            张量 = [标量.展开(形状) 对于 形状 进入 形状]
            张量 = 广播张量(*张量)
            返回 张量[0].形状



定义 分割(
    张量: 张量,
    分割大小或部分: 联合[int, 列表[int]],
    维度: 整型 = 0,
) -> 元组[张量, ...]
    r将张量分割成块。每个块是原始张量的视图。

如果 `split_size_or_sections` 是一个整型，则 `tensor` 将被分割成等大小的块（如果可能）。如果沿着给定维度 `dim` 的张量大小不能被 `split_size` 整除，则最后一个块将更小。
如果沿着给定维度 `dim` 的张量大小不能被 `split_size` 整除，则最后一个块将更小。
如果沿着给定维度 `dim` 的张量大小不能被 `split_size` 整除，则最后一个块将更小。
如果沿着给定维度 `dim` 的张量大小不能被 `split_size` 整除，则最后一个块将更小。

如果 :attr:`split_size_or_sections` 是一个列表，那么 :attr:`tensor` 将会被分割
将输入文本翻译为简体中文如下：

将输入文本分为 `len(split_size_or_sections)` 个大小在 `:attr:`dim` 中的块
到：`split_size_or_sections` 属性。

参数：
张量（Tensor）：要分割的张量。
单个块的大小或分块数（int）或（int 列表）：单个块的大小或分块数列表
每个块的大小列表
dim（int）：分割张量的维度。

示例::

        >>> a = torch.arange(10).reshape(5, 2)
        >>> a
        tensor([[0, 1],
                [2, 3],
                [4, 5],
[6, 7]
[8, 9]]
        >>> torch.split(a, 2)
        (tensor([[0, 1],
                 [2, 3]]),
         tensor([[4, 5],
                 [6, 7]]),
         tensor([[8, 9]]))
        >>> torch.split(a, [1, 4])
        (tensor([[0, 1]]),
         tensor([[2, 3],
                 [4, 5],
[6, 7]
[8, 9]
    """
    如果 has_torch_function_unary(张量):
        返回 handle_torch_function(
            分割, (张量,), 张量, 分割大小或部分, 维度=维度
        )
    # 覆盖原因：
    # 这将根据 split_size_or_sections 的类型调用两个 ATen 函数
    # 分支代码在 _tensor.py 中
    #请在此处调用。
    返回 张量.分割(分割大小或部分, 维度)



定义 einsum(*参数: 任何) -> 张量:
    r"einsum(equation, *operands) -> Tensor"

对输入 :attr:`operands` 的元素乘积沿指定维度求和。
基于爱因斯坦求和约定。

Einsum 允许通过表示来计算许多常见的多维线性代数数组操作。
以爱因斯坦求和约定为基础的简写格式，由：attr:`equation` 给出。该格式的详细信息如下，但基本思想是给输入的每个：attr:`operands` 维度标注一个下标，并定义哪些下标是输出的一部分。输出然后通过计算那些下标不属于输出的：attr:`operands` 元素沿维度的乘积之和来得到。
该格式的具体描述如下，但基本思想是给输入的每个：attr:`operands` 维度标注一个下标，并定义哪些下标是输出的一部分。
输出是通过计算那些下标不属于输出的：attr:`operands` 元素沿维度的乘积之和来得到的。
输出是通过计算那些下标不属于输出的：attr:`operands` 元素沿维度的乘积之和来得到的。
输出。例如，可以使用 einsum 计算矩阵乘法，如 `torch.einsum("ij,jk->ik", A, B)`。
其中，j 是求和下标，i 和 k 是输出下标（详见下文了解更多细节）。

公式：

attr:`equation` 字符串指定了每个维度的下标（字母 `[a-zA-Z]`）。
输入：attr:`operands`，按照维度顺序排列，每个操作数的下标用逗号（','）分隔
例如，`'ij,jk'`指定了两个二维操作数的下标。具有相同下标的维度必须是可广播的，也就是说，它们的大小必须匹配或为`1`。例外情况是，如果某个下标对于同一个输入操作数重复出现，在这种情况下，对于此操作数的该下标所标记的维度
必须是可广播的，即它们的大小必须匹配或为`1`。例外情况是如果某个下标对于同一个输入操作数重复出现，在这种情况下，对于此操作数的该下标所标记的维度
必须是可广播的，即它们的大小必须匹配或为`1`。例外情况是如果某个下标对于同一个输入操作数重复出现，在这种情况下，对于此操作数的该下标所标记的维度
必须大小匹配，操作数将被其对这些维度的对角线替换。
在 :attr:`equation` 中恰好出现一次的下标将包含在输出中，并按字母顺序升序排列。
输出是通过逐元素相乘输入的 :attr:`operands`，根据下标对齐维度，然后对不包含在输出中的维度进行求和计算得到的。
输出是通过逐元素相乘输入的 :attr:`operands`，根据下标对齐维度，然后对不包含在输出中的维度进行求和计算得到的。

可选地，输出下标可以显式定义，方法是在等式末尾添加箭头（'->'）
然后跟输出下标。例如，以下等式计算矩阵乘法的转置：'ij,jk->ki'。输出下标必须至少在某个输入操作数中出现一次，并且在输出中最多出现一次。
矩阵乘法：'ij,jk->ki'。输出下标必须至少在某个输入操作数中出现一次，并且在输出中最多出现一次。
输出下标必须至少在某个输入操作数中出现一次，并且在输出中最多出现一次。

省略号（'...'）可以用作下标，以表示省略号覆盖的维度。
每个输入操作数最多只能有一个省略号，它将覆盖下标未覆盖的维度，
例如，对于一个具有 5 个维度的输入操作数，方程 `'ab...c'` 中的省略号覆盖了第三和第四维度。
省略号不需要在所有操作数上覆盖相同数量的维度，但
省略号（它们覆盖的维度大小）的 'shape' 必须一起广播。如果输出没有明确地使用箭头 ('->') 符号定义，省略号将首先出现在输出中（最左侧的维度），
在出现一次的输入操作数的下标标签之前。例如，以下方程实现了批矩阵乘法 `'...ij,...jk'`。
在出现一次的输入操作数的下标标签之前。例如，以下方程实现了批矩阵乘法 `'...ij,...jk'`。
在出现一次的输入操作数的下标标签之前。例如，以下方程实现了批矩阵乘法 `'...ij,...jk'`。

一些最后的注意事项：该方程可能在不同元素（下标、省略号等）之间包含空格
箭头和逗号）但类似于 `'. . .'` 的格式是无效的。对于标量操作数，空字符串 `''` 是有效的。

.. 注意::

torch.einsum 处理省略号('...')的方式与 NumPy 不同，因为它允许维度
被省略号覆盖以进行求和，即省略号不需要成为输出的一部分。

.. 注意::

请安装 opt-einsum（https://optimized-einsum.readthedocs.io/en/stable/）以便加入更高效的 einstein 求和操作。
您可以在安装 torch 时安装它，如下所示：`pip install torch[opt-einsum]`，或者单独安装。
使用`pip install opt-einsum`进行安装。

如果 opt-einsum 可用，此函数将自动加速计算并/或减少内存消耗。
通过通过我们的 opt_einsum 后端优化收缩顺序：mod:`torch.backends.opt_einsum`（_与-之间的区别，我知道，很令人困惑）。当至少有三个输入时，才会发生这种优化，因为顺序并不重要
注意，找到`最优`路径是一个 NP 难题，因此，opt-einsum 依赖于不同的启发式方法来获得近似最优结果。如果 opt-einsum 不可用，则默认的顺序是收缩
。请注意，找到`最优`路径是一个 NP 难题，因此，opt-einsum 依赖于不同的启发式方法来获得近似最优结果。如果 opt-einsum 不可用，则默认的顺序是收缩
。如果 opt-einsum 不可用，则默认的顺序是收缩
从左到右。

要绕过此默认行为，请添加以下内容以禁用 opt_einsum 并跳过路径计算：
        ``torch.backends.opt_einsum.enabled = False``

要指定 opt_einsum 计算收缩路径的策略，请添加以下行：
``torch.backends.opt_einsum.strategy = 'auto'`` 默认策略为 'auto'，同时我们也支持 'greedy' 和 'optimal'。
注意，'optimal' 的运行时间与输入数量呈阶乘关系！更多详情请参阅 opt_einsum 文档（https://optimized-einsum.readthedocs.io/en/stable/path_finding.html）。
截至 PyTorch 1.10，:func:`torch.einsum` 也支持子列表格式（以下有示例）。在此格式中，

.. 注意::

有关详细信息，请参阅 PyTorch 1.10 的 :func:`torch.einsum` 文档。
每个操作数的下标由子列表指定，子列表是范围在[0, 52)内的整数列表。这些子列表
跟随其操作数，并且输入末尾可以额外出现一个子列表来指定输出的下标，例如`torch.einsum(op1, sublist1, op2, sublist2, ..., [subslist_out])`。Python 的`Ellipsis`对象
可以在子列表中提供，以启用如上方程部分所述的广播。
提供在子列表中，以启用如上方程部分所述的广播。

参数：
方程（字符串）：爱因斯坦求和的子脚标。
操作数（张量列表）：计算爱因斯坦求和的张量。

示例：

>>> # xdoctest: +IGNORE_WANT("非确定性")
>>> # 跟踪
        >>> torch.einsum('ii', torch.randn(4, 4))
张量(-1.2104)

>>> # xdoctest: +IGNORE_WANT("非确定性")
>>> # 对角线
        >>> torch.einsum('ii->i', torch.randn(4, 4))
张量([-0.1034,  0.7952, -0.2433,  0.4545])

>>> # xdoctest: +IGNORE_WANT("非确定性")
>>> # 外积
        >>> x = torch.randn(5)
        >>> y = torch.randn(4)
        >>> torch.einsum('i,j->ij', x, y)
        tensor([[ 0.1156, -0.2897, -0.3918,  0.4963],
                [-0.3744,  0.9381,  1.2685, -1.6070],
                [ 0.7208, -1.8058, -2.4419,  3.0936],
                [ 0.1713, -0.4291, -0.5802,  0.7350],
[0.5704, -1.4290, -1.9323, 2.4480]])

>>> # xdoctest: +IGNORE_WANT("非确定性")
>>> # 批量矩阵乘法
        >>> As = torch.randn(3, 2, 5)
        >>> Bs = torch.randn(3, 5, 4)
        >>> torch.einsum('bij,bjk->bik', As, Bs)
tensor([[[[-1.0564, -1.5904,  3.2023,  3.1271],
[[-1.6706, -0.8097, -0.8025, -2.1183]]

[[4.2239, 0.3107, -0.5756, -0.2354]]
[[-1.4558, -0.3460, 1.5087, -0.8530]]

[[2.8153, 1.8787, -4.3839, -1.2112]]
[[0.3728, -2.1131, 0.0921, 0.8305]]])

>>> # xdoctest: +IGNORE_WANT("非确定性")
>>> # 使用子列表格式和省略号
        >>> torch.einsum(As, [..., 0, 1], Bs, [..., 1, 2], [..., 0, 2])
tensor([[[[-1.0564, -1.5904,  3.2023,  3.1271],
[[-1.6706, -0.8097, -0.8025, -2.1183]]

[[4.2239, 0.3107, -0.5756, -0.2354]]
[[-1.4558, -0.3460, 1.5087, -0.8530]]

[[2.8153, 1.8787, -4.3839, -1.2112]]
[[0.3728, -2.1131, 0.0921, 0.8305]]])

>>> # 批量排列
        >>> A = torch.randn(2, 3, 4, 5)
        >>> torch.einsum('...ij->...ji', A).shape
        torch.Size([2, 3, 5, 4])

>>> 等价于 torch.nn.functional.bilinear
        >>> A = torch.randn(3, 5, 4)
        >>> l = torch.randn(2, 5)
        >>> r = torch.randn(2, 4)
        >>> torch.einsum('bn,anm,bm->ba', l, A, r)
        tensor([[-0.3430, -5.2405,  0.4494],
                [ 0.3311,  5.5201, -3.0356]])
    """
    导入 torch.backends.opt_einsum as opt_einsum

    # 此包装器存在是为了支持可变参数。
    如果 长度(参数) < 2:
        抛出 值错误(
            "einsum()：必须指定方程字符串和至少一个操作数，"
            "至少一个操作数及其下标列表"
        )

    方程 = 无
    操作数 = 无

    如果 isinstance(参数[0] 火炬.张量):
        # 将操作数及其下标列表的交错格式转换为下标列表格式
        # 列表，末尾可选输出子脚标列表（更多详细信息请参阅文档）
        将方程字符串格式化为从下标列表创建方程字符串并分组
        将输入操作数放入一个 tensorlist（Tensor 列表）中。
        定义 解析下标(n: int) -> str:
            如果 n == 省略号:
                返回 "..."
            如果 n ≥ 0 和 n < 26:
                返回 chr(ord("A") + n)
            如果 n ≥ 26 和 n < 52:
                返回 chr(ord("一个") + n - 26)
            抛出 值错误(
                "einsum(): 索引列表中的索引不在有效范围 [0, 52) 内"
            )

        # 解析输入操作数的下标
        方程 = ",".连接(输入文本翻译为简体中文为："".连接(解析下标(s) 对于 s 进入 l) 对于 l 进入 参数[1::2])

        解析可选的输出下标（当参数数量为奇数时提供）
        如果 长度(参数) % 2 == 1:
            方程 += "→" + 输入文本翻译为简体中文为："".连接(解析下标(s) 对于 s 进入 参数[-1])
            操作数 = 参数[-1:2]
        否则:
            操作数 = 参数[::2]
    否则:
        方程 = 参数[0]
        操作数 = 参数[1]

    如果 有 torch 功能(操作数):
        返回 handle_torch_function(einsum, 操作数, 方程, *操作数)

    如果 长度(操作数) == 1 和 isinstance(操作数[0] (列表, 元组)):
        # 将操作数作为单个列表参数传递的旧接口
        _操作数 = 操作数[0]
        # 递归，如果操作数包含具有 torch 函数的值
        # 在原始实现中，此行被省略
        返回 einsum(方程, *操作数)

    如果 长度(操作数) <= 2 或者 not OptEinsum.启用:
        合同路径优化已进行 0 或 1 次
        或者用户已禁用使用 opt_einsum
        返回 _VF.einsum(方程, 操作数)  # 类型：忽略[已定义]

    路径 = 无
    如果 OptEinsum.是否可用():
        _opt_einsum = OptEinsum.get_opt_einsum()
        tupled_path = _opt_einsum.contract_path(
            方程, *操作数, 优化=OptEinsum.策略
        )]0]
        # 分发到 C++的扁平路径
        路径 = [*itertools.chain.from_iterable(tupled_path)]
    返回 _VF.einsum(方程, 操作数, 路径=路径)  # type: ignore[attr-defined]



# 此包装器存在是为了支持可变参数。
如果 类型检查:
    JIT 不理解联合类型，因此只为 mypy 添加类型注解。
    定义 网格(
        *张量: 联合[张量, 列表[张量]], 索引: 可选[str] = 无
    ) -> 元组[张量, ...]
        返回 网格(*张量, 索引=索引)

否则:

    定义 网格(*张量, 索引: 可选[str] = 无) -> 元组[张量, ...]
        r生成由`attr`:tensors 中的 1D 输入指定的坐标网格。

这在您想可视化某些数据时非常有用。
输入范围。以下为绘图示例。

给定 :math:`N` 个 1D 张量 :math:`T_0 \ldots T_{N-1}` 作为
输入，对应的大小为 :math:`S_0 \ldots S_{N-1}`，
这将创建 :math:`N` 个 N 维张量 :math:`G_0 \ldots
\( G_{N-1} \)，每个的形状为：\( (S_0, ..., S_{N-1}) \)
输出 \( G_i \) 通过展开 \( T_i \) 构建。
将结果扩展到结果形状。

.. 注意::
0 维输入等效于 1 维输入。
单个元素。

..警告：
`torch.meshgrid(*tensors)` 目前具有相同的行为
作为调用 `numpy.meshgrid(*arrays, indexing='ij')`。

未来 `torch.meshgrid` 将过渡到
默认为 `indexing='xy'`。

请参阅 https://github.com/pytorch/pytorch/issues/50276 跟踪。
本问题旨在迁移到 NumPy 的行为。

参考文献也请参阅。

`torch.cartesian_prod` 具有相同的效果，但它
收集数据到一个向量张量中。

参数：
张量（Tensor 列表）：标量或一维张量的列表。标量将被
自动视为大小为 :math:`(1,)` 的张量处理。

索引模式：(str, 可选): 索引模式，可以是 "xy" 或 "ij"，默认为 "ij"。有关未来更改的警告请参阅。
或者 "ij"，默认为 "ij"。有关未来更改的警告请参阅。

如果选择 "xy"，则第一个维度对应第二个输入的基数，第二个维度对应第三个输入的基数。
维度对应第三个输入的基数。
维度对应于第一个的基数
输入

如果选择“ij”，维度相同
输入的基数作为顺序。

返回值：
seq (序列)：如果输入有 :math:`N`
张量大小为：`S_0 ... S_{N-1}`，然后
输出也将包含：`N` 个张量，其中每个张量
是形状：`（S_0, ..., S_{N-1}）`。

示例::

            >>> x = torch.tensor([1, 2, 3])
            >>> y = torch.tensor([4, 5, 6])

观察网格中的逐元素配对，(1, 4)，
(1, 5)，...，（3，6）。这与笛卡尔积相同。
这是同一件事。
            >>> grid_x, grid_y = torch.meshgrid(x, y, indexing='ij')
            >>> grid_x
            tensor([[1, 1, 1],
                    [2, 2, 2],
[[3, 3, 3]]
            >>> grid_y
            tensor([[4, 5, 6],
[[4, 5, 6]]
[4, 5, 6]]]

当这些网格正确堆叠时，这种对应关系可以观察到。
堆叠得当。
            >>> torch.equal(torch.cat(tuple(torch.dstack([grid_x, grid_y]))),
torch.cartesian_prod(x, y) 的笛卡尔积
            True

`torch.meshgrid` 通常用于生成网格
用于绘图。
            >>> # xdoctest: +REQUIRES(module:matplotlib)
            >>> # xdoctest: +REQUIRES(env:DOCTEST_SHOW)
>>> 导入 matplotlib.pyplot 库
            >>> xs = torch.linspace(-5, 5, steps=100)
            >>> ys = torch.linspace(-5, 5, steps=100)
            >>> x, y = torch.meshgrid(xs, ys, indexing='xy')
            >>> z = torch.sin(torch.sqrt(x * x + y * y))
            >>> ax = plt.axes(projection='3d')
            >>> ax.plot_surface(x.numpy(), y.numpy(), z.numpy())
            >>> plt.show()

.. 图片:: ../_static/img/meshgrid.png
宽度: 512

        """
        返回 网格(*张量, 索引=索引)



定义 网格(*张量, 索引: 可选[str)]
    如果 有 torch 功能(张量):
        返回 handle_torch_function(网格, 张量, *张量, 索引=索引)
    如果 长度(张量) == 1 和 isinstance(张量[0] (列表, 元组)):
        # 将操作数作为单个列表参数传递的旧接口
        张量 = 张量[0]  # 类型：忽略[赋值]

    # 继续允许调用不带索引的老方法
    # 为向前兼容添加参数
    #
    # 在发布两周后删除此内容
    kwargs = {} 如果 索引 是 无 否则 {索引: 索引}
    返回 _VF.网格(张量, **关键字参数)  # 类型：忽略[已定义]


定义 stft(
    输入: 张量,
    n_fft: int,
    跳长: 可选[int] = 无,
    窗长: 可选[int] = 无,
    窗口: 可选[张量] = 无,
    中心: 布尔值 = True,
    填充模式: 字符串 = 反射,
    标准化: 布尔值 = False,
    单向的: 可选[bool] = 无,
    返回复杂: 可选[bool] = 无,
    与窗口对齐: 可选[bool] = 无,
) -> 张量:
    r短时傅里叶变换（STFT）。

..警告：
从版本 1.8.0 开始，:attr:`return_complex`必须始终提供
专门用于真实输入，且`return_complex=False`已被
已弃用。强烈建议使用 `return_complex=True`，如未来版本中所示
PyTorch 发布，此函数将仅返回复杂数组。

请注意：:func:`torch.view_as_real` 可以用于恢复实数
张量具有一个额外的最后一个维度，用于实部和虚部。

..警告::
从版本 2.1 开始，如果未指定 :attr:`window`，将提供警告。在未来版本中，此属性将是必需的。
如果未指定窗口，从版本 2.1 开始将提供警告。在未来版本中，此属性将成为必需项。
当前不提供窗口默认使用矩形窗口，
这可能会导致不希望出现的伪影。请考虑使用锥形窗口，
例如：:func:`torch.hann_window`。

STFT 计算短重叠窗口的傅里叶变换
输入. 这提供信号随时间变化的频率分量
时间。此功能界面模仿了（但并非*直接替换*）
替代 librosa_ stft 函数。

https://librosa.org/doc/latest/generated/librosa.stft.html

忽略可选的批量维度，此方法计算以下
表达式：

    .. math::
X[ω, m] = ∑_{k = 0}^{win_length-1}%
window[k] input[m × hop_length + k]%
\exp\left(- j \frac{2 \pi \cdot \omega k}{n_fft}\right),

其中 :math:`m` 是滑动窗口的索引，而 :math:`\omega` 是
频率：$0 \leq \omega < \text{n\_fft}$ 对于 `onesided=False`
或 $0 \leq \omega < \lfloor \text{n\_fft} / 2 \rfloor + 1$ 对于 `onesided=True`

* :attr:`input` 必须是 1-D 时间序列或 2-D 时间序列批
次

如果 :attr:`hop_length` 为 ``None``（默认），则视为等于
``floor(n_fft / 4)``。

如果 :attr:`win_length` 为 ``None``（默认），则视为等于
attr:`n_fft`。

* :attr:`window` 可以是一个大小为 :attr:`win_length` 的 1-D 张量，例如从
torch.hann_window。如果 :attr:`window` 是 ``None``（默认），则是
被视为窗口中到处都有：数学公式`1`。如果
`win_length < n_fft` 时，:attr:`window` 将被填充
在应用之前，对两边的长度进行：attr:`n_fft`。

如果：attr:`center` 为 ``True``（默认），则：attr:`input` 将被填充。
以便第：math:`t` 个帧在时间：math:`t \times \text{hop\_length}` 处居中。
否则，第：math:`t` 个帧。
开始时间为：:math:`t \times \text{hop\_length}`。

* :attr:`pad_mode` 决定了在 :attr:`input` 上使用的填充方法。
attr:`center` 为 ``True``。请参阅 :meth:`torch.nn.functional.pad` 了解所有可用选项。
默认为 ``"reflect"``。

如果 :attr:`onesided` 为 ``True``（实数输入的默认值），则只返回
math:`\omega` 在 :math:`\left[0, 1, 2, \dots, \left\lfloor
\frac{\text{n\_fft}}{2} \right\rfloor + 1\right]` 范围内的值，因为
实数到复数的傅里叶变换满足共轭对称性，
即，:math:`X[m, \omega] = X[m, \text{n\_fft} - \omega]^*`.
注意，如果输入或窗口张量是复数，则 :attr:`onesided`
输出不可行。

* 如果 :attr:`normalized` 为 ``True``（默认为 ``False``），则函数
返回归一化的 STFT 结果，即乘以 :math:`(frame\_length)^{-0.5}`。

* 如果 :attr:`return_complex` 为 ``True``（如果输入是复数则为默认值），则返回
是 ``input.dim() + 1`` 维的复数张量。如果 ``False``，则
输出是一个 ``input.dim() + 2`` 维的实数张量，其中最后一个
维度表示实部和虚部。

返回一个大小为 :math:`(* \times N \times T)` 的复杂张量
:attr:`return_complex` 为 true，或一个大小为 :math:`(* \times N` 的实张量
\( \times T \times 2) \)。其中，:math:`*` 是可选的批量大小。
输入：:attr:`input`, :math:`N` 是应用短时傅里叶变换的频率数量
翻译：输入：:attr:`input`，:math:`N` 是应用短时傅里叶变换的频率数
并且：`T` 是使用的总帧数。

..警告：
此函数在版本 0.4.1 中更改了签名。调用时使用
前一个签名可能引起错误或返回不正确的结果。

参数：
输入（张量）：形状为 `(B?, L)` 的输入张量，其中 `B?` 是可选的批处理维度
批处理维度
n_fft（整数）：傅里叶变换的大小
hop_length（整数，可选）：相邻滑动窗口之间的距离
帧数。默认值：``None``（视为等于 ``floor(n_fft / 4)``）
窗口长度（int，可选）：窗口帧和 STFT 滤波器的大小。
默认值：``None``（视为等于 :attr:`n_fft`）
窗口（Tensor，可选）：可选的窗口函数。
形状必须是 1 维且 `<= n_fft`
默认：`None`（视为全部为 1 秒的窗口）
center（布尔值，可选）：是否在`input`的两侧进行填充
以使得第`t`个帧在时间`t × hop_length`处居中。
默认：``True``
pad_mode（字符串，可选）：控制填充方法
attr:`center` 为 ``True``。默认：``"reflect"``
normalized（布尔值，可选）：控制是否返回归一化的 STFT 结果
默认：``False``
onesided（布尔值，可选）：控制是否返回结果的一半
避免对真实输入的冗余
默认：对于真实 :attr:`input` 和 :attr:`window`，为 ``True``，否则为 ``False``
返回复数张量（bool，可选）：是否返回复数张量，或
带有额外最后一个维度的实数张量。
用于实部和虚部。

.. 版本变更:: 2.0
``return_complex`` 现在对于真实输入是必须的参数，
因为默认值正在过渡到 ``True``。

.. 已弃用:: 2.0
``return_complex=False`` 已弃用，请使用 ``return_complex=True`` 代替
注意调用 :func:`torch.view_as_real` 对输出进行操作
可以恢复已弃用的输出格式。

返回值：
张量：包含 STFT 结果的张量，形状为`(B?, N, T, C?)`，其中
- `B?` 是从输入中可选的批处理维度。
`- N 是频率样本的数量，对于 n_fft // 2 + 1`
`onesided=True`，否则为 `n_fft`。
`- T 是帧数，对于 center=True，为 1 + L // hop_length`
`，否则为 1 + (L - n_fft) // hop_length`。
- `C?` 是一个可选的长度为 2 的实部和虚部维度
组件，当 `return_complex=False` 时存在。

    """
    如果 has_torch_function_unary(输入):
        返回 handle_torch_function(
            stft,
            (输入,),
            输入,
            n_fft,
            跳长=跳长,
            窗长=窗长,
            窗口=窗口,
            中心=中心,
            填充模式=填充模式,
            标准化=标准化,
            单向的=单向的,
            返回复杂=返回复杂,
            与窗口对齐=与窗口对齐,
        )
    如果 中心 和 窗口对齐 是 not 无:
        抛出 RuntimeError(
            "STFT 窗口对齐仅在 center 为 false 时设置"
        )
    # NOTE: Do not edit. This code will be removed once the forward-compatibility
    #       period is over for PR #73432
    如果 中心:
        信号维度 = 输入.维度()
        扩展形状 = [1] * (3 - 信号维度) + 列表(输入.尺寸())
        填充 = int(FFT 长度 // 2)
        输入 = F.填充(输入.视图(扩展形状), [填充, 填充] 填充模式)
        输入 = 输入.视图(输入.形状[-信号维度])
    返回 _VF.stft(  # 类型：忽略[已定义]
        输入,
        n_fft,
        跳长,
        窗长,
        窗口,
        标准化,
        单向的,
        返回复杂,
        与窗口对齐,
    )



双谱（Inverse Short-Time Fourier Transform） = _添加文档字符串(
    火炬.短时傅里叶变换,
    istft(input, n_fft, 跳长=None, 窗长=None, 窗口=None, center=True, )
    normalized=False, onesided=None, length=None, return_complex=False) -> 张量:输入文本翻译为简体中文为：\n"
    r""
逆短时傅里叶变换。这应该与 :func:`~torch.stft` 的逆运算相对应。

.. 警告::
从版本 2.1 开始，如果未指定 :attr:`window`，将提供警告。在未来版本中，此属性将是必需的。
如果未指定窗口，从版本 2.1 开始将提供警告。在未来版本中，此属性将成为必需项。
请提供与 stft 调用中使用的相同窗口。

它具有相同的参数（+可选参数：attr:`length`）并且应该返回
原始信号的平方最小二乘估计。算法将使用 NOLA 条件（
非零重叠）进行检查。

重要参数：attr:`窗口`和：attr:`中心`的考虑，以确保所有窗口的求和在某个时间点永远不会为零。
具体来说，求和：math:`\sum_{t=-\infty}^{\infty} |w|^2[n-t\times hop\_length] \cancel{=} 0`。
由于：func:`~torch.stft`在信号末尾元素无法适应帧时将丢弃这些元素，因此，

信号帧的长度为：func:`~torch.stft`的长度。
``istft`` 可能返回比原始信号更短的信号（如果 :attr:`center` 为 False 的话可能会发生）
由于信号没有填充）。如果 `length` 在参数中给出并且比预期更长，
``istft`` 将会在返回的信号末尾填充零。

如果 :attr:`center` 为 ``True``，则会有填充，例如 ``'constant'``、``'reflect'`` 等。
左侧填充可以精确地被移除，因为它们可以计算出来，但右侧填充不能，因为没有额外的信息可以计算。
可以计算出来，无需额外信息。

例如：假设最后一个窗口是：
``[17, 18, 0, 0, 0]`` 与 ``[18, 0, 0, 0, 0]``

`:attr:`n_fft`、:attr:`hop_length`、:attr:`win_length` 都相同，这阻止了计算
右侧填充。这些额外值可以是零或信号的反射，因此提供
`:attr:`length` 可能很有用。如果 :attr:`length` 是 `None`，则将积极移除填充
（信号有一定损失）。

[1] D. W. Griffin 和 J. S. Lim, "从修改后的短时傅里叶变换中估计信号,"
IEEE 信号处理汇刊，第 32 卷，第 2 期，第 236-243 页，1984 年 4 月。

参数：
输入（张量）：输入张量。期望格式为 :func:`~torch.stft`，
输出。这是一个形状为 `(B?, N, T)` 的复数张量，

- `B?` 是可选的批量维度
- `N` 是频率样本的数量，`(n_fft // 2) + 1`
对于单边输入，否则 `n_fft`
- `T` 是帧数，对于中心化 STFT，为 `1 + length // hop_length`
或 `1 + (长度 - n_fft) // 跳长` 否则。

.. 版本变更:: 2.0
实数数据类型输入不再受支持。输入必须现在具有
复数数据类型，如 ``stft(..., return_complex=True)`` 返回的。
n_fft (int): 傅里叶变换的大小
hop_length (Optional[int]): 相邻滑动窗口帧之间的距离。
        (Default: ``n_fft // 4``)
win_length (Optional[int]): 窗口帧的大小和 STFT 滤波器。 (Default: ``n_fft``)
窗口（Optional[torch.Tensor]）：可选的窗口函数。
形状必须是 1 维且 `<= n_fft`
（默认：``torch.ones(win_length)``）
center（布尔值）：是否对：attr:`input` 进行了两侧填充，以便使：math:`t`-th 帧的
中心位于时间：`t × hop_length`。
（默认：`True`）
标准化（布尔值）：STFT 是否进行了标准化。（默认：`False`）
单边（可选[布尔值]）：STFT 是否为单边。
（默认情况下，如果输入大小中的 `n_fft` 不等于 `fft_size`，则为 `True`）
长度（可选[int]）：通过信号的数量（即，）
原始信号长度）。默认为`(T - 1) * hop_length`。
居中对齐 STFT，或`n_fft + (T - 1) * hop_length`，其中`T`
输入帧的数量。
return_complex（可选[bool]）：
输出是否应为复数，或者输入是否应
假设来自实信号和窗口。
注意这与 `onesided=True` 不兼容。
（默认：`False`）

返回：
张量：原始信号的平方最小二乘估计，形状为 `(B?, length)`。
`B?` 是输入张量中的一个可选批处理维度。
""",
)


如果 类型检查:
    这些 _impl 函数返回可变数量的张量作为输出，
    # __torch_function__; 已经完成了元组拆包，而不是进行
    # 由 _impl 函数的调用者完成
    _unique_impl_out = 任何
否则:
    _unique_impl_out = 元组[张量, 张量, 张量]


定义 _唯一实现(
    输入: 张量,
    排序: 布尔值 = True,
    返回反向: 布尔值 = False,
    返回计数: 布尔值 = False,
    维度: 可选[int] = 无,
) -> _unique_impl_out:
    runique(input, sorted=True, return_inverse=False, return_counts=False, dim=None) -> tuple[Tensor, Tensor, Tensor]

返回输入张量中的唯一元素。

.. note:: 此函数与 :func:`torch.unique_consecutive` 不同之处在于
此函数还会消除非连续重复值。

.. 注意:: 目前在 CUDA 实现和 CPU 实现中，
`torch.unique` 总是在开始时对张量进行排序，无论 `sort` 参数如何。
排序可能会很慢，因此如果您的输入张量已经排序，建议使用
func:`torch.unique_consecutive`，它避免了排序。

参数：
输入（张量）：输入张量
排序（布尔值）：是否按升序排序唯一元素
在返回输出之前。
返回_inverse（布尔值）：是否还返回索引，表示
原始输入中的元素最终出现在返回的唯一列表中。
return_counts (bool): 是否同时返回每个唯一元素的计数
            element.
dim (int, 可选): 要操作的维度。如果 ``None``，则表示使用当前维度。
返回展平输入的唯一值。否则，返回每个值。
张量按给定维度索引被视为一个
要应用唯一操作的元素。请参阅示例以获取更多信息
详细信息。默认值：``None``

返回值：
(Tensor, Tensor (可选), Tensor (可选)): 包含张量或张量元组的张量

- **输出** (*Tensor*): 唯一标量元素的输出列表
- **inverse_indices** (*Tensor*): (可选) 如果
attr:`return_inverse` 为 True，则将有一个额外的
返回与输入相同形状的索引张量
表示原始输入中的元素映射到输出中的位置；
否则，此函数将仅返回一个张量。
- **counts** (*张量*)：可选的，如果
当 `return_counts` 为 True 时，将返回一个额外的
张量（与输出或 output.size(dim) 相同的形状，
如果指定了 dim）表示每个唯一值或张量的出现次数
。

示例::

        >>> output = torch.unique(torch.tensor([1, 3, 2, 3], dtype=torch.long))
        >>> output
        tensor([1, 2, 3])

>>> 输出，逆索引 = torch.unique(
        ...     torch.tensor([1, 3, 2, 3], dtype=torch.long), sorted=True, return_inverse=True)
        >>> output
        tensor([1, 2, 3])
        >>> inverse_indices
        tensor([0, 2, 1, 2])

>>> 输出，逆索引 = torch.unique(
        ...     torch.tensor([[1, 3], [2, 3]], dtype=torch.long), sorted=True, return_inverse=True)
        >>> output
        tensor([1, 2, 3])
        >>> inverse_indices
        tensor([[0, 2],
[[1, 2]]]

        >>> a = torch.tensor([
        ...     [
        ...         [1, 1, 0, 0],
        ...         [1, 1, 0, 0],
        ...         [0, 0, 1, 1],
        ...     ],
        ...     [
[0, 0, 1, 1]
[0, 0, 1, 1]
[1, 1, 1, 1]
]
...
...[1, 1, 0, 0]
...[1, 1, 0, 0]
...[0, 0, 1, 1]
...
...

>>> 如果我们调用 `torch.unique(a, dim=0)`，每个张量 `a[idx, :, :]` 都将被比较。我们可以看到 `a[0, :, :]` 和 `a[2, :, :]` 是匹配的
>>> 将会进行比较。我们可以看到 `a[0, :, :]` 和 `a[2, :, :]` 匹配
>>> # 每个都会被删除，所以其中一个将被移除。
        >>> (a[0, :, :] == a[2, :, :]).all()
        tensor(True)
        >>> a_unique_dim0 = torch.unique(a, dim=0)
        >>> a_unique_dim0
        tensor([[[0, 0, 1, 1],
                 [0, 0, 1, 1],
                 [1, 1, 1, 1]],
                [[1, 1, 0, 0],
                 [1, 1, 0, 0],
[0, 0, 1, 1]]

>>> # 注意哪些子张量从 `a` 与子张量从
        >>> # `a_unique_dim0`:
        >>> (a_unique_dim0[0, :, :] == a[1, :, :]).all()
        tensor(True)
        >>> (a_unique_dim0[1, :, :] == a[0, :, :]).all()
        tensor(True)

>>> 对于 `torch.unique(a, dim=1)`，每个张量 `a[:, idx, :]` 都会被比较。
>>> `a[:, 0, :]` 和 `a[:, 1, :]` 相匹配，所以其中一个将被移除。
>>>
        >>> (a[:, 0, :] == a[:, 1, :]).all()
        tensor(True)
        >>> torch.unique(a, dim=1)
        tensor([[[0, 0, 1, 1],
[[1, 1, 0, 0]]
[[1, 1, 1, 1]]
[[0, 0, 1, 1]]
[[0, 0, 1, 1]]
                 [1, 1, 0, 0]]])

对于 `torch.unique(a, dim=2)`，张量 `a[:, :, idx]` 进行比较。
`a[:, :, 0]` 和 `a[:, :, 1]` 相匹配。同时，`a[:, :, 2]` 和
>>> `a[:, :, 3]`彼此匹配得也很好。所以在这种情况下，两个中的
>>> # 将移除子张量。
        >>> (a[:, :, 0] == a[:, :, 1]).all()
        tensor(True)
        >>> (a[:, :, 2] == a[:, :, 3]).all()
        tensor(True)
        >>> torch.unique(a, dim=2)
        tensor([[[0, 1],
                 [0, 1],
[1, 0]
[[1, 0]]
[1, 0]
[1, 1]
[[0, 1]]
[[0, 1]]
[[1, 0]]
    """
    如果 has_torch_function_unary(输入):
        返回 handle_torch_function(
            独特,
            (输入,),
            输入,
            排序=排序,
            返回反向=返回反向,
            返回计数=返回计数,
            维度=维度,
        )

    如果 维度 是 not 无:
        输出, 反向索引, 计数 = _VF.独特维度(
            输入,
            维度,
            排序=排序,
            返回反向=返回反向,
            返回计数=返回计数,
        )
    否则:
        输出, 反向索引, 计数 = 火炬._unique2(
            输入,
            排序=排序,
            返回反向=返回反向,
            返回计数=返回计数,
        )
    返回 输出, 反向索引, 计数


定义 _唯一连续实现(
    输入: 张量,
    返回反向: 布尔值 = False,
    返回计数: 布尔值 = False,
    维度: 可选[int] = 无,
) -> 唯一实现输出:
    r消除每个连续等效元素组中除第一个元素之外的所有元素。

.. 注意:: 此函数与 :func:`torch.unique` 在意义上有所不同
仅消除连续重复的值。此语义类似于 `std::unique`
在 C++中

参数：
输入（张量）：输入张量
return_inverse (bool): 是否同时返回原始输入中元素在返回的唯一列表中的索引
            elements in the original input ended up in the returned unique list.
return_counts (bool): 是否同时返回每个唯一元素的计数
            element.
dim (int): 应用唯一的维度。如果为 ``None``，则返回展平输入的唯一值。默认：``None``
default: ``None``

返回值：
(Tensor, Tensor (可选), Tensor (可选)): 包含张量或张量元组的张量

- **输出** (*Tensor*): 唯一标量元素的输出列表
- **inverse_indices** (*Tensor*): (可选) 如果
attr:`return_inverse` 为 True，则将有一个额外的
返回与输入相同形状的索引张量
表示原始输入中的元素映射到输出中的位置；
否则，此函数将仅返回一个张量。
- **counts** (*张量*)：可选的，如果
当 `return_counts` 为 True 时，将返回一个额外的
张量（与输出或 output.size(dim) 相同的形状，
如果指定了 dim）表示每个唯一值或张量的出现次数
。

示例::

        >>> x = torch.tensor([1, 1, 2, 2, 3, 1, 1, 2])
        >>> output = torch.unique_consecutive(x)
        >>> output
        tensor([1, 2, 3, 1, 2])

        >>> output, inverse_indices = torch.unique_consecutive(x, return_inverse=True)
        >>> output
        tensor([1, 2, 3, 1, 2])
        >>> inverse_indices
        tensor([0, 0, 1, 1, 2, 3, 3, 4])

        >>> output, counts = torch.unique_consecutive(x, return_counts=True)
        >>> output
        tensor([1, 2, 3, 1, 2])
>>> 计数
        tensor([2, 2, 1, 2, 1])
    """
    如果 has_torch_function_unary(输入):
        返回 handle_torch_function(
            唯一连续,
            (输入,),
            输入,
            返回反向=返回反向,
            返回计数=返回计数,
            维度=维度,
        )
    输出, 反向索引, 计数 = _VF.唯一连续(  # 类型：忽略[已定义]
        输入, 返回反向=返回反向, 返回计数=返回计数, 维度=维度
    )
    返回 输出, 反向索引, 计数


定义 返回计数(
    输入,
    排序=True,
    返回反向=False,
    返回计数=False,
    维度=无,
):
    (Tensor, bool, bool, bool, Optional[int]) -> tuple[Tensor, Tensor]

    如果 has_torch_function_unary(输入):
        返回 _唯一实现(输入, 排序, 返回反向, 返回计数, 维度)

    输出, _, 计数 = _唯一实现(输入, 排序, 返回反向, 返回计数, 维度)
    返回 输出, 计数


定义 _返回输出(
    输入,
    排序=True,
    返回反向=False,
    返回计数=False,
    维度=无,
):
    # 类型: (张量, 布尔值, 布尔值, 布尔值, 可选[int]) -> 张量

    如果 has_torch_function_unary(输入):
        返回 _唯一实现(输入, 排序, 返回反向, 返回计数, 维度)

    输出, _, _ = _唯一实现(输入, 排序, 返回反向, 返回计数, 维度)
    返回 输出


定义 返回逆序(
    输入,
    排序=True,
    返回反向=False,
    返回计数=False,
    维度=无,
):
    (Tensor, bool, bool, bool, Optional[int]) -> tuple[Tensor, Tensor]

    如果 has_torch_function_unary(输入):
        返回 _唯一实现(输入, 排序, 返回反向, 返回计数, 维度)

    输出, 反向索引, _ = _唯一实现(
        输入, 排序, 返回反向, 返回计数, 维度
    )
    返回 输出, 反向索引


_返回逆序为假 = 布尔分发(
    参数名称="返回计数",
    索引参数=3,
    默认=False,
    如果为真=返回计数,
    如果为假=_返回输出,
    模块名称=__name__,
    函数名="唯一",
)

返回逆序真 = 布尔分发(
    参数名称="返回计数",
    索引参数=3,
    默认=False,
    如果为真=_唯一实现,
    如果为假=返回逆序,
    模块名称=__name__,
    函数名="唯一",
)

# unique 的返回类型取决于`return_inverse`和`return_counts`，因此为了
# 在 TorchScript 中解决输出类型，我们需要静态地知道这两个参数的值

唯一的 = 布尔分发(
    参数名称=返回逆序,
    索引参数=2,
    默认=False,
    如果为真=_返回逆序为真,
    如果为假=_return_inverse_false,
    模块名称=__name__,
    函数名="唯一",
)
独特.__文档__ = _唯一实现.__文档__


定义 _连续返回计数(
    输入,
    返回反向=False,
    返回计数=False,
    维度=无,
):
    # 类型: (Tensor, bool, bool, Optional[int]) -> tuple[Tensor, Tensor]

    如果 has_torch_function_unary(输入):
        返回 _唯一连续实现(输入, 返回反向, 返回计数, 维度)

    输出, _, 计数 = _唯一连续实现(
        输入, 返回反向, 返回计数, 维度
    )
    返回 输出, 计数


定义 连续返回输出(
    输入,
    返回反向=False,
    返回计数=False,
    维度=无,
):
    (张量，布尔值，布尔值，可选[int]) -> 张量

    如果 has_torch_function_unary(输入):
        返回 _唯一连续实现(输入, 返回反向, 返回计数, 维度)

    输出, _, _ = _唯一连续实现(输入, 返回反向, 返回计数, 维度)
    返回 输出


定义 _连续返回倒数(
    输入,
    返回反向=False,
    返回计数=False,
    维度=无,
):
    # 类型: (Tensor, bool, bool, Optional[int]) -> tuple[Tensor, Tensor]

    如果 has_torch_function_unary(输入):
        返回 _唯一连续实现(输入, 返回反向, 返回计数, 维度)

    输出, 反向索引, _ = _唯一连续实现(
        输入, 返回反向, 返回计数, 维度
    )
    返回 输出, 反向索引


连续返回逆序为假 = 布尔分发(
    参数名称="返回计数",
    索引参数=1,
    默认=False,
    如果为真=_连续返回计数,
    如果为假=连续返回输出,
    模块名称=__name__,
    函数名=独特连续,
)

_连续返回逆真 = 布尔分发(
    参数名称="返回计数",
    索引参数=1,
    默认=False,
    如果为真=_唯一连续实现,
    如果为假=_连续返回倒数,
    模块名称=__name__,
    函数名=独特连续,
)

# unique 的返回类型取决于`return_inverse`和`return_counts`，因此为了
# 在 TorchScript 中解决输出类型，我们需要静态地知道这两个参数的值

独一无二连续 = 布尔分发(
    参数名称=返回逆序,
    索引参数=2,
    默认=False,
    如果为真=_连续返回逆真,
    如果为假=_连续返回逆序为假,
    模块名称=__name__,
    函数名=独特连续,
)
唯一连续.__文档__ = _唯一连续实现.__文档__

如果 类型检查:
    通过
    没有好的方法使用这种类型注解而不破坏即时编译（JIT）
    因此，为了 mypy 现在留为未类型化
否则:

    @overload
    定义 tensordot(
        a,
        b,
        维数: 整型 = 2,
        出: 可选[火炬.张量] = 无,
    ):
        通过

    @overload
    定义 tensordot(  # noqa: F811
        a,
        b,
        维数: 元组[列表[int] 列表[int]],
        出: 可选[火炬.张量] = 无,
    ):
        通过

    @overload
    定义 tensordot(  # noqa: F811
        a,
        b,
        维数: 列表[列表[int]],
        出: 可选[火炬.张量] = 无,
    ):
        通过

    @overload
    定义 tensordot(  # noqa: F811
        a,
        b,
        维数: 火炬.张量,
        出: 可选[火炬.张量] = 无,
    ):
        通过


定义 tensordot(  # noqa: F811
    a,
    b,
    维数=2,
    出: 可选[火炬.张量] = 无,
):
    r在多个维度上返回 a 和 b 的收缩

attr:`tensordot` 实现了广义矩阵乘法。

参数：
a (张量): 要收缩的左张量
b (张量): 要收缩的右张量
dims（int 或包含两个列表或列表的元组或列表列表的 Tensor）：维度数
合约或显式列表维度用于：attr:`a`和
attr:`b`分别

当使用非负整数参数：attr:`dims` = :math:`d`时，
a 和 b 的维度数分别为 m 和 n，
分别，:func:`~torch.tensordot` 函数计算

    .. math::
        r_{i_0,...,i_{m-d}, i_d,...,i_n}
          = \sum_{k_0,...,k_{d-1}} a_{i_0,...,i_{m-d},k_0,...,k_{d-1}} \times b_{k_0,...,k_{d-1}, i_d,...,i_n}.

当以列表形式的 :attr:`dims` 调用时，将给出的大小将替代 :attr:`a` 的最后 :math:`d` 个和 :attr:`b` 的前 :math:`d` 个。
在这些维度中大小必须匹配，但 :func:`~torch.tensordot` 将处理广播。
这些维度中大小必须匹配，但 :func:`~torch.tensordot` 将处理广播。
尺寸。

示例：

        >>> a = torch.arange(60.).reshape(3, 4, 5)
        >>> b = torch.arange(24.).reshape(4, 3, 2)
        >>> torch.tensordot(a, b, dims=([1, 0], [0, 1]))
        tensor([[4400., 4730.],
                [4532., 4874.],
                [4664., 5018.],
[4796., 5162.]
[4928., 5306.]

        >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_CUDA)
        >>> a = torch.randn(3, 4, 5, device='cuda')
        >>> b = torch.randn(4, 5, 6, device='cuda')
        >>> c = torch.tensordot(a, b, dims=2).cpu()
        tensor([[ 8.3504, -2.5436,  6.2922,  2.7556, -1.0732,  3.2741],
                [ 3.3161,  0.0704,  5.0187, -0.4079, -4.3126,  4.8744],
[0.8223, 3.9445, 3.2168, -0.2400, 3.4117, 1.7780]]

        >>> a = torch.randn(3, 5, 4, 6)
        >>> b = torch.randn(6, 4, 5, 3)
        >>> torch.tensordot(a, b, dims=([2, 1, 3], [1, 2, 0]))
        tensor([[  7.7193,  -2.4867, -10.3204],
                [  1.5513, -14.4737,  -6.5113],
                [ -0.2850,   4.2573,  -3.5997]])
    """
    如果 has_torch_function_variadic(a, b):
        返回 handle_torch_function(tensordot, (a, b), a, b, 维数=维数, 出=出)

    如果 不 isinstance(维数, (元组, 列表, 火炬.张量, int, 火炬.SymInt)):
        抛出 RuntimeError(
            "tensordot 期望维度为 int 或"
            + "tuple[列表[int], 列表[int]]或"
            + "包含两个列表的 list[list[int]]，但得到"
            + f"dims="{维数}"
        )

    次元_a: 列表[int] = 输入文本为空，请提供需要翻译的文本
    次元_b: 列表[int] = 输入文本为空，请提供需要翻译的文本

    如果 isinstance(维数, (元组, 列表)):
        次元_a, 模块_b = dims

    如果 isinstance(维数, 火炬.张量):
        元素数量 = 维数.元素数量()
        如果 元素数量 > 1:
            断言 维数.尺寸()[0] == 2
            dims_a = 火炬.算子.标注(列表[int] 维数[0].转列表())
            模块_b = 火炬.算子.标注(列表[int] 维数[1].转列表())
        否则:
            dims_val = int(维数.项目())
            如果 dims_val < 0:
                抛出 RuntimeError(f"tensordot 期望 dims >= 0，但得到 dims="{维数}")
            dims_a = 列表(范围(-dims_val, 0))
            dims_b = 列表(范围(dims_val))

    如果 isinstance(维数, (int, 火炬.SymInt)):
        如果 dims < 0:
            抛出 RuntimeError(f"tensordot 期望 dims >= 0，但得到 dims="{维数}")
        如果 dims > 最小值(a.维度(), b.维度()):
            抛出 运行时错误(
                ftensordot 期望维度小于 ndim_a 或 ndim_b，但得到了维度={维数}"
            )
        dims_a = 列表(范围(-维数, 0))
        模块_b = 列表(范围(维数))

    如果 外部 是 无:
        返回 _VF.tensordot(a, b, 次元_a, 次元_b)  # 类型：忽略[已定义]
    否则:
        返回 _VF.tensordot(a, b, 次元_a, 次元_b, 输出=出)  # type: ignore[attr-defined]



[docs]def 笛卡尔积(*tensors: Tensor) -> Tensor:
"""对给定的张量序列进行笛卡尔积。其行为类似于
Python 的`itertools.product`。

Args:
*张量：任意数量的 1 维张量。

返回：
张量：将所有输入张量转换为列表的等价张量，
然后对这些列表执行 `itertools.product`，最后将结果列表转换为
转换为张量。

示例::

>>> 导入 itertools
>>> a = [1, 2, 3]
>>> b = [4, 5]
>>> list(itertools.product(a, b))
[(1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)]
>>> tensor_a = torch.tensor(a)
>>> tensor_b = torch.tensor(b)
>>> torch.cartesian_prod(tensor_a, tensor_b)
tensor([[1, 4],
[1, 5],
[2, 4]
[2, 5]
[3, 4]
[3, 5]
"""
# 此包装器存在以支持可变参数。
if has_torch_function(tensors):
return handle_torch_function(cartesian_prod, tensors, *tensors)
return _VF.cartesian_prod(tensors)  # 忽略未定义的属性


[文档]def block_diag(*tensors):
创建由提供的张量组成的分块对角矩阵。

Args:
张量：一个或多个具有 0、1 或 2 维度的张量。

返回：
张量：一个二维张量，其中所有输入张量按顺序排列
按顺序排列，使它们的左上角和右下角
对角相邻。其他所有元素设置为 0。

示例::

>>> 导入 torch
>>> A = torch.tensor([[0, 1], [1, 0]])
>>> B = torch.tensor([[3, 4, 5], [6, 7, 8]])
>>> C = torch.tensor(7)
>>> D = torch.tensor([1, 2, 3])
>>> E = torch.tensor([[4], [5], [6]])
>>> torch.block_diag(A, B, C, D, E)
tensor([[0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 3, 4, 5, 0, 0, 0, 0, 0],
[0, 0, 6, 7, 8, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 7, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 1, 2, 3, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 4]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 5]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 6]
""
# This wrapper exists to support variadic args.
if has_torch_function(tensors):
return handle_torch_function(block_diag, tensors, *tensors)
return torch._C._VariableFunctions.block_diag(tensors)  # type: ignore[attr-defined]


定义 cdist(x1, x2, p=2.0, 计算模式="如有必要，使用 mm 计算欧几里得距离"):
    # 类型：(Tensor, Tensor, float, str) -> (Tensor)
    r"计算两个行向量集合中每对之间的 p 范数距离。"

参数：
x1 (Tensor)：形状为 :math:`B \times P \times M` 的输入张量。
x2 (Tensor)：输入张量，形状为 :math:`B \times R \times M`。
p：计算每个向量对之间的 p-范数距离的 p 值
math:`\in [0, \infty]`。
compute_mode：
'当需要时使用矩阵乘法计算欧几里得距离（p = 2）如果 P > 25 或 R > 25'
欧几里得距离（p = 2）
'始终使用矩阵乘法计算欧几里得距离（p = 2）'
欧几里得距离（p = 2）
不使用 mm 计算欧几里得距离
欧几里得距离（p = 2）
默认：如果需要，则使用毫米计算欧几里得距离。

如果 x1 的形状为 :math:`B \times P \times M`，而 x2 的形状为 :math:`B \times R \times M`，那么：
输出将具有形状：`B × P × R`。

此函数等价于 `scipy.spatial.distance.cdist(input,'minkowski', p=p)`。
当 :math:`p ∈ (0, ∞)` 时。当 :math:`p = 0` 时，它等价于
`scipy.spatial.distance.cdist(input, 'hamming') * M`。当 :math:`p = ∞` 时，最近的
scipy 函数是`scipy.spatial.distance.cdist(xn, lambda x, y: np.abs(x - y).max())`。

示例：

        >>> a = torch.tensor([[0.9041, 0.0196], [-0.3108, -2.4423], [-0.4821, 1.059]])
        >>> a
        tensor([[ 0.9041,  0.0196],
[-0.3108, -2.4423]
[-0.4821, 1.0590]
        >>> b = torch.tensor([[-2.1763, -0.4713], [-0.6986, 1.3702]])
        >>> b
        tensor([[-2.1763, -0.4713],
                [-0.6986,  1.3702]])
        >>> torch.cdist(a, b, p=2)
        tensor([[3.1193, 2.0959],
[2.7138, 3.8322]
[2.2830, 0.3791]
    """
    如果 has_torch_function_variadic(x1, x2):
        返回 handle_torch_function(
            cdist, (x1, x2), x1, x2, p=p, 计算模式=计算模式
        )
    如果 计算模式 == "如有必要，使用 mm 计算欧几里得距离":
        返回 _VF.cdist(x1, x2, p, 无)  # 类型：忽略[已定义]
    elif 计算模式 == 使用 mm 计算欧几里得距离:
        返回 _VF.cdist(x1, x2, p, 1)  # 类型：忽略[已定义]
    elif 计算模式 == 不使用 mm 计算欧几里得距离:
        返回 _VF.cdist(x1, x2, p, 2)  # 类型：忽略[已定义]
    否则:
        抛出 值错误(f"{计算模式}"compute_mode"不是一个有效的值)



[文档]def 至少_1d(*tensors):
r"""
返回每个输入张量的 1 维视图，其中零维为 0。
输入张量如果有一维或多维，则按原样返回。

Args:
输入 (Tensor 或 Tensor 列表)

返回:
输出 (Tensor 或 Tensor 元组)

示例::

>>> x = torch.arange(2)
>>> x
tensor([0, 1])
>>> torch.atleast_1d(x)
tensor([0, 1])
>>> x = torch.tensor(1.)
>>> x
tensor(1.)
>>> torch.atleast_1d(x)
tensor([1.])
>>> x = torch.tensor(0.5)
>>> y = torch.tensor(1.)
>>> torch.atleast_1d((x, y))
(tensor([0.5000]), tensor([1.]))
"""
# This wrapper exists to support variadic args.
如果有 torch_function(tensors):
返回 handle_torch_function(atleast_1d, tensors, *tensors)
如果 tensors 的长度等于 1:
tensors = tensors[0]
return _VF.atleast_1d(tensors)  # type: ignore[attr-defined]


[文档]def 至少_2d(*tensors):
r"""
返回每个输入张量的二维视图，零维度的张量保持不变。
输入张量如果有两个或更多维度，则直接返回。

Args:
输入 (Tensor 或 Tensor 列表)

返回:
输出 (Tensor 或 Tensor 元组)

示例::

>>> x = torch.tensor(1.)
>>> x
tensor(1.)
>>> torch.atleast_2d(x)
>>> tensor([[1.]])
>>> x = torch.arange(4).view(2, 2)
>>> x
tensor([[0, 1],
[2, 3]])
>>> torch.atleast_2d(x)
tensor([[0, 1],
[2, 3]]
>>> x = torch.tensor(0.5)
>>> y = torch.tensor(1.)
>>> torch.atleast_2d((x, y))
(tensor([[0.5000]]), tensor([[1.]]))
"""
# 此包装器存在以支持可变参数。
if has_torch_function(tensors):
return handle_torch_function(atleast_2d, tensors, *tensors)
if len(tensors) == 1:
tensors = tensors[0]
return _VF.atleast_2d(tensors)  # type: ignore[attr-defined]


[文档]def 至少_3d(*tensors):
r"""
返回每个输入张量的 3 维视图，零维不变。
输入张量具有三个或更多维度时，将按原样返回。

Args:
输入 (Tensor 或 Tensor 列表)

返回:
输出 (Tensor 或 Tensor 元组)

示例：

>>> x = torch.tensor(0.5)
>>> x
tensor(0.5000)
>>> torch.atleast_3d(x)
tensor([[[0.5000]]])
>>> y = torch.arange(4).view(2, 2)
>>> y
tensor([[0, 1],
])
[2, 3]])
>>> torch.atleast_3d(y)
tensor([[[0],
])
[1]]
空白行
[2]
[3]]])
>>> x = torch.tensor(1).view(1, 1, 1)
>>> x
tensor([[[1]]])
>>> torch.atleast_3d(x)
tensor([[[1]]])
>>> x = torch.tensor(0.5)
>>> y = torch.tensor(1.0)
>>> torch.atleast_3d((x, y))
(tensor([[[0.5000]]]), tensor([[[1.]]]))
"""
# 此包装器存在以支持可变参数。
if has_torch_function(tensors):
return handle_torch_function(atleast_3d, tensors, *tensors)
if len(tensors) == 1:
tensors = tensors[0]
return _VF.atleast_3d(tensors)  # type: ignore[attr-defined]


如果 类型检查:
    通过
    没有好的方法使用这个类型注解；无法将 norm()重命名为
    # _norm_impl() 的实现方式不会破坏 JIT 重载。所以保持未类型化
    # 目前用于 mypy。
    #    def norm(输入: Tensor,
    #             p: 可选[Union[str, Number]] = "fro",
    #             dim: 可选[Union[int, List[int]]] = None,
    #             keepdim: bool = False,
    #             out: 可选[Tensor] = None,
    #             数据类型：_dtype = None) -> 张量:
    #        返回 _norm_impl(input, p, dim, keepdim, out, dtype)
否则:
    # TODO：当 https://github.com/pytorch/pytorch/issues/33782 问题解决后，将 dim 类型更改为 BroadcastingList
    # https://github.com/pytorch/pytorch/issues/33782 修复后
    @overload
    定义 归一化(
        输入,
        p=拉丁,
        维度=无,
        保持维度=False,
        出=无,
        数据类型=无,
    ):
        (Tensor, str, Optional[List[int]], bool, Optional[Tensor], Optional[int]) -> Tensor
        通过

    @overload
    定义 归一化(  # noqa: F811
        输入,
        p=拉丁,
        维度=无,
        保持维度=False,
        出=无,
        数据类型=无,
    ):
        (Tensor, 可选[number], 可选[List[int]], bool, 可选[Tensor], 可选[int]) -> Tensor
        通过

    @overload
    定义 归一化(  # noqa: F811
        输入,
        p=拉丁,
        维度=无,
        保持维度=False,
        出=无,
        数据类型=无,
    ):
        (Tensor, 可选[number], 可选[int], bool, 可选[Tensor], 可选[int]) -> Tensor
        通过

    @overload
    定义 归一化(  # noqa: F811
        输入,
        p=拉丁,
        维度=无,
        保持维度=False,
        出=无,
        数据类型=无,
    ):
        (Tensor, str, 可选[int], bool, 可选[Tensor], 可选[int]) -> Tensor
        通过


定义 归一化(  # noqa: F811
    输入,
    p: 可选[联合[float, str]] = 拉丁,
    维度=无,
    保持维度=False,
    出=无,
    数据类型=无,
):
    r"返回给定张量的矩阵范数或向量范数。"

..警告::

torch.norm 已弃用，可能在未来的 PyTorch 版本中删除。
其文档和行为可能不正确，并且它已不再积极维护。
请使用 :func:`torch.linalg.vector_norm` 来计算向量范数，使用 :func:`torch.linalg.matrix_norm` 来计算矩阵范数。

当计算向量范数时使用 :func:`torch.linalg.vector_norm`，当计算矩阵范数时使用 :func:`torch.linalg.matrix_norm`。
请使用 :func:`torch.linalg.vector_norm` 来计算向量范数，使用 :func:`torch.linalg.matrix_norm` 来计算矩阵范数。
对于具有与此类似行为的函数，请参阅：:func:`torch.linalg.norm`。
然而，这些函数的签名与 `torch.norm` 的签名略有不同。
输入（张量）：输入张量。其数据类型必须是浮点型或复数类型。对于复数输入，范数计算使用的是 ...

参数：
输入（张量）：输入张量。它的数据类型必须是浮点型或复数类型。对于复数输入，范数计算使用的是 ...
输入（张量）：输入张量。它的数据类型必须是浮点型或复数类型。对于复数输入，范数计算使用的是 ...
每个元素的绝对值。如果输入是复数且既不是
:attr:`dtype` 或 :attr:`out` 未指定，结果的数据类型将
对应浮点类型（例如，如果 `:attr:`input` 是
复杂浮点数。

p (int, float, inf, -inf, 'fro', 'nuc', 可选): 范数的阶。默认：``'fro'``
可以计算以下范数：

            ======  ==============  ==========================
ord     矩阵范数     向量范数
            ======  ==============  ==========================
'fro'   Frobenius 范数  --
核范数    --
数量    --              sum(abs(x)**ord)**(1./ord)
            ======  ==============  ==========================

向量范数可以在任意维度上计算。
对应的维度被展平为 :attr:`input` 的维度。
一维，范数是在展平后计算的
维度。

弗罗贝尼乌斯范数在所有情况下都产生与 ``p=2`` 相同的结果
除非 :attr:`dim` 是三个或更多维度的列表，在这种情况下
的情况下，弗罗贝尼乌斯范数会抛出错误。

核范数只能计算在恰好两个维度上。

dim (int, int 元组，int 列表，可选):
指定要计算范数的 :attr:`input` 的哪个维度或哪些维度。
如果 :attr:`dim` 为 ``None``，则范数将在 :attr:`input` 的所有维度上计算。如果范数
是在所有维度上计算的，则 ...
由 :attr:`p` 指示的类型不支持指定的维度数量，将发生错误。
维度，将发生错误。
keepdim（布尔值，可选）：输出张量是否保留 :attr:`dim` 维度。如果 :attr:`dim` = ``None``，则忽略。
。如果 :attr:`dim` = ``None``，则忽略。
`out` = `None`. 默认：`False`
out (Tensor, 可选)：输出张量。如果忽略
`dim` = `None` 且 `out` = `None`
dtype (:class:`torch.dtype`, 可选)：期望的数据类型为
返回张量。如果指定，输入张量将被转换为
在执行操作时指定 `dtype`。默认：无。

.. 注意::
尽管 `p='fro'` 支持任意数量的维度，但真正的
数学定义的 Frobenius 范数仅适用于张量
精确到两个维度。:func:`torch.linalg.matrix_norm` 使用 ``ord='fro'``
与数学定义一致，因为它只能应用于
精确到两个维度。

示例::

>>> 导入 torch
        >>> a = torch.arange(9, dtype= torch.float) - 4
        >>> b = a.reshape((3, 3))
        >>> torch.norm(a)
        tensor(7.7460)
        >>> torch.norm(b)
        tensor(7.7460)
        >>> torch.norm(a, float('inf'))
        tensor(4.)
        >>> torch.norm(b, float('inf'))
        tensor(4.)
        >>> c = torch.tensor([[ 1, 2, 3], [-1, 1, 4]] , dtype=torch.float)
        >>> torch.norm(c, dim=0)
        tensor([1.4142, 2.2361, 5.0000])
        >>> torch.norm(c, dim=1)
        tensor([3.7417, 4.2426])
        >>> torch.norm(c, p=1, dim=1)
        tensor([6., 6.])
        >>> d = torch.arange(8, dtype=torch.float).reshape(2, 2, 2)
        >>> torch.norm(d, dim=(1, 2))
        tensor([ 3.7417, 11.2250])
        >>> torch.norm(d[0, :, :]), torch.norm(d[1, :, :])
(张量(3.7417), 张量(11.2250))
    """

    如果 has_torch_function_unary(输入):
        返回 handle_torch_function(
            归一化, (输入,), 输入, p=p, 维度=维度, 保持维度=保持维度, 出=出, 数据类型=dtype
        )

    # 注意。所有重复的代码和奇怪的 Python 都是为了取悦 TorchScript。
    #     对于更紧凑的实现，请参阅 `_refs/__init__.py` 中的相关函数

    # 我们不对 MPS 或稀疏张量这样做
    如果 输入.布局 == 火炬.稀疏的 和 输入.设备.类型 在 (
        "cpu",
        cuda,
        元数据,
        火炬.工具.后端注册._私有用途 1 后端名称,
    ):
        如果 维度 是 不 无:
            如果 isinstance(维度, (int, 火炬.SymInt)):
                _dim = [维度]
            否则:
                _dim = 维度
        否则:
            _dim = 无  # 类型：忽略[赋值]

        如果 isinstance(p, str):
            如果 p == fro 和 (
                维度 是 无 或者 isinstance(维度, (int, 火炬.SymInt)) 或者 长度(维度) <= 2
            ):
                如果 外部 是 无:
                    返回 火炬.线性代数.向量范数(
                        输入, 2, 模糊, 保持维度, 数据类型=dtype
                    )
                否则:
                    返回 火炬.线性代数.向量范数(
                        输入, 2, 模糊, 保持维度, 数据类型=数据类型, 出=外部
                    )

            # 我们可以称之为核范数，或者带有某些参数的矩阵范数
            # 这将引发错误
            如果 _dim 是 无:
                _dim = 列表(范围(输入.维数))
            如果 外部 是 无:
                返回 火炬.线性代数.矩阵范数(输入, p, 模糊, 保持维度, 数据类型=数据类型)
            否则:
                返回 火炬.线性代数.矩阵范数(
                    输入, p, 模糊, 保持维度, 数据类型=数据类型, 出=外部
                )
        否则:
            # 注意：p 应该是 Union[str, number] 类型，而不是 Optional!
            _p = 2.0 如果 p 是 无 否则 p
            如果 外部 是 无:
                返回 火炬.线性代数.向量范数(输入, _p, 模糊, 保持维度, 数据类型=数据类型)
            否则:
                返回 火炬.线性代数.向量范数(
                    输入, _p, 模糊, 保持维度, 数据类型=数据类型, 出=外部
                )

    维数 = 输入.维度()

    # 捕获默认情况
    如果 维度 是 无 和 外部 是 无 和 dtype 是 无 和 p 是 不 无:
        如果 isinstance(p, str):
            如果 p == 拉丁:
                返回 _VF.Frobenius 范数(输入, 维度=(), 保持维度=保持维度)
        如果 不 isinstance(p, str):
            _dim = 列表(范围(维数))
            返回 _VF.归一化(输入, p, 维度=模糊, 保持维度=保持维度)  # 类型：忽略[已定义]

    # TODO: 当 https://github.com/pytorch/pytorch/issues/33782 被修复时
    # 将 dim 为整数的重载移除，替换为 BraodcastingList1
    # 并删除下四行，将 _dim 替换为 dim
    如果 维度 是 不 无:
        如果 isinstance(维度, (int, 火炬.SymInt)):
            _dim = [维度]
        否则:
            _dim = 维度
    否则:
        _dim = 无  # 类型：忽略[赋值]

    如果 isinstance(p, str):
        如果 p == 拉丁:
            如果 dtype 是 不 无:
                抛出 值错误("dtype 参数不支持在 Frobenius 范数中")

            如果 _dim 是 无:
                _dim = 列表(范围(维数))
            如果 外部 是 无:
                返回 _VF.Frobenius 范数(输入, 模糊, 保持维度=保持维度)  # type: ignore[arg-type]
            否则:
                返回 _VF.Frobenius 范数(输入, 模糊, 保持维度=保持维度, 出=出)  # type: ignore[arg-type]
        elif p == 核:
            如果 dtype 是 不 无:
                抛出 值错误("核范数中不支持 dtype 参数")
            如果 _dim 是 无:
                如果 外部 是 无:
                    返回 _VF.核范数(输入, 保持维度=保持维度)  # type: ignore[arg-type]
                否则:
                    返回 _VF.核范数(输入, 保持维度=保持维度, 出=出)  # type: ignore[arg-type]
            否则:
                如果 外部 是 无:
                    返回 _VF.核范数(输入, 模糊, 保持维度=保持维度)  # type: ignore[arg-type]
                否则:
                    返回 _VF.核范数(输入, 模糊, 保持维度=保持维度, 出=出)  # type: ignore[arg-type]
        抛出 RuntimeError(f"仅有效的字符串值是 'fro' 和 'nuc'"{p}")
    否则:
        如果 _dim 是 无:
            _dim = 列表(范围(维数))

        如果 外部 是 无:
            如果 dtype 是 无:
                返回 _VF.归一化(输入, p, 模糊, 保持维度=保持维度)  # 类型：忽略[已定义]
            否则:
                返回 _VF.归一化(输入, p, 模糊, 保持维度=保持维度, 数据类型=数据类型)  # 类型：忽略[已定义]
        否则:
            如果 dtype 是 无:
                返回 _VF.归一化(输入, p, 模糊, 保持维度=保持维度, 出=出)  # 类型：忽略[已定义]
            否则:
                返回 _VF.归一化(输入, p, 模糊, 保持维度=保持维度, 数据类型=数据类型, 出=出)  # type: ignore[attr-defined]



定义 unravel_index(
    索引: 张量,
    形状: 联合[int, 序列[int] 火炬.尺寸]
) -> 元组[张量, ...]
    r将一个扁平索引的张量转换为坐标张量的元组
指定形状的任意张量的索引。

参数：
索引（Tensor）：一个整数张量，包含对形状的索引。
任意形状为 :attr:`shape` 的张量的扁平版本。
所有元素必须在范围 ``[0, prod(shape) - 1]`` 内。

形状（int、int 序列或 torch.Size）：任意张量的形状。所有元素必须为非负。
张量。所有元素必须为非负。

返回值：
张量元组的 Tensors：输出中的每个``i``-th 张量对应于：attr:`shape`的维度``i``。每个张量具有与形状相同的形状。
每个张量具有与形状相同的形状。
``indices`` 包含每个维度 ``i`` 的一个索引。
由 ``indices`` 给出的平面索引。

示例::

>>> 导入 torch
        >>> torch.unravel_index(torch.tensor(4), (3, 2))
        (tensor(2),
tensor(0)

        >>> torch.unravel_index(torch.tensor([4, 1]), (3, 2))
        (tensor([2, 0]),
tensor([0, 1])

        >>> torch.unravel_index(torch.tensor([0, 1, 2, 3, 4, 5]), (3, 2))
        (tensor([0, 0, 1, 1, 2, 2]),
         tensor([0, 1, 0, 1, 0, 1]))

        >>> torch.unravel_index(torch.tensor([1234, 5678]), (10, 10, 10, 10))
(张量([1, 5]),
张量([2, 6]),
tensor([3, 7])
tensor([4, 8])

        >>> torch.unravel_index(torch.tensor([[1234], [5678]]), (10, 10, 10, 10))
        (tensor([[1], [5]]),
tensor([[2], [6]])
tensor([[3], [7]])
tensor([[4], [8]])

        >>> torch.unravel_index(torch.tensor([[1234], [5678]]), (100, 100))
(tensor([[12], [56]]))
         tensor([[34], [78]]))
    """
    如果 has_torch_function_unary(索引):
        返回 handle_torch_function(unravel_index, (索引,), 索引, 形状=形状)
    累积张量 = _unravel_index(索引, 形状)
    返回 累积张量.解绑(-1)



定义 _unravel_index(索引: 张量, 形状: 联合[int, 序列[int]]) -> 张量:
    火炬._检查类型(
        不 索引.是复杂的()
        和 不 索引.is_floating_point()
        和 不 索引.dtype == 火炬.bool,
        lambda: f"期望 'indices' 为整型数据类型，但得到{索引.数据类型}",
    )

    火炬._检查类型(
        isinstance(形状, (int, 火炬.SymInt, 序列)),
        lambda: f"预期 'shape' 是 int 或 int 序列，但得到了"{类型(形状)}",
    )

    如果 isinstance(形状, (int, 火炬.SymInt)):
        形状 = 火炬.尺寸[形状])
    否则:
        对于 维度 在 形状:
            火炬._检查类型(
                isinstance(维度, (int, 火炬.SymInt)),
                lambda: f预期 'shape' 序列只应包含整数，但得到了{类型(维度)}",
            )
        形状 = 火炬.尺寸(形状)

    火炬.检查值(
        所有(维度 ≥ 0 对于 维度 在 形状),
        lambda: f"形状不能有负值，但得到了"{元组(形状)}",
    )

    系数 = 列表(
        反转(
            列表(
                itertools.累加(
                    反转(形状[1] + 火炬.尺寸[1])), 函数=操作符.乘
                )
            )
        )
    )
    返回 索引.展平(-1).向下取整除(
        火炬.张量(系数, 设备=索引.设备, 数据类型=火炬.int64)
    ) % 火炬.张量(形状, 设备=索引.设备, 数据类型=火炬.int64)


[文档]def chain_matmul(*matrices, out=None):
返回 `N` 个二维张量的矩阵乘积。此乘积计算效率高。
使用矩阵链序算法，该算法选择最低成本的顺序
算术运算（`[CLRS]`_）的函数，注意由于这是一个计算乘积的函数，:math:`N`
需要大于等于 2；如果等于 2，则返回一个平凡的矩阵-矩阵乘积。
如果:math:`N`是 1，则这是一个无操作 - 原始矩阵按原样返回。

.. 警告::

`torch.chain_matmul` 已弃用，将在未来的 PyTorch 版本中删除。
请使用 :func:`torch.linalg.multi_dot` 代替，它接受一个包含两个或更多张量的列表
而不是多个参数。

参数：
矩阵（张量...）：要确定乘积的 2 个或更多 2-D 张量序列。
out（张量，可选）：输出张量。如果：attr:`out` = ``None``，则忽略。

返回：
张量：如果第：math:`i^{th}` 张量的维度为：math:`p_{i} \times p_{i + 1}`，则乘积
将会是维度为 :math:`p_{1} \times p_{N + 1}` 的。

示例::

>>> # xdoctest: +SKIP
>>> # xdoctest: +IGNORE_WANT("非确定性的")
>>> a = torch.randn(3, 4)
>>> b = torch.randn(4, 5)
>>> c = torch.randn(5, 6)
>>> d = torch.randn(6, 7)
# 将引发弃用警告
>>> torch.chain_matmul(a, b, c, d)
tensor([[ -2.3375,  -3.9790,  -4.1119,  -6.6577,   9.5609, -11.5095,  -3.2614],
[ 21.4038,   3.3378,  -8.4982,  -5.2457, -10.2561,  -2.4684,   2.7163],
[[-0.9647, -5.8917, -2.3213, -5.2284, 12.8615, -12.2816, -2.5095]])

.. 参考文献请见[CLRS](https://mitpress.mit.edu/books/introduction-algorithms-third-edition)
"""
# 此包装器存在是为了支持可变参数。
如果有 torch_function(matrices):
返回 handle_torch_function(chain_matmul, matrices, *matrices)

如果 out 为 None:
返回_VF.chain_matmul(matrices)  # type: ignore[attr-defined]
else:
返回 _VF.chain_matmul(matrices, out=out)  # 忽略属性定义错误


定义 _lu_impl(A, 轴心=True, 获取信息=False, 出=无):
    # 类型: (Tensor, bool, bool, Any) -> tuple[Tensor, Tensor, Tensor]
    r计算矩阵或矩阵批次的 LU 分解
返回包含矩阵 :attr:`A` 的 LU 分解和
交换因子的元组。如果 :attr:`pivot` 设置为
``True``，则进行交换。

..警告::

`:func:`torch.lu` 已弃用，推荐使用 :func:`torch.linalg.lu_factor`。
and :func:`torch.linalg.lu_factor_ex`。:func:`torch.lu` 将在下一个版本中删除。
未来 PyTorch 版本。
`LU, 旋转，信息 = torch.lu(A, 计算旋转)`

.. 代码块 :: python

            LU, pivots = torch.linalg.lu_factor(A, compute_pivots)

``LU, pivots, info = torch.lu(A, compute_pivots, get_infos=True)`` 应该替换为

.. 代码块 :: python

LU 分解，pivot，信息 = torch.linalg.lu_factor_ex(A, compute_pivots)

.. 注意::
* 每个矩阵返回的置换矩阵表示为一个大小为 ``min(A.shape[-2], A.shape[-1])`` 的 1 索引向量。
``pivots[i] == j`` 表示在算法的第 i 步中，
算法中第 i 步的 pivot[i]等于 j。
第 i 行与第 j-1 行进行了置换。
当 :attr:`pivot` = ``False`` 时，不可用 LU 分解，尝试这样做将引发错误。
对于 CPU，并且尝试这样做将会抛出错误。然而，
当 :attr:`pivot` = ``False`` 时，LU 分解是可用的。
          CUDA.
此函数不检查分解是否成功
或如果不：attr:`get_infos` 是 ``True``，则状态为
分解存在于返回元组的第三个元素中。
在大小小于或等于的平方矩阵批次的情况下
将 32 个在 CUDA 设备上，LU 分解被重复进行
由于 MAGMA 库中的错误，导致单矩阵
（参见熔岩问题 13）。
使用 :func:`torch.lu_unpack` 可以导出 ``L``、``U`` 和 ``P``。

..警告::
当 :attr:`A` 是满秩时，该函数的梯度才会是有限的。
这是因为 LU 分解仅在满秩矩阵处可微。
此外，如果 :attr:`A` 接近非满秩，则
梯度将数值不稳定，因为它依赖于 :math:`L^{-1}` 和 :math:`U^{-1}` 的计算。

参数：
A（张量）：要分解的尺寸为 :math:`(*, m, n)` 的张量。
pivot（布尔值，可选）：控制是否进行置换。默认：``True``。
get_infos（布尔值，可选）：如果设置为 ``True``，则返回一个信息 IntTensor。
默认：``False``
输出（元组，可选）：可选输出元组。如果 :attr:`get_infos` 是 ``True``，
则元组中的元素是 Tensor，IntTensor，
和 IntTensor。如果 :attr:`get_infos` 是 ``False``，则
元组中的元素为 Tensor，IntTensor。默认值：``None``

返回值：
(Tensor, IntTensor, IntTensor（可选）)：包含张量的元组

- **分解** (*Tensor*)：大小为 :math:`(*, m, n)` 的分解

- **主元** (*IntTensor*)：大小为 :math:`(*, \text{min}(m, n))` 的主元
``pivots`` 存储所有行的中间转置。
最终排列 ``perm`` 可以通过
应用 ``swap(perm[i], perm[pivots[i] - 1])`` 对于 ``i = 0, ..., pivots.size(-1) - 1`` 来重建，
其中 ``perm`` 初始为 :math:`m` 个元素的恒等排列
这实际上就是 :func:`torch.lu_unpack` 函数所做的事情。

- **infos** (*IntTensor*, *可选*): 如果 :attr:`get_infos` 是 ``True``，则这是一个张量，
大小为 :math:`(*)`，其中非零值表示矩阵或每个小批量因式分解是否成功。
失败。

示例::

        >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_LAPACK)
>>> # xdoctest: +IGNORE_WANT("非确定性")
        >>> A = torch.randn(2, 3, 3)
        >>> A_LU, pivots = torch.lu(A)
        >>> A_LU
        tensor([[[ 1.3506,  2.5558, -0.0816],
                 [ 0.1684,  1.1551,  0.1940],
                 [ 0.1193,  0.6189, -0.5497]],

[[0.4526, 1.2526, -0.3285]]
[[-0.7988, 0.7175, -0.9701]]
[[0.2634, -0.9255, -0.3459]]
>>> 旋转轴
        tensor([[ 3,  3,  3],
                [ 3,  3,  3]], dtype=torch.int32)
        >>> A_LU, pivots, info = torch.lu(A, get_infos=True)
>>> 如果 info.nonzero().size(0)等于 0:
...     打印('所有样本的 LU 分解成功！')
所有样本的 LU 分解成功！
    """
    # 如果 get_infos 为 True，则不需要检查错误，反之亦然
    返回 火炬._lu_with_info(A, 轴心=轴心, 检查错误=(不 获取信息))


如果 类型检查:
    _列表或序列 = 序列[张量]
否则:
    _列表或序列 = 列表[张量]


定义 _检查列表大小(out_len: int, 获取信息: bool, 出: _ListOrSeq) -> 无:
    获取信息_int = 1 如果 获取信息 否则 0
    如果 输出长度 - 获取信息_int != 2:
        抛出 类型错误(
            f"预期的元组，但得到的是"{2 + int(获取信息)}元素的数量，但得到了"{out_len}"
        )
    如果 不 isinstance(出, (元组, 列表)):
        抛出 类型错误(
            f"参数 'out' 必须是 Tensors 的元组，不是"{类型(出).__name__}"
        )


定义 _lu_with_infos(A, 轴心=True, 获取信息=False, 出=无):
    # 类型: (Tensor, bool, bool, Optional[tuple[Tensor, Tensor, Tensor]]) -> tuple[Tensor, Tensor, Tensor]
    如果 has_torch_function_unary(A):
        返回 handle_torch_function(
            lu, (A,), A, 轴心=轴心, 获取信息=获取信息, 出=外部
        )
    结果 = _lu_impl(A, 轴心, 获取信息, 出)
    如果 外部 是 不 无:
        _检查列表大小(长度(出), 获取信息, 出)
        对于 i 在 范围(长度(出)):
            出[i].调整大小为_(结果[i]).复制_(结果[i])
        返回 外部
    否则:
        返回 结果  # A_LU, 旋转轴，信息


定义 _lu_no_infos(A, 轴心=True, 获取信息=False, 出=无):
    # type: (张量, 布尔值, 布尔值, 可选[tuple[张量, 张量]]) -> tuple[张量, 张量]
    # 需要在这里检查 torch_function，以便在退出时
    如果 has_torch_function_unary(A):
        返回 handle_torch_function(
            lu, (A,), A, 轴心=轴心, 获取信息=获取信息, 出=外部
        )
    结果 = _lu_impl(A, 轴心, 获取信息, 出)
    如果 外部 是 不 无:
        _检查列表大小(长度(出), 获取信息, 出)
        对于 i 在 范围(长度(出)):
            出[i].调整大小为_(结果[i]).复制_(结果[i])
        返回 外部
    否则:
        返回 结果[0] 结果[1]  # A_LU，枢轴


lu 的返回类型取决于`get_infos`，因此为了解决在 TorchScript 中 lu 的输出类型，我们需要静态地知道`get_infos`的值
lu 在 TorchScript 中的输出类型需要静态地知道`get_infos`的值
lu = 布尔分发(
    参数名称=get_infos,
    索引参数=2,
    默认=False,
    如果为真=_lu_with_infos,
    如果为假=_lu_no_infos,
    模块名称=__name__,
    函数名="lu",
)
lu.__文档__ = _lu_impl.__文档__


定义 对齐张量(*张量):
    抛出 RuntimeError("对齐张量尚未实现。")