# mypy: 允许未类型化定义
该模块通过 python_tensor.cpp 添加了 Tensor 类
为了同时支持 TorchScript 和 MyPy 的解决方案：
来自
打字
导入
任何,
可选,
类型检查,
联合
导入
火炬
来自
火炬
导入
张量
来自 torch._C
导入
_添加文档字符串, _sparse
# 类型：忽略[已定义]
半结构化稀疏度支持
来自
.半结构化
导入 (
稀疏半结构化张量,
稀疏半结构化张量 CUSPARSELT,
稀疏半结构化张量 CUTLASS,
转换为稀疏半结构化,
)
if 类型检查:
来自
torch 的类型
导入 _dtype as
数据类型
暗度 =
可选[
联合[int,
元组[int, ...
]
列表[int]]]
否则:
# JIT 编译器不理解 Union，也不理解这里的 torch.dtype
数据类型 =
整型
暗度 =
可选[
元组[int]]
全部 = [
添加 mm,
检查稀疏张量不变性,
mm,
"求和",
"softmax",
"求解",
"log_softmax",
稀疏半结构化张量,
稀疏半结构化张量 CUTLASS,
稀疏半结构化张量 CUSPARSELT,
转换为稀疏半结构化,
as_sparse_gradcheck,
]
addmm = _添加文档字符串(
_sparse._sparse_addmm,
r""
sparse.addmm(mat, mat1, mat2, *, beta=1., alpha=1.) -> Tensor
此函数与 :func:`torch.addmm` 在正向操作中执行完全相同的功能，
但它支持稀疏 COO 矩阵 :attr:`mat1` 的反向操作。
当 :attr:`mat1` 是 COO 张量时，它必须具有 `sparse_dim = 2`。
当输入为 COO 张量时，此函数也支持对两个输入的逆向传播。
支持 CSR 和 COO 存储格式。
.. 注意：
此函数不支持对 CSR 矩阵进行求导。
参数：
mat (Tensor)：要添加的密集矩阵
mat1（张量）：要相乘的稀疏矩阵
mat2（张量）：要相乘的稠密矩阵
beta（数字，可选）：:attr:`mat`（:math:`\beta`）的乘数
alpha（数字，可选）：:math:`mat1 @ mat2`（:math:`\alpha`）的乘数
""",
)
mm = _添加文档字符串(
_sparse.稀疏_mm,
r""
执行稀疏矩阵 :attr:`mat1` 的矩阵乘法
与（稀疏或步进）矩阵 :attr:`mat2`。类似于 :func:`torch.mm`，如果 :attr:`mat1` 是
math:`(n \times m)` 张量，:attr:`mat2` 是 :math:`(m \times p)` 张量，输出将是
math:`(n \times p)` 张量。
当`:attr:`mat1`是一个 COO 张量时，它必须具有`sparse_dim = 2`。
当输入是 COO 张量时，此函数也支持对两个输入的反向传播。
支持 CSR 和 COO 存储格式。
.. 注意：
此函数不支持对 CSR 矩阵进行求导。
此函数还额外接受一个可选的：attr:`reduce` 参数，允许
规格说明一个可选的缩减操作，在数学上执行以下操作：
.. 数学表达式
z_{ij} = \bigoplus_{k = 0}^{K - 1} x_{ik} y_{kj}
其中 :math:`\bigoplus` 定义了累加操作符。:attr:`reduce` 仅在 CPU 设备上的 CSR 存储格式中实现。
CSR 存储格式在 CPU 设备上。
参数：
mat1 (Tensor)：要相乘的第一个稀疏矩阵
mat2 (Tensor)：要相乘的第二个矩阵，可以是稀疏矩阵或稠密矩阵
reduce (str, 可选)：应用于非唯一索引的降维操作
(:obj:`"sum"`, :obj:`"mean"`, :obj:`"amax"`, :obj:`"amin"`). 默认 :obj:`"sum"`.
形状：
此函数的输出张量格式如下：
- 稀疏 x 稀疏 -> 稀疏
- 稀疏 x 密集 -> 密集
示例::
>>> a = torch.tensor([[1., 0, 2], [0, 3, 0]]).to_sparse().requires_grad_()
>>> a
tensor(indices=tensor([[0, 0, 1],
[0, 2, 1]]),
values=tensor([1., 2., 3.])
size=(2, 3), nnz=3, 布局=torch.sparse_coo, requires_grad=True)
>>> b = torch.tensor([[0, 1.], [2, 0], [0, 0]], requires_grad=True)
>>> b
tensor([[0., 1.],
[2., 0.],
[0., 0.]], requires_grad=True)
>>> y = torch.sparse.mm(a, b)
>>> y
tensor([[0., 1.],
[6., 0.]], grad_fn=<SparseAddmmBackward0>)
>>> y.sum().backward()
>>> a.grad
tensor(indices=tensor([[0, 0, 1],
[0, 2, 1]]),
values=tensor([1., 0., 2.]),
size=(2, 3), nnz=3, 布局=torch.sparse_coo)
>>> c = a.detach().to_sparse_csr()
>>> c
tensor(crow_indices=tensor([0, 2, 3]),
col_indices=tensor([0, 2, 1]),
values=tensor([1., 2., 3.]), size=(2, 3), nnz=3,
layout=torch.sparse_csr)
>>> y1 = torch.sparse.mm(c, b, 'sum')
>>> y1
tensor([[0., 1.],
[[6., 0.]], grad_fn=)
>>> y2 = torch.sparse.mm(c, b, 'max')
>>> y2
tensor([[0., 1.],
[[6., 0.]], grad_fn=)
""",
)
sampled_addmm = _添加文档字符串(
_sparse.稀疏采样加 MM,
r""
sparse.sampled_addmm(input, mat1, mat2, *, beta=1., alpha=1., out=None) -> 张量
执行密集矩阵 :attr:`mat1` 和 :attr:`mat2` 在 :attr:`input` 的稀疏模式指定的位置的矩阵乘法。
矩阵 :attr:`input` 被添加到最终结果中。
从数学上讲，这执行以下操作：
.. 数学表达式
\text{out} = \alpha\ (\text{mat1} \mathbin{@} \text{mat2})*\text{spy}(\text{input}) + \beta\ \text{input}
其中 :math:`\text{spy}(\text{input})` 是 :attr:`input` 的稀疏模式矩阵，:attr:`alpha`
和 :attr:`beta` 是缩放因子。
`spy(input)` 在 `input` 非零值的位置上取值为 1，其他位置取值为 0。
.. 注意：
`input` 必须是一个稀疏的 CSR 张量。`mat1` 和 `mat2` 必须是稠密张量。
参数：
输入 (Tensor)：一个形状为 `(m, n)` 的稀疏 CSR 矩阵，用于相加并用于计算
样本矩阵乘法
mat1（张量）：一个形状为（m，k）的密集矩阵，用于相乘
mat2（张量）：一个形状为（k，n）的密集矩阵，用于相乘
关键字参数:
beta（数字，可选）：用于：attr:`input`（:math:`\beta`）的乘数
alpha（数字，可选）：:math:`mat1 @ mat2`（:math:`\alpha`）的乘数
out（张量，可选）：输出张量。如果为`None`则忽略。默认：`None`。
示例::
>>> input = torch.eye(3, device='cuda').to_sparse_csr()
>>> mat1 = torch.randn(3, 5, device='cuda')
>>> mat2 = torch.randn(5, 3, device='cuda')
>>> torch.sparse.sampled_addmm(input, mat1, mat2)
tensor(crow_indices=tensor([0, 1, 2, 3]),
col_indices=tensor([0, 1, 2]),
values=tensor([ 0.2847, -0.7805, -0.1900]), device='cuda:0',
size=(3, 3), nnz=3, 布局=torch.sparse_csr)
>>> torch.sparse.sampled_addmm(input, mat1, mat2).to_dense()
tensor([[ 0.2847, 0.0000, 0.0000],
[ 0.0000, -0.7805, 0.0000],
[[0.0000, 0.0000, -0.1900]], 设备='cuda:0'
>>> torch.sparse.sampled_addmm(input, mat1, mat2, beta=0.5, alpha=0.5)
tensor(crow_indices=tensor([0, 1, 2, 3]),
col_indices=tensor([0, 1, 2]),
values=tensor([ 0.1423, -0.3903, -0.0950]), device='cuda:0',
size=(3, 3), nnz=3, layout=torch.sparse_csr)
""",
)
[文档]def
总和(
输入:
张量,
维度:
暗度 =
无,
数据类型:
可选[
数据类型] =
无) ->
张量:
r返回给定稀疏张量每行的和。
返回给定稀疏张量 `input` 在指定维度 `dim` 上每行的和。
如果 `dim` 是维度的列表，则
对所有这些进行求和。当对所有 `sparse_dim` 求和时，此方法返回一个稠密张量而不是稀疏张量。
返回一个稠密张量而不是稀疏张量。
所有求和的 :attr:`dim` 都会被压缩（参见 :func:`torch.squeeze`），结果是一个维度比 :attr:`input` 少 :attr:`dim` 的输出张量。
输出张量的维度比输入张量少 :attr:`dim`。
在反向传播过程中，只有 `input` 的 ``nnz`` 位置处的梯度
将传播回。注意：:attr:`input` 的梯度已合并。
参数：
输入（张量）：输入稀疏张量
dim (int 或 int 的元组): 要降维的维度或维度列表。默认：reduce
总维度。
dtype (:class:`torch.dtype`, 可选): 返回 Tensor 的期望数据类型。
默认：:attr:`input` 的数据类型。
示例::
>>> nnz = 3
>>> dims = [5, 5, 2, 3]
>>> I = torch.cat([torch.randint(0, dims[0], size=(nnz,)),
torch.randint(0, dims[1], size=(nnz,))], 0).reshape(2, nnz)
>>> V = torch.randn(nnz, dims[2], dims[3])
>>> size = torch.Size(dims)
>>> # xdoctest: +IGNORE_WANT("非确定性")
>>> S = torch.sparse_coo_tensor(I, V, size)
>>> S
tensor(indices=tensor([[2, 0, 3],
[[2, 4, 1]])
values=tensor([[[[-0.6438, -1.6467, 1.4004],
[[ 0.3411, 0.0918, -0.2312]],
[[ 0.5348, 0.0634, -2.0494],
[[-0.7125, -1.0646, 2.1844]]
[[0.1276, 0.1874, -0.6334]]
[[-1.9682, -0.5340, 0.7483]]
size=(5, 5, 2, 3), nnz=3, layout=torch.sparse_coo
当仅对 sparse_dims 的部分求和时，返回一个稀疏张量
>>> torch.sparse.sum(S, [1, 3])
tensor(indices=tensor([[0, 2, 3]]),
values=tensor([[-1.4512, 0.4073],
[-0.8901, 0.2017]
[-0.3183, -1.7539]
size=(5, 2), nnz=3, layout=torch.sparse_coo
当对所有稀疏维度求和时，返回一个稠密张量
# 压缩维度求和
>>> torch.sparse.sum(S, [0, 1, 3])
tensor([-2.6596, -1.1450])
"""
if dtype 是
无:
if 维度
是
不
无:
返回
PyTorch._sparse_sum(
输入,
维度)
否则:
返回
PyTorch._sparse_sum(
输入)
否则:
if 维度
是
不
无:
返回
PyTorch._sparse_sum(
输入,
维度,
数据类型=
数据类型)
否则:
返回
PyTorch._sparse_sum(
输入,
数据类型=
数据类型)
softmax = _添加文档字符串(
_sparse.稀疏 softmax,
r""
sparse.softmax(input, dim, *, dtype=None) -> Tensor
应用 softmax 函数。
Softmax 定义为：
\text{Softmax}(x_{i}) = \frac{exp(x_i)}{\sum_j exp(x_j)}\
where :math:`i, j` 在稀疏张量索引和未指定范围内运行
条目被忽略。这相当于定义未指定
条目设为负无穷大，使得 :math:`exp(x_k) = 0` 当
条目索引：`k` 未指定。
它应用于`dim`的所有切片，并将它们重新缩放，使得
元素位于范围 `[0, 1]` 内，并且总和为 1。
参数：
input (Tensor): 输入
dim (int): softmax 将计算的维度
dtype (:class:`torch.dtype`, 可选): 想要的数据类型
返回张量的类型。如果指定，输入张量在操作执行前会被转换为 :attr:`dtype`
转换。这在防止数据类型
转换错误时很有用。
溢出。默认值：无
""",
)
spsolve = _添加文档字符串(
_sparse._spsolve,
r""
sparse.spsolve(input, other, *, left=True) -> 张量
计算一个线性方程组的解
一个独特的解决方案。其目的是类似于：func:`torch.linalg.solve`
除了系统由一个稀疏的 CSR 矩阵定义外
`稀疏_csr`。
参数：
输入（张量）：表示线性系统系数的形状为`(n, n)`的稀疏 CSR 矩阵
。
其他（Tensor）：表示线性系统右侧的密集矩阵（n, ）
左侧（bool，可选）：是否求解 `input @ out = other`（默认）或 `out @ input = other` 的系统。仅支持 `left=True`。
left（bool，可选）：是否求解 `input @ out = other`（默认）或 `out @ input = other` 的系统。
仅支持 `left=True`。
""",
)
log_softmax = _添加文档字符串(
_sparse._sparse_log_softmax,
r""
sparse.log_softmax(input, dim, *, dtype=None) -> Tensor
应用 softmax 函数后跟对数。
更多详情请参阅 :class:`~torch.sparse.softmax`。
参数：
input (Tensor): 输入
dim (int): softmax 将计算的维度
dtype (:class:`torch.dtype`, 可选): 想要的数据类型
返回张量的类型。如果指定，输入张量在操作执行前会被转换为 :attr:`dtype`
转换。这在防止数据类型
转换错误时很有用。
溢出。默认值：无
""",
)
spdiags = _添加文档字符串(
_sparse._spdiags,
r""
sparse.spdiags(diagonals, offsets, shape, layout=None) -> Tensor
通过将 :attr:`diagonals` 的值放置在输出矩阵的指定对角线上创建一个稀疏二维张量
attr:`对角线` 沿着指定的对角线排列
attr:`offsets` 张量控制哪些对角线被设置。
- 如果 :attr:`offsets[i]` = 0，则是主对角线
- 如果 :attr:`offsets[i]` < 0，则位于主对角线下方
- 如果 :attr:`offsets[i]` > 0，则位于主对角线上方
对角线的行数必须与 :attr:`offsets` 的长度相匹配，
并且偏移量不能重复。
参数：
对角线（Tensor）：按行存储对角线的矩阵
偏移量（Tensor）：要设置的对角线，存储为向量
形状（整数二元组）：结果期望的形状
关键字参数:
布局（:class:`torch.layout`，可选）：返回张量的期望布局
支持的格式有 ``torch.sparse_coo``、``torch.sparse_csc`` 和 ``torch.sparse_csr``
默认：``torch.sparse_coo``
示例：
设置矩阵的主对角线和前两个下对角线
>>> diags = torch.arange(9).reshape(3, 3)
>>> diags
tensor([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> s = torch.sparse.spdiags(diags, torch.tensor([0, -1, -2]), (3, 3))
>>> s
tensor(indices=tensor([[0, 1, 2, 1, 2, 2],
[0, 1, 2, 0, 1, 0]]),
values=tensor([0, 1, 2, 3, 4, 6]),
size=(3, 3), nnz=6, 布局=torch.sparse_coo)
>>> s.to_dense()
tensor([[0, 0, 0],
[3, 1, 0],
[6, 4, 2]])
更改输出布局
>>> diags = torch.arange(9).reshape(3, 3)
>>> diags
tensor([[0, 1, 2],[3, 4, 5], [6, 7, 8]])
>>> s = torch.sparse.spdiags(diags, torch.tensor([0, -1, -2]), (3, 3), layout=torch.sparse_csr)
>>> s
tensor(crow_indices=tensor([0, 1, 3, 6]))
col_indices=tensor([0, 0, 1, 0, 1, 2])
values=tensor([0, 3, 1, 6, 4, 2]), size=(3, 3), nnz=6,
layout=torch.sparse_csr)
>>> s.to_dense()
tensor([[0, 0, 0],
[3, 1, 0],
[6, 4, 2]])
设置大输出部分的偏对角线::
>>> diags = torch.tensor([[1, 2], [3, 4]])
>>> offsets = torch.tensor([0, -1])
>>> torch.sparse.spdiags(diags, offsets, (5, 5)).to_dense()
tensor([[1, 0, 0, 0, 0],
[3, 2, 0, 0, 0]
[0, 4, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
.. 注意：
当设置给定对角线上的值时，对角线中的索引
并且将`:attr:`diagonals`中的行索引作为
输出列索引。这会导致当设置对角线时
使用正偏移量 `k`，该对角线上的第一个值将是
对角线行 :attr:`diagonals` 中位置 `k` 的值
指定正偏移量::
>>> diags = torch.tensor([[1, 2, 3], [1, 2, 3], [1, 2, 3]])
>>> torch.sparse.spdiags(diags, torch.tensor([0, 1, 2]), (5, 5)).to_dense()
tensor([[1, 2, 3, 0, 0],
[0, 2, 3, 0, 0],
[0, 0, 3, 0, 0],
[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
""",
)
[文档]
类
检查稀疏张量不变性:
一个用于控制检查稀疏张量不变性的工具。
管理稀疏张量不变量的以下选项存在
在稀疏张量构建中进行检查：
1. 使用上下文管理器：
.. 代码块 :: python
with torch.sparse.check_sparse_tensor_invariants():
run_my_model()
2. 采用程序化方法：
.. 代码块 :: python
prev_checks_enabled = torch.sparse.check_sparse_tensor_invariants.is_enabled()
torch.sparse.check_sparse_tensor_invariants.enable()
run_my_model()
如果没有 prev_checks_enabled:
torch.sparse.check_sparse_tensor_invariants.disable()
3. 使用函数装饰：
.. 代码块 :: python
@torch.sparse.check_sparse_tensor_invariants()
def run_my_model():
...
run_my_model()
在稀疏张量构造函数调用中使用 ``check_invariants`` 关键字参数。
例如：
>>> torch.sparse_csr_tensor([0, 1, 3], [0, 1], [1, 2], check_invariants=True)
Traceback (most recent call last):
文件 "", 行 1，在 中
运行时错误：`crow_indices[..., -1] == nnz` 不满足条件。
"""
[文档] @staticmethod
def is_enabled():
r"""返回 True 如果稀疏张量不变性检查已启用。
.. 注意::
使用 :func:`torch.sparse.check_sparse_tensor_invariants.enable` 或
func:`torch.sparse.check_sparse_tensor_invariants.disable` 来
管理稀疏张量不变性检查的状态。
"""
返回 torch._C._check_sparse_tensor_invariants()
[文档] @staticmethod
def 启用():
启用稀疏张量构造函数中的稀疏张量不变性检查。
.. 注意::
默认情况下，稀疏张量不变性检查是禁用的。使用
func:`torch.sparse.check_sparse_tensor_invariants.is_enabled` 来
检索稀疏张量不变性检查的当前状态。
.. 注意::
稀疏张量不变性检查标志对所有稀疏张量构造函数有效，包括 Python 和 ATen。
稀疏张量构造函数，无论是 Python 还是 ATen，稀疏张量不变性检查标志都有效。
标志可以被本地覆盖为 `check_invariants`
可选参数为稀疏张量构造函数的参数。
```python
# 输入文本
input_text = '"""'
# 翻译函数（此处为示例，实际翻译功能需调用真实的翻译 API）
def translate_to_simplified_chinese(text):
# 假设的翻译结果
return text
# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
torch._C._set_check_sparse_tensor_invariants(True)
翻译为：torch._C._set_check_sparse_tensor_invariants(True)
[文档] @staticmethod
def 禁用():
r"""在稀疏张量构造函数中禁用稀疏张量不变性检查。
更多信息请参阅 :func:`torch.sparse.check_sparse_tensor_invariants.enable`。
"""
torch._C._set_check_sparse_tensor_invariants(False)
# 管道管理器支持
def __init__(self, 启用=True):
self.状态 =
启用
self.保存状态:
可选[bool] =
无
def __进入__(self):
if self.保存状态
是
不
无:
抛出
运行时错误(
"此上下文管理器实例已激活。"
"请使用不同的上下文管理器实例进行上下文嵌套。"
)
self.保存状态 = self.
启用()
PyTorch._C.
设置检查稀疏张量不变性(self.
状态)
def __退出__(self,
类型, value,
跟踪回溯):
断言 self.
保存状态
是
不
无
PyTorch._C.
设置检查稀疏张量不变性(self.
保存状态)
self.保存状态 =
无
装饰器支持
def __调用__(self,
月):
def 测试_mth(*
参数, **kwargs):
替换为
类型(self)(self.
状态):
返回
月(*
参数, **kwargs)
返回
测试_mth
[文档]def as_sparse_gradcheck(gradcheck):
装饰函数，用于扩展稀疏张量的 gradcheck。
torch.autograd.gradcheck 或其 functools.partial 的装饰器
扩展 gradcheck 函数以支持输入变体的方法
操作或返回稀疏张量的函数
确保指定的 gradcheck 函数本身仅操作
带有步长的张量
例如：
>>> gradcheck = torch.sparse.as_sparse_gradcheck(torch.autograd.gradcheck)
>>> x = torch.tensor([[0, 1], [2, 3]], dtype=torch.float64).to_sparse_coo().requires_grad_(True)
>>> gradcheck(lambda x: x.to_sparse_csr(), x)
True
"""
def gradcheck_with_sparse_support(函数,
输入, **kwargs):
""
创建支持稀疏张量的 gradcheck。
与:func:`torch.autograd.gradcheck`相同，但支持稀疏张量的输入和输出。
"""
隐藏 = kwargs.
流行(
"掩码", False)
稀疏布局 = {
PyTorch.
稀疏 COO,
PyTorch.
稀疏压缩存储格式,
PyTorch.
稀疏压缩存储格式,
PyTorch.
稀疏_bsr,
PyTorch.
稀疏矩阵,
}
稀疏压缩布局 = {
PyTorch.
稀疏压缩存储格式,
PyTorch.
稀疏压缩存储格式,
PyTorch.
稀疏_bsr,
PyTorch.
稀疏矩阵,
}
稀疏块布局 = {
PyTorch.
稀疏_bsr,
PyTorch.
稀疏矩阵}
STRIDED_REPRESENTATION = "__STRIDED_REPRESENTATION__"
def 转换为步长表示形式(
参数):
将可微的非分步张量转换为包含可微分步张量的表示形式。
if 不 isinstance(
参数, (
列表,
元组)):
args = (参数,)
新参数:
列表[
任何] =
输入文本为空，请提供需要翻译的文本
为
对象
在
参数:
if (
isinstance(对象,
PyTorch.
张量)
和
对象.
需要梯度
和
对象.
布局
在
稀疏布局
):
d = 字典(
布局=
对象.
布局,
形状=
对象.
形状)
if 不
遮蔽:
# 使用零值材料化未指定的元素
批处理维度 =
对象.
维数 -
对象.
稠密维度() -
对象.
稀疏维度()
块大小 = (
对象.
值().
形状[
批处理维度 + 1 :
批处理维度 + 3]
if 对象.
布局
在
稀疏块布局
否则
无
)
完整掩码 =
PyTorch.
一(
对象.
形状,
设备=
对象.
设备,
数据类型=
PyTorch.
布尔值
).转换为稀疏格式(
布局=
对象.
布局,
块大小=
块大小,
稠密维度=
对象.
稠密维度(),
)
对象 =
对象.
转换为稠密格式().sparse_mask(full_mask)
if 对象.
布局
是
PyTorch.
稀疏 COO:
d.更新(
索引=
对象.
索引(),
是否合并=
对象.
是否合并()
)
values = 对象.
值()
如果...否则
对象.
布局
在 {
PyTorch.
稀疏压缩存储格式,
PyTorch.
稀疏_bsr}:
d.更新(
压缩索引=
对象.
鸡索引(),
平凡索引=
对象.
列索引(),
)
values = 对象.
值()
否则:
d.更新(
压缩索引=
对象.
c 列索引(),
平凡索引=
对象.
行索引(),
)
values = 对象.
值()
新参数.
扩展(
(分步表示, d,
值.
需要梯度_(True))
)
否则:
新参数.
添加(
对象)
返回
元组(
新参数)
def 从分块表示恢复(
参数):
"从它们的步长表示中恢复非步长可微张量。"
new_args = 输入文本为空，请提供需要翻译的文本
args = 列表(
参数)
当
参数:
a = 参数.
流行(0)
if a == 分步表示:
d, values = 参数.
流行(0),
参数.
流行(0)
if d[布局]
是
PyTorch.
稀疏 COO:
a = PyTorch.
稀疏 Coo 张量(
d[索引
]
值,
尺寸=d[
"形状"
]
是否合并=d[
是否合并
]
)
如果...否则 d[
布局]
在
稀疏压缩布局:
a = PyTorch.
稀疏压缩张量(
d[压缩索引
]
d["普通索引"
]
值,
尺寸=d[
"形状"
]
布局=d[
布局
]
)
否则:
抛出
不支持的操作异常(
f转换{d[
布局]}
步长表示转换为张量'
)
新参数.
添加(a)
返回
元组(
新参数)
def 函数包装器(*
参数, **kwargs):
恢复参数 =
从分块表示恢复(
参数)
# 将可微输出稀疏张量转换为分块
# 张量：
输出 =
函数(*
恢复参数, **kwargs)
步长输出 = (
元组(
输出) if isinstance(
输出, (
列表,
元组))
否则 (
输出,)
)
步长输出 =
元组(
(
o.转换为稠密格式(
掩码梯度=
遮蔽)
if isinstance(o, PyTorch.
张量)
和 o.
需要梯度
和 o.
布局
在
稀疏布局
否则 o
)
为 o
在
步长输出
)
返回 (
步长输出
if isinstance(输出, (
列表,
元组))
否则
步长输出[0]
)
args = (函数包装器,
转换为步长表示形式(
输入))
返回 gradcheck(*
参数, **kwargs)
返回 gradcheck_with_sparse_support
