""
此模块包含张量创建工具。
""
导入 collections.abc
导入 functools
导入
数学
导入
警告
from 打字
导入
角色,
可选,
联合
导入
火炬
_INTEGRAL_TYPES = [
火把.uint8,
火把.int8,
火把.int16,
火把.int32,
火把.int64,
火把.uint16,
火把.uint32,
火把.uint64,
]
浮点类型 = [
火把.float16,
火把.bfloat16,
火把.float32,
火把.float64]
浮点 8 位类型 = [
火把.float8_e4m3fn,
火把.float8_e5m2,
火把.float8_e4m3fnuz,
火把.float8_e5m2fnuz,
]
复杂类型 = [
火把.complex32,
火把.complex64,
火把.complex128]
布尔或整型类型 = [
火把.
布尔, *
整数类型]
浮点或复数类型 = [*
浮点类型, *
复数类型]
定义
_均匀随机_(t:
火把.
张量,
低: float,
高: float) ->
火把.
张量:
# 均匀_要求 to-from <= std::numeric_limits::max()
# 通过在 PRNG 之前和之后缩放范围来解决这个问题
如果
高 -
低 >=
火把.finfo(t.
数据类型).
最大值:
返回 t.
均匀的(
低 / 2,
高 / 2).mul_(2)
else:
返回 t.
均匀的(
低,
高)
[文档]
定义
创建张量(
*shape: 联盟[
整数,
火把.
尺寸,
列表[
整数
]
元组[
整数, ...]],
数据类型:
火把.
数据类型,
设备:
联盟[
字符串,
火把.
设备
]
低:
可选[float] =
无,
高:
可选[float] =
无,
需要梯度:
布尔 =
错误,
不连续的:
布尔 =
错误,
排除零:
布尔 =
错误,
内存格式:
可选[
火把.
内存格式] =
无,
) -> 火把.
张量:
r创建具有给定 :attr:`shape`、:attr:`device` 和 :attr:`dtype` 的张量，并用从 ``[low, high)`` 中均匀抽取的值填充。
如果指定了 :attr:`low` 或 :attr:`high`，并且它们超出了 :attr:`dtype` 可表示的有限值范围，则它们将被分别夹到最低或最高的可表示有限值。
如果 :attr:`low` 或 :attr:`high` 被指定并且超出了 :attr:`dtype` 可表示的有限值范围，则它们将被分别夹到最低或最高的可表示有限值。
如果 :attr:`low` 或 :attr:`high` 被指定并且超出了 :attr:`dtype` 可表示的有限值范围，则它们将被分别夹到最低或最高的可表示有限值。
如果为 ``None``，则下表描述了 :attr:`low` 和 :attr:`high` 的默认值，
它们依赖于 :attr:`dtype`。
+---------------------------+------------+----------+
| ``dtype`` | ``low`` | ``high`` |
+===========================+============+==========+
| boolean 类型 | ``0`` | ``2`` |
+---------------------------+------------+----------+
| 无符号整型类型 | ``0`` | ``10`` |
+---------------------------+------------+----------+
| 有符号整型类型 | ``-9`` | ``10`` |
+---------------------------+------------+----------+
| 浮点类型 | ``-9`` | ``9`` |
+---------------------------+------------+----------+
复杂类型 | ``-9`` | ``9`` |
+---------------------------+------------+----------+
参数：
形状（元组[int, ...]）：单个整数或定义输出张量形状的整数序列。
输入张量的数据类型（:class:`torch.dtype`）。
设备（联合[str, torch.device]）：返回张量的设备。
low（可选[Number]）：设置给定范围的下限（包含）。如果提供数字，则将其限制为给定数据类型的最低可表示有限值。当为 ``None``（默认值）时，此值根据 ``dtype``（见上表）确定。默认：``None``。
high（可选[Number]）：设置给定范围的上限（排除）。如果提供数字，则将其限制为给定数据类型的最高可表示有限值。
high（可选[Number]）：设置给定范围的上限（排除）。如果提供数字，则将其限制为给定数据类型的最高可表示有限值。
high（可选[Number]）：设置给定范围的上限（排除）。如果提供数字，则将其限制为给定数据类型的最高可表示有限值。
被限制在给定数据类型的最大可表示有限值。当为 ``None``（默认值）时，此值
将基于 :attr:`dtype`（见上表）确定。默认值：``None``。
已在 2.1 版本中弃用
对于浮点型或复数类型，将 ``low==high`` 传递给 :func:`~torch.testing.make_tensor` 已弃用
自 2.1 版本开始使用，将在 2.3 版本中删除。请使用 :func:`torch.full` 代替。
requires_grad (可选[bool])：如果 autograd 应记录对返回张量的操作。默认：``False``。
noncontiguous (可选[bool])：如果为 `True`，则返回的张量将是非连续的。如果构造的张量元素少于两个，则忽略此参数。与 ``memory_format`` 互斥。
如果构造的张量元素少于两个，则忽略此参数。与 ``memory_format`` 互斥。
exclude_zero (Optional[bool]): 如果 ``True``，则将零替换为 dtype 的小正数值
根据 :attr:`dtype`。对于布尔型和整型，零被替换为一。对于浮点型
点类型被替换为 dtype 的最小正正常数（“微小”值）
:attr:`dtype` 的 :func:`~torch.finfo` 对象)，对于复杂数据类型则用复数替换
其实部和虚部都是可以表示的最小正正常数
类型。默认 ``False``。
memory_format（可选[torch.memory_format]）：返回张量的内存格式。互斥
使用“非连续”的。
抛出异常：
ValueError：如果为整型 `dtype` 传递了 `requires_grad=True`
ValueError：如果 `low >= high`
ValueError：如果任一 :attr:`low` 或 :attr:`high` 是 `nan`
ValueError：如果同时传递了 :attr:`noncontiguous` 和 :attr:`memory_format`
如果 :attr:`dtype` 不支持此函数。
示例：
>>> # xdoctest: +SKIP
>>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_CUDA)
>>> 从 torch.testing 导入 make_tensor
>>> # 创建一个值在 [-1, 1) 的浮点张量
>>> make_tensor((3,), device='cpu', dtype=torch.float32, low=-1, high=1)
>>> # xdoctest: +SKIP
tensor([0.1205, 0.2282, -0.6380])
>>> 创建一个 CUDA 上的布尔张量
>>> make_tensor((2, 2), device='cuda', dtype=torch.bool)
tensor([[False, False],
[[False, True]], 设备='cuda:0'
"文档"
定义
修改低高(
低:
可选[float
]
高:
可选[float
]
*,
最低（包含）: float,
最高（不包含）: float,
默认低: float,
默认高: float,
) -> 元组[float, float
]：
""
修改（并在适当的情况下引发 ValueError）用户给出的低和高值（input_low，input_high）
如果需要的话。
"文档"
定义
卡钳(a: float, l: float, h: float) -> float:
返回
最小(
最大值(a, l), h)
低 =
低
如果
低
是
不
无
否则
默认低
高 =
高
如果
高
是
不
无
否则
默认高
如果
任何(isinstance(
值, float)
并且
数学.isnan(
值) for
值
在 [
低,
高
)]
raise ValueError(
f"`低` 和 `高` 不能是 NaN，但是得到了{
低=}
和{
高=}"
)
elif 低 ==
高
并且 dtype
在
_浮点或复数类型:
警告.
警告(
"将 `low==high` 传递给 `torch.testing.make_tensor` 用于浮点或复数类型"
"自 2.1 版本开始已弃用，将在 2.3 版本中删除。"
"请使用 `torch.full(...)` 代替。",
未来警告,
栈级别=3,
)
elif 低 >=
高:
raise ValueError(f"要求 `low` 必须小于 `high`，但得到"{
低}
≥{
高}")
elif 高 <
最低包含值
或者
低 >=
最高不包含值:
raise ValueError(
f由 `low` 和 `high` 指定的值区间为 [{
低}, {
高}
)
f但是{
数据类型}
只支持[{
最小值（包含）}, {
最大值（不包含）})"
)
低 =
卡钳(
低,
最低包含值,
最高不包含值)
高 =
卡钳(
高,
最低包含值,
最高不包含值)
如果 dtype
在
_布尔或整型类型:
# 1. `low` 被向上取整以避免创建小于 `low` 的值，从而超出指定区间
# 2. 根据 1.中的相同推理，`high` 应该向下取整。然而，上界为
# `torch.randint` 是排他的，因此这里也需要向上取整。
返回
数学.
向上取整(
低),
数学.
向上取整(
高)
返回
低,
高
如果
长度(shape) == 1
并且 isinstance(shape[0
]
集合.abc.
序列):
形状 = shape[0]
# 类型：忽略[赋值]
形状 =
角色(
元组[
整数, ...
]
元组(shape))
如果
非连续的
并且
内存格式
是
不
无:
raise ValueError(
f"参数 `noncontiguous` 和 `memory_format` 是互斥的，"
f"但得到了"{
不连续的=}
和{
内存格式=}"
)
如果 requires_grad
并且 dtype
在
_布尔型或整型类型:
raise ValueError(
f"不支持布尔型和整型数据类型的 `requires_grad=True`，但得到了"{
数据类型=}"
)
非连续的 =
非连续的
并且 functools.
减少(lambda x, y: x * y, shape, 1) > 1
如果
不连续的:
在最后一个维度上加倍形状的大小，以便我们在进行非连续操作时具有非相同的值。
当我们进行非连续操作时，将具有非相同的值。
形状 =
角色(
元组[
整数, ...
] (*shape
[-1
] 2 * shape[-1]))
如果 dtype
是
火把.
布尔:
低,
高 =
角色(
元组[
整数,
整数
]
修改低高(
低,
高,
最小值（包含）=0,
最高排他=2,
默认低=0,
默认高=2,
),
)
结果 =
火把.
随机整数(
低,
高, shape,
设备=
设备,
数据类型=
数据类型)
elif dtype 在
_布尔或整型类型:
低,
高 =
角色(
元组[
整数,
整数
]
修改低高(
低,
高,
最小值包含=
火把.iinfo(
数据类型).
最小,
highest_exclusive=火把.iinfo(
数据类型).
最大
理论上，`highest_exclusive` 应该总是最大值加 1。然而，`torch.randint`
内部将边界转换为 int64，可能会溢出。换句话说：`torch.randint` 无法
样本 2**63 - 1，即 `torch.int64` 的最大值，我们需要在这里考虑这一点。
+ (1 如果 dtype
是
不
火把.
int64 类型
否则 0),
# 这对于 `torch.uint8` 是不正确的，但因为我们将其限制为 `lowest`，即对于 `torch.uint8` 的 0，
# 在使用默认值之后，我们在这里不需要特别处理
默认低=-9,
默认高=10,
),
)
结果 =
火把.
随机整数(
低,
高, shape,
设备=
设备,
数据类型=
数据类型)
elif dtype 在
浮点或复杂类型:
低,
高 =
修改低高(
低,
高,
最小值（包含）=
火把.finfo(
数据类型).
最小,
最大值（不包含）=
火把.finfo(
数据类型).
最大值,
默认低=-9,
默认高=9,
)
结果 =
火把.
空的(shape,
设备=
设备,
数据类型=
数据类型)
_均匀随机_(
火把.
真实查看(
结果)
如果 dtype
在
_复杂类型_
否则
结果,
低,
高
)
elif dtype 在
浮动 8 位类型:
低,
高 =
修改高低(
低,
高,
最小值（包含）=
火把.finfo(
数据类型).
最小,
最大值（不包含）=
火把.finfo(
数据类型).
最大值,
默认低=-9,
默认高=9,
)
结果 =
火把.
空的(shape,
设备=
设备,
数据类型=
火把.float32)
_均匀随机_(
结果,
低,
高)
结果 =
结果.
到(
数据类型)
else:
raise 类型错误(
f"请求的数据类型 '{
数据类型}
torch.testing.make_tensor() 不支持。
"要请求支持，请在此处提交问题：https://github.com/pytorch/pytorch/issues"
)
如果
不连续的:
# 向前偏移 1 以捕获偏移问题
结果 =
结果[..., 1::2]
elif 内存格式
是
不
无:
结果 =
结果.
克隆(
内存格式=
内存格式)
如果
排除零值:
结果[
结果 == 0] = (
1 如果 dtype
在
_布尔或整型类型
否则
火把.finfo(
数据类型).
微型
)
如果 dtype
在
_浮点或复数类型:
结果.requires_grad = requires_grad
返回
结果
