# mypy: 允许未类型化定义
导入 contextlib
导入 dataclasses
导入
数学
导入
文本换行
来自
打字
导入
任何,
可选
导入
火炬
来自
火炬
导入
无穷
@dataclasses.数据类
类
__打印机选项:
precision: 整型 = 4
阈值:
浮点数 = 1000
边缘项目:
整型 = 3
线宽:
整型 = 80
科学模式:
可选[bool] =
无
打印选项 =
打印机选项()
我们可以使用 **kwargs，但这将提供更好的文档
[文档]def
设置打印选项(
precision=无,
阈值=
无,
边缘元素=
无,
线宽=
无,
个人资料=
无,
sci 模式=
无,
):
r设置打印选项。毫不客气地借鉴了 NumPy
参数：
精度：浮点数输出的有效数字位数
（默认 = 4）。
阈值：触发汇总的数组元素总数
而不是完整的 `repr`（默认 = 1000）。
edgeitems：在汇总的开始和结束处每个维度的数组元素数量（默认 = 3）。
每个维度的数组元素数量（默认 = 3）。
行宽：每行字符数，用于
插入换行符（默认=80）。阈值矩阵将
忽略此参数。
配置文件：为美观打印设置合理的默认值。可以使用以下任何一项进行覆盖。
上述选项。（`default`、`short`、`full`中的任意一个）
科学模式：启用（True）或禁用（False）科学记数法。如果
未指定（默认），值由定义
`torch._tensor_str._Formatter`。此值自动选择
通过框架。
示例::
>>> # 限制元素的精度
>>> torch.set_printoptions(precision=2)
>>> torch.tensor([1.12345])
tensor([1.12])
>>> 限制显示元素的数量
>>> 设置 torch 的打印选项，阈值设为 5
>>> torch.arange(10)
tensor([0, 1, 2, ..., 7, 8, 9])
>>> # 恢复默认设置
>>> torch.set_printoptions(profile='default')
>>> torch.tensor([1.12345])
tensor([1.1235])
>>> torch.arange(10)
tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
"""
如果 profile
是
不
无:
如果
个人资料 ==
默认:
打印选项.
精度 = 4
打印选项.
阈值 = 1000
打印选项.
边缘项目 = 3
打印选项.
线宽 = 80
如果...否则
个人资料 ==
简短:
打印选项.
精度 = 2
打印选项.
阈值 = 1000
打印选项.
边缘项目 = 2
打印选项.
线宽 = 80
如果...否则
配置文件 ==
全部:
打印选项.
精度 = 4
打印选项.
阈值 =
无
打印选项.
边缘项目 = 3
打印选项.
线宽 = 80
如果
精度
是
不
无:
打印选项.
精确度 =
精确度
如果
阈值
是
不
无:
打印选项.
阈值 =
阈值
如果
边缘项目
是
不
无:
打印选项.
边缘项目 =
边缘项目
如果
线宽
是
不
无:
打印选项.
线宽 =
线宽
打印选项.
科学模式 =
科学模式
def get_printoptions() -> 字典[str,
任何
]
r获取当前打印选项，作为一个字典，可以传递给 set_printoptions() 函数作为 **kwargs 参数。
可以传递给 set_printoptions() 函数作为 **kwargs 参数。
"""
返回 dataclasses.asdict(
打印选项)
@contextlib.contextmanager
def 打印选项(**kwargs):
r"""上下文管理器，临时更改打印选项。接受的参数与 :func:`set_printoptions` 相同。"""
参数与 :func:`set_printoptions` 相同。
old_kwargs = get_printoptions()
设置打印选项(**kwargs)
尝试:
产生
最后:
设置打印选项(**old_kwargs)
def 张量类型转换(t):
dtype = (
PyTorch.
浮点数
如果 (
t.是_mps
或者 (t.
是_xpu
和
不
PyTorch.xpu.
获取设备属性(t.
设备).
支持_fp64)
)
否则
PyTorch.double
)
返回 t.
到(
数据类型=
数据类型)
类
_格式化器:
def __init__(self, 张量):
self.浮点类型 =
张量.
数据类型.
是否为浮点数
self.整数模式 =
真实
self.科学计数法模式 =
假
self.最大宽度 = 1
替换为
PyTorch.
不梯度():
张量视图 =
张量.
重塑(-1)
如果
不 self.
浮点数据类型:
for 值
在
张量视图:
value_str = f"{value}"
self.最大宽度 =
最大值(self.
最大宽度,
长度(value_str))
否则:
非零有限值 =
PyTorch.
遮蔽选择(
张量视图,
PyTorch.
是有限的(
张量视图) &
张量视图.
不(0)
)
如果
非零有限值.
元素数量() == 0:
# 无效数字，不执行任何操作
返回
如果
张量.dtype ==
PyTorch.float8_e8m0fnu:
# 类型：忽略[已定义]
# float8_e8m0fnu 是特殊的，不定义算术运算，
# 并且在此文件中打印代码进一步假设存在
计算各种算术运算以确定要打印的内容。我们进行破解
并将其转换为浮点数，以便正确打印。
TODO(#113663)：在添加对这些数据类型的支持后，也在这里添加它们。
支持被移除
非零有限值 =
非零有限值.float()
将其转换为双精度浮点数以便于计算。HalfTensor 在 1e8 时溢出，CPU 上没有 div()函数。
非零有限绝对值 =
张量类型(
非零有限值.
绝对值())
非零有限最小值 =
张量类型转换(
非零有限绝对值.
最小值())
非零有限最大值 =
张量类型转换(
非零有限绝对值.
最大值())
for 值
在
非零有限值:
如果
值 !=
PyTorch.
向上取整(value):
self.整数模式 =
假
断开
如果 self.
整数模式:
对于浮点数，在 int_mode 模式下，所有数字都被视为整数，对于非终结数，我们附加一个小数点
为了表示张量是浮点类型。长度加 1 以考虑这一点。
如果 (
非零有限最大值 /
非零有限最小值 > 1000.0
或者
非零有限最大值 >
100000000
):
self.科学模式 =
真实
for 值
在
非零有限值:
字符串值 = f"{{:.{
打印选项.precision}e}}".
格式(value)
self.最大宽度 =
最大值(self.
最大宽度,
长度(
字符串值))
否则:
for 值
在
非零有限值:
字符串值 = f"{value:.0f}"
self.最大宽度 =
最大值(self.
最大宽度,
长度(
字符串值) + 1)
否则:
检查是否应使用科学表示法。
如果 (
非零有限最大值 /
非零有限最小值 > 1000.0
或者
非零有限最大值 >
100000000
或者
非零有限最小值 <
0.0001
):
self.科学模式 =
真实
for 值
在
非零有限值:
字符串值 = f"{{:.{
打印选项.precision}e}}".
格式(value)
self.最大宽度 =
最大值(self.
最大宽度,
长度(
字符串值))
否则:
for 值
在
非零有限值:
字符串值 = f"{{:.{
打印选项.precision}f}}".
格式(value)
self.最大宽度 =
最大值(self.
最大宽度,
长度(
字符串值))
如果
打印选项.
科学模式
是
不
无:
self.科学模式 =
打印选项.
科学模式
def 宽度(self):
返回 self.
最大宽度
def 格式(self, value):
如果 self.
浮点数据类型:
如果 self.
科学模式:
返回 = f"{{:{self.
最大宽度}.{
打印选项.precision}e}}".
格式(value)
如果...否则 self.
整型模式:
返回 = f"{value:.0f}"
如果
不 (
数学.
判断是否为无穷大(value)
或者
数学.isnan(value)):
返回 += "."
否则:
返回 = f"{{:.{
打印选项.precision}f}}".
格式(value)
否则:
返回 = f"{value}"
返回 (self.
最大宽度 -
长度(
返回)) *
输入文本为空，请提供需要翻译的文本 +
返回
def _标量字符串(self,
格式化器 1,
格式化器 2=
无):
如果 formatter2
是
不
无:
real_str = _scalar_str(self.真实, formatter1)
imag_str = (_标量_str(self.
图像, formatter2) + "j").
去除字符串左侧空白字符()
处理负数、+0.0、-0.0
如果 imag_str[0] == "+"
或者 imag_str[0] ==
破折号:
返回
真实字符串 +
虚拟字符串
否则:
返回
真实字符串 + "+" + imag_str
否则:
返回 formatter1.
格式(self.
项目())
def _vector_str(self, indent, 摘要,
格式化器 1,
格式化器 2=
无):
# 长度包括空格和元素之间的逗号
元素长度 =
格式化器 1.
宽度() + 2
如果
格式化器 2
是
不
无:
# imag_formatter 的宽度 + 一个额外的 j 用于复杂情况
元素长度 +=
格式化器 2.
宽度() + 1
每行元素数 =
最大值(
1, int(数学.
向下取整((
打印选项.
线宽 -
缩进) / (
元素长度)))
)
def _值格式化器(val,
格式化器 1=
格式化器 1,
格式化器 2=
格式化器 2):
如果 formatter2
是
不
无:
real_str = formatter1.格式(val.
真实)
imag_str = (formatter2.格式(val.
图像) + "j").
去除字符串左侧空白字符()
# 处理负数，+0.0，-0.0
如果 imag_str[0] ==
“+”
或者
图像字符串[0] ==
破折号:
返回
实际字符串 +
图像字符串
否则:
返回 real_str +
加号 + imag_str
否则:
返回 formatter1.
格式(val)
如果
概括
和
不
打印选项.
边缘项目:
# 处理边缘情况，负零等于零
数据 = [
...]
如果...否则
摘要
和 self.
尺寸(0) > 2 *
打印选项.
边缘元素:
数据 = (
[_值格式化器(val) for val
在 self
[
打印选项.
边缘元素].
转列表()]
+ ["……"]
+ [_值格式化器(val) for val
在 self[-
打印选项.
边缘项目
].
转列表()]
)
否则:
数据 = [
_值格式化器(val) for val
在 self.
转列表()]
数据行 = [
数据[i : i +
元素每行] for i
在
范围(0,
长度(
数据),
元素每行)
]
行 = [
“，”.
连接(
行) for
行
在
数据行]
返回
[ + (
逗号 + "
输入文本翻译为简体中文为：\n" +
输入文本为空，请提供需要翻译的文本 * (
缩进 + 1)).
连接(
行) + "]"
# formatter2 仅用于打印复杂的张量。
# 对于复杂的张量，formatter1 和 formatter2 是 tensor.real 的格式化器。
# and tensor.imag 分别对应
def _tensor_str_with_formatter(self, 缩进,
总结, formatter1, formatter2=
无):
维度 = self.
维度()
如果
维度 == 0:
返回
_标量字符串(self, formatter1,
格式化器 2)
如果
维度 == 1:
返回
向量字符串(self,
缩进,
摘要,
格式化器 1,
格式化器 2)
如果
总结
和 self.
尺寸(0) > 2 *
打印选项.
边缘元素:
切片 = (
[
使用格式化器的_tensor_str(
self[i]
缩进 + 1,
概括,
格式化器 1,
格式化器 2
)
for i 在
范围(0,
打印选项.
边缘项目)
]
+ ["..."]
+ [
_tensor_str_with_formatter(
self[i]
缩进 + 1,
总结,
格式化器 1, formatter2
)
for i 在
范围(
长度(self) -
打印选项.edgeitems,
长度(self))
]
)
否则:
slices = [
_tensor_str_with_formatter(
self[i]
缩进 + 1,
概括,
格式化器 1,
格式化器 2
)
for i 在
范围(0, self.
尺寸(0))
]
tensor_str = (逗号 + "
输入文本翻译为简体中文为：\n" * (
维度 - 1) +
输入文本为空，请提供需要翻译的文本 * (indent + 1)).
连接(
切片)
返回
[ +
张量_str +
`]`
def _tensor_str(self, 缩进):
如果 self.
元素数量() == 0:
返回
`[]`
如果 self.
有名称():
张量打印主要经过两条代码路径（可能还有更多）
- 张量数据可以舒适地显示在屏幕上
- 张量数据需要被总结
- 一些代码路径并不完全支持命名张量，所以我们发送
# 一个未命名的张量作为格式化代码的解决方案。
self = self.重命名(
无)
摘要 = self.
元素数量() >
打印选项.
阈值
如果 self._is_zerotensor():
self = self.克隆()
# 处理负数位
如果 self.
是否定():
self = self.解决否定()
# TODO: 当实现 FP8 的掩码选择时移除我
如果 self.dtype
在 [
PyTorch.float8_e5m2,
PyTorch.float8_e5m2fnuz,
PyTorch.float8_e4m3fn,
PyTorch.float8_e4m3fnuz,
]
self = self.半()
如果 self.
数据类型.
是复杂的:
# 处理共轭位
self = self.解决连词()
实数格式化器 =
_格式化器(
获取总结数据(self.
真实)
如果
摘要
否则 self.
真实
)
图片格式化器 =
_格式化器(
获取摘要数据(self.
图像)
如果
摘要
否则 self.
图像
)
返回
使用格式化器的张量字符串(
self, 缩进,
摘要,
实际格式化器,
图像格式化器
)
否则:
格式化器 =
_格式化器(
获取摘要数据(self)
如果
摘要
否则 self)
返回
使用格式化器的张量字符串(self,
缩进,
总结,
格式化器)
def _添加后缀(
张量字符串,
后缀,
缩进,
强制换行):
矩阵字符串 = [
矩阵字符串]
last_line_len = 长度(tensor_str) - tensor_str.
向后查找("
输入文本翻译为简体中文为：\n") + 1
for 后缀
在 suffixes:
后缀长度 =
长度(
后缀)
如果
强制换行
或者
最后一行长度 +
后缀长度 + 2 >
打印选项.
线宽:
张量字符串.
添加(
“
输入文本翻译为简体中文为：\n" +
输入文本为空，请提供需要翻译的文本 *
缩进 +
后缀)
最后一行长度 =
缩进 +
后缀长度
强制换行 =
假
否则:
张量字符串.
添加(
"，" +
后缀)
最后一行长度 +=
后缀长度 + 2
张量字符串.
添加(
“）”)
返回
输入文本翻译为简体中文为："".
连接(
张量字符串)
def 获取摘要数据(self):
维度 = self.
维度()
如果
维度 == 0:
返回 self
如果
维度 == 1:
如果 self.
尺寸(0) > 2 *
打印选项.
边缘项目:
返回
PyTorch.
猫(
(self[
打印选项.
边缘项目
] self[-
打印选项.
边缘项目
])
)
否则:
返回 self
如果
不
打印选项.
边缘项目:
返回 self.
新空
[0] * self.
维度())
如果...否则 self.
尺寸(0) > 2 *
打印选项.
边缘项目:
开始 = [self[i] for i
在
范围(0,
打印选项.
边缘项目)]
末端 = [self[i] for i
在
范围(
长度(self) -
打印选项.
边缘项目,
长度(self))]
返回
PyTorch.
栈
[
获取总结数据(x) for x
在 (
开始 +
结束
)]])
否则:
返回
PyTorch.
栈
[
获取摘要数据(x) for x
在 self])
def 内部字符串(
输入, *,
张量内容=
无):
如果
PyTorch._C._functorch.
是 functorch 包装的 tensor(
输入文本翻译为简体中文：inp):
返回 _functorch_wrapper_str_intern(inp,
张量内容=
张量内容)
is_plain_tensor = 类型(inp)
是
PyTorch.
张量
或者
类型(
输入)
是
PyTorch.
神经网络.
参数
如果
输入.
是嵌套的:
前缀 =
"嵌套张量（"
如果...否则
是否为普通张量:
前缀 =
tensor(
否则:
前缀 = f"{
类型(
输入).__name__}
(
缩进 =
长度(
前缀)
后缀 =
输入文本为空，请提供需要翻译的文本
自定义提供的内容 =
张量内容
是
不
无
如果
自定义提供的内容:
张量_str =
张量内容
# 用于提取原始值，从而禁用前向自动微分
# 在此函数内部。
# TODO(albanD) 需要更新当支持多级时
self, 切线 =
PyTorch.
自动微分.forward_ad.
解包双倍(
输入)
# 注意 [打印张量设备]:
这里的一般逻辑是，只有当设备不匹配时才打印设备
指定的默认张量类型中的设备。
当前 torch.set_default_tensor_type()仅支持 CPU/CUDA。
只返回 cpu 或 cuda。
在其他情况下，我们还没有办法将它们设置为默认值。
并且我们应该始终为它们打印出设备。
如果 (
self.设备.
类型 !=
PyTorch._C._get_default_device()
或者 (
self.设备.
类型 == "cuda"
和
PyTorch.cuda.
当前设备() != self.
设备.
索引
)
或者 (self.
设备.
类型 ==
国会议员)
):
后缀.
添加(
"设备='" + str(self.
设备) + "'")
张量打印执行张量操作，如切片、索引等，以便将其
这些操作在 ipu/xla/lazy/mtia 张量结果上会导致编译。因此，
为了避免编译，在打印之前将张量复制到 CPU。
如果 self.
设备.
类型
在 ["xla",
懒惰,
知识产权,
翻译
]
self = self.到("cpu")
TODO：添加一个将真实数据类型映射到复杂数据类型的 API。
_默认复杂数据类型 = (
PyTorch.cdouble
如果
PyTorch.
获取默认数据类型() ==
PyTorch.double
否则
PyTorch.cfloat
)
默认数据类型 = self.dtype
在 (
PyTorch.
获取默认数据类型(),
默认复杂数据类型,
PyTorch.int64,
PyTorch.bool,
)
如果 self.is_sparse:
后缀.
添加(
size= + str(
元组(self.
形状)))
来自 torch._subclasses.fake_tensor
导入
模拟 Tensor
是否是元数据 = self.
是否是元数据
或者 isinstance(self,
假 Tensor)
如果
不 is_meta:
后缀.
添加("nnz=" + str(self._nnz()))
如果
不
默认数据类型:
后缀.
添加(
"数据类型=" + str(self.
数据类型))
如果
不
提供自定义内容:
索引前缀 = "indices=tensor("
索引 = self.
索引().detach()
如果 is_meta:
索引字符串 = "..."
否则:
索引字符串 = _tensor_str(
索引,
缩进 +
长度(
索引前缀))
如果
是否是元数据
或者
索引.
元素数量() == 0:
索引字符串 +=
", 大小=" + str(
元组(
索引.
形状))
值前缀 = "values=tensor("
values = self.值().detach()
如果 is_meta:
values_str = "..."
否则:
values_str = _tensor_str(值,
缩进 +
长度(values_prefix))
如果
是元数据
或者
值.
元素数量() == 0:
values_str += ", 大小=" + str(
元组(
值.
形状))
张量_str = (
索引前缀
+ 索引字符串
+ ")
输入文本翻译为简体中文为：\n"
+ 输入文本为空，请提供需要翻译的文本 *
缩进
+ 值前缀
+ 值字符串
+ ）"
)
如果...否则 self.
布局
在 {
PyTorch.
稀疏压缩存储格式,
PyTorch.
稀疏压缩存储格式,
PyTorch.
稀疏_bsr,
PyTorch.
稀疏矩阵,
}:
来自 torch._subclasses.fake_tensor
导入
模拟 Tensor
后缀.
添加(
"大小=" + str(
元组(self.
形状)))
是否是元数据 = self.
是否是元数据
或者 isinstance(self,
假 Tensor)
如果
不
是否是元数据:
后缀.
添加("nnz=" + str(self._nnz()))
如果
不 has_default_dtype:
suffixes.添加("dtype=" + str(self.
数据类型))
如果
不
自定义内容提供:
压缩索引方法,
纯索引方法 = {
PyTorch.
稀疏压缩存储格式: (
PyTorch.
张量.
鸡索引,
PyTorch.
张量.
列索引),
PyTorch.
稀疏压缩存储格式: (
PyTorch.
张量.
c 列索引,
PyTorch.
张量.
行索引),
PyTorch.
稀疏_bsr: (
PyTorch.
张量.
鸡索引,
PyTorch.
张量.
列索引),
PyTorch.
稀疏矩阵: (
PyTorch.
张量.
c 列索引,
PyTorch.
张量.
行索引),
}self.
布局]
如果 self.
布局
在 {
PyTorch.
稀疏压缩存储格式,
PyTorch.
稀疏_bsr}:
cdim 名称,
pdim 名称 =
行,
列
否则:
cdimname, pdimname = 列,
行
压缩索引前缀 = f
c{cdimname
[3]}_indices=tensor("
压缩索引 =
压缩索引方法(self).detach()
如果 is_meta:
compressed_indices_str = "..."
否则:
compressed_indices_str = _tensor_str(
压缩索引,
缩进 +
长度(compressed_indices_prefix)
)
如果
压缩索引.
元素数量() == 0
或者 is_meta:
压缩索引字符串 +=
", 大小=" + str(
元组(
压缩索引.
形状)
)
索引前缀 = f"{pdimname
[3]}_indices=tensor("
平凡索引 =
索引方法(self).detach()
如果
是否是元数据:
索引字符串 = "..."
否则:
平常索引字符串 = _tensor_str(
平凡索引,
缩进 +
长度(
平常索引前缀)
)
如果
平凡索引.
元素数量() == 0
或者
是否是元数据:
平常索引字符串 +=
", 大小=" + str(
元组(
平凡索引.
形状))
values_prefix = "values=tensor("
values = self.值().detach()
如果
是否是元数据:
值字符串 = "..."
否则:
值字符串 = _tensor_str(
值,
缩进 +
长度(
值前缀))
如果
值.
元素数量() == 0
或者
是否元数据:
值字符串 +=
", 大小=" + str(
元组(
值.
形状))
张量_str = (
压缩索引前缀
+ 压缩索引字符串
+ "),输入文本翻译为简体中文为：\n"
+ 输入文本为空，请提供需要翻译的文本 *
缩进
+ 纯索引前缀
+ 平凡索引字符串
+ "),输入文本翻译为简体中文为：\n"
+ 输入文本为空，请提供需要翻译的文本 *
缩进
+ 值前缀
+ 值字符串
+ ）"
)
如果...否则 self.
是否量化:
后缀.
添加(
size= + str(
元组(self.
形状)))
如果
不
默认数据类型:
后缀.
添加("dtype=" + str(self.
数据类型))
后缀.
添加(
"量化方案=" + str(self.
q 方案()))
如果 (
self.q 方案() ==
PyTorch.
每张张量仿射
或者 self.
q 方案() ==
PyTorch.
每张张量对称
):
后缀名.
添加(
scale= + str(self.q_scale()))
后缀.
添加(
"零点=" + str(self.q_zero_point()))
如果...否则 (
self.q 方案() ==
PyTorch.
单通道仿射
或者 self.
q 方案() ==
PyTorch.
单通道对称
或者 self.
q 方案() ==
PyTorch.
单通道仿射浮点 Q 参数
):
后缀.
添加("scale=" + str(self.
每通道缩放的 q()))
后缀.
添加("zero_point=" + str(self.
q_per_channel_zero_points
q_per_channel_零点()))
后缀.
添加(
"轴=" + str(self.
每通道轴的 q()))
如果
不
自定义提供的内容:
张量_str = _tensor_str(self.
反量化(),
缩进)
如果...否则 self.
是嵌套的:
如果
不
自定义提供的内容:
def 缩进字符串(s,
缩进):
返回 "
输入文本翻译为简体中文为：\n".
连接(f" {
行}" for
行
在 s.
分割("
输入文本翻译为简体中文为：\n"))
字符串 =
“
输入文本翻译为简体中文为：\n".
连接(
缩进字符串(str(t),
缩进 + 1)
for t 在
PyTorch.
操作.aten.
解绑.int(self, 0)
)
张量_str = f"[
输入文本翻译为简体中文为：\n{strs}
输入文本翻译为简体中文为：\n]"
如果...否则
PyTorch._is_functional_tensor(self):
前缀 = "_to_functional_tensor("
张量_str =
表示(
PyTorch._from_functional_tensor(self))
否则:
# 循环导入问题，因此在此处导入
来自 torch._subclasses.fake_tensor
导入
模拟 Tensor
如果 self.is_meta
或者 isinstance(self,
假 Tensor):
后缀.
添加(
size= + str(
元组(self.
形状)))
如果 self.dtype !=
PyTorch.
获取默认数据类型():
后缀.
添加(
dtype= + str(self.
数据类型))
# TODO：这表示省略号是分配的合法语法
# 这是一个元张量或 FakeTensor，它可能是，但现在并不正确
如果
不
自定义提供的内容:
张量_str = "..."
否则:
如果 self.
元素数量() == 0
和
不 self.is_sparse:
# 如果形状不是(0,)，则显式打印形状，以匹配 NumPy 的行为
如果 self.
维度() != 1:
后缀.
添加("size=" + str(
元组(self.
形状)))
# 在一个空张量中，没有元素可以推断其数据类型
# 因此必须显式地指定为 int64。
如果 self.dtype !=
PyTorch.
获取默认数据类型():
后缀.
添加("dtype=" + str(self.
数据类型))
如果
不
自定义提供的内容:
张量_str =
`[]`
否则:
如果
不
打印选项.
边缘项目:
后缀.
添加(
"大小=" + str(
元组(self.
形状)))
如果
不
具有默认数据类型:
后缀.
添加(
"数据类型=" + str(self.
数据类型))
如果
不
自定义提供的内容:
如果 self.
布局 !=
PyTorch.strided:
张量_str = _tensor_str(self.
转换为稠密格式(),
缩进)
否则:
张量_str = _tensor_str(self,
缩进)
如果 self.
布局 !=
PyTorch.strided:
后缀.
添加(
"布局=" + str(self.
布局))
# 使用 inp 来获取原始 grad_fn，而不是由 forward grad 生成的那个
# 解包。
grad_fn_name = 无
尝试:
grad_fn = 输入.grad_fn
除了
运行时错误:
# 访问 grad_fn 调用重置逻辑，这会导致错误
# 如果该张量是在无梯度模式下创建的视图，并在原地修改
无梯度模式。参见：https://github.com/pytorch/pytorch/issues/99968
grad_fn_name = "无效"
如果 grad_fn_name
是
无
和 grad_fn
是
不
无: # type: ignore[possibly-undefined]
grad_fn_name = 类型(grad_fn).__name__
如果 grad_fn_name ==
Cpp 函数名:
grad_fn_name = grad_fn.名称().
右分割(
双冒号, 1
)]-1]
如果 grad_fn_name
是
不
无:
后缀.
添加(f
"grad_fn=<"{grad_fn_name}>")
如果...否则
输入.
需要梯度:
后缀.
添加(
requires_grad=True)
如果 self.
有名称():
后缀.
添加(f
names={self.names}")
如果
切线
是
不
无:
后缀.
添加(f
"切线="{
切线}")
字符串表示 =
_添加后缀(
前缀 +
张量字符串, # type: ignore[possibly-undefined]
后缀,
缩进,
强制换行=self.is_sparse,
)
# 检查此实例是否被标记为参数并相应地更改 repr。
# 很遗憾，这个函数必须知道这个细节。
# 注意：目前为了保持向后兼容性，对于普通张量参数要跳过此操作。
# 在未来，这也应该适用于那些参数以生成有效的 repr。
如果 isinstance(self,
PyTorch.
神经网络.
参数)
和
不 is_plain_tensor:
string_repr = f参数({string_repr})"
返回
字符串表示
def _functorch_wrapper_str_intern(张量, *,
张量内容=
无):
级别 =
PyTorch._C._functorch.
可能获得等级(
张量)
断言
等级 != -1
如果
PyTorch._C._functorch.
是功能性张量(
张量):
解包 FunctionalTensorWrapper 时，我们需要确保它是最新的
首先
PyTorch.
同步_(
张量)
值 =
PyTorch._C._functorch.
获取解包后的(
张量)
值表示 =
表示(value)
缩进值表示 = textwrap.
缩进(
值表示,
输入文本为空，请提供需要翻译的文本 * 4)
如果
PyTorch._C._functorch.is_batchedtensor(
张量):
bdim = PyTorch._C._functorch.maybe_get_bdim(
张量)
断言 bdim != -1
返回 (
f"BatchedTensor(層級={
層級}
，bdim={bdim}
,值=
输入文本翻译为简体中文为：\n{
缩进值表示}
输入文本翻译为简体中文为：\n)"
)
如果
PyTorch._C._functorch.
是否为 gradtrackingtensor(
张量):
返回 f
GradTrackingTensor(lvl={
级别}
, 值=
输入文本翻译为简体中文为：\n{
缩进值表示}
输入文本翻译为简体中文为：\n)"
如果
PyTorch._C._functorch.
是功能性张量(
张量):
返回 f
"功能性张量(lvl={
级别}
,值=
\n{
值表示})"
抛出
值错误(
我们不知道如何打印这个，请向我们提交一个问题)
def 字符串(self, *,
张量内容=
无):
替换为
PyTorch.
不梯度(),
PyTorch.
工具._python_dispatch.
禁用当前模式():
守卫 =
PyTorch._C.
禁用功能手电筒() # noqa: F841
返回
字符串内联(self,
张量内容=
张量内容)
