# mypy: 允许未类型化定义
来自
打字
导入 Any,
可调用,
可选
r"""
以下约束已实施：
- ``constraints 布尔``
- ``constraints.cat``
- ``constraints.corr_cholesky``
- ``constraints.dependent``
- ``constraints.greater_than(lower_bound)``
- ``约束.大于等于(下界)``
- ``约束.独立(约束, 重新解释的批次维度数)``
- ``约束.整数区间(下界, 上界)``
- ``约束.区间(下界, 上界)``
- ``constraints.less_than(upper_bound)``
- ``constraints.lower_cholesky``
- ``constraints.lower_triangular``
- ``constraints.multinomial``
- ``约束.非负``
- ``约束.非负整数``
- ``约束.单热编码``
- ``约束.正整数``
- ``约束.正的``
- ``约束.正半定``
- ``约束.正定``
- ``约束.实向量``
- ``constraints.real``
- ``constraints.simplex``
- ``constraints.symmetric``
- ``constraints.stack``
- ``约束.正方形``
- ``约束.对称``
- ``约束.单位区间``
"""
导入
火炬
全部 = [
"约束",
布尔值,
"猫",
"相关奇异值分解",
"依赖的",
"依赖属性",
大于,
大于等于,
独立的,
整数区间,
"间隔",
"半开区间",
"是依赖的",
"小于",
"下三角 Cholesky",
"下三角矩阵",
"多项式分布",
"非负",
"非负整数",
"独热编码",
"正数",
"正半定",
正定,
正整数,
实数,
实向量,
"简单",
"正方形",
"堆栈",
"对称的",
"单位区间",
]
[文档]class Constraint:
"""
抽象基类，用于约束。
约束对象表示变量有效的区域，
例如，变量可以在此优化的范围内。
属性：
is_discrete (布尔值): 是否约束空间是离散的。
默认为 False。
event_dim（int）：定义事件的右侧维度数量
meth:`check` 方法将在计算有效性时移除这么多维度
当计算有效性时，将移除这些维度
"""
is_discrete = False # 默认为连续。
event_dim = 0 # 默认为单变量。
[文档] def check(self, value):
"""
返回一个 ``sample_shape + batch_shape`` 的字节张量，表示
每个事件在值中是否满足此约束。
"""
抛出未实现异常
def __repr__(self):
return self.__class__.__name__[1:] + "()"
约束):
"""
变量的支持依赖于其他变量，这些变量的支持是占位符。
这些变量不遵循简单的坐标约束。
参数：
is_discrete (bool): ``.is_discrete`` 的可选值。如果可以静态计算，则无需提供。如果没有提供，访问 ``.is_discrete`` 属性将引发 NotImplementedError。
event_dim (int): ``.event_dim`` 的可选值。如果可以静态计算，则无需提供。如果没有提供，访问 ``.event_dim`` 属性将引发 NotImplementedError。
``.is_discrete`` 属性将引发 NotImplementedError。
event_dim (int): ``.event_dim`` 的可选值。
可以静态计算。如果没有提供，将引发 NotImplementedError 异常。
将引发 NotImplementedError 异常。
"沉浸式翻译"
定义 __init__(
自身, *,
是否离散=NotImplemented,
事件维度=NotImplemented):
自身._is_discrete =
is 离散
自身._event_dim =
事件维度
超级().__init__()
@property
定义
是否离散(
自身) -> bool:
# 类型：忽略[重写]
如果
自身._is_discrete
是 NotImplemented:
抛出
不支持的操作异常(
".is_discrete 无法静态确定")
返回
自身._is_discrete
@property
定义
事件维度(
自身) -> int:
# 类型：忽略[重写]
如果
自身._event_dim
是
未实现:
抛出
不支持的操作异常(
".event_dim 无法静态确定")
返回
自身._event_dim
定义
__调用__(
自身, *,
是否离散=
未实现,
事件维度=
未实现):
"""
支持自定义静态属性的语法：
constraints.dependent(is_discrete=True, event_dim=1)
"沉浸式翻译"
如果
is 离散
是
未实现:
is 离散 =
自身._is_discrete
如果
事件维度
是
未实现:
事件维度 =
自身.
_事件维度
返回 _Dependent(
是否离散=
是否离散,
事件维度=
事件维度)
def 查看(self, x):
抛出
值错误(
"无法确定依赖约束的有效性")
[文档]def is_dependent(constraint):
"""
检查 `constraint` 是否是 `_Dependent` 对象。
Args:
constraint : `Constraint` 对象。
返回值：
``bool``: 如果 ``constraint`` 可以精炼为类型 ``_Dependent``，则为 True，否则为 False。
示例：
>>> 导入 torch
>>> 从 torch.distributions 导入 Bernoulli
>>> from torch.distributions.constraints import is_dependent
>>> dist = Bernoulli(probs=torch.tensor([0.6], requires_grad=True))
>>> constraint1 = dist.arg_constraints["probs"]
>>> constraint2 = dist.arg_constraints["logits"]
>>> for constraint in [constraint1, constraint2]:
>>> 如果 is_dependent(constraint):
>>> 继续执行
"""
判断约束是否为 _Dependent 类型
类 _DependentProperty(
属性, _Dependent):
""
扩展 @property 装饰器，使其像 `Dependent` 约束一样行为
在类上调用时，就像在对象上调用属性一样。
示例::
类 Uniform(Distribution):
def __init__(self, low, high):
self.low = low
self.high = 高
@constraints.dependent_property(是离散=False, 事件维度=0)
def 支持(self):
return constraints.interval(self.low, self.high)
参数：
装饰器中的函数（Callable）：要装饰的函数。
is_discrete（布尔值）：可选值，用于在可以静态计算的情况下指定 ``.is_discrete``。
如果不提供，访问 ``.is_discrete`` 属性将引发 NotImplementedError。
``.is_discrete`` 属性将引发 NotImplementedError。
event_dim（int）：可选的 ``.event_dim`` 值。如果可以静态计算，则
否则，访问 ``.event_dim`` 属性将引发 NotImplementedError。
NotImplementedError
"沉浸式翻译"
def __init__(
self,
函数:
可选[
可调用[..., Any]] =
无,
*,
是否离散:
可选[bool] =
NotImplementedError,
事件维度:
可选[int] =
未实现,
) -> 无:
超级().__init__(
函数)
self._is_discrete = is_discrete
self._event_dim = 事件维度
def __调用__(self,
函数:
可调用[..., Any]) ->
_依赖属性:
# 类型：忽略[重写]
""
支持自定义静态属性的语法：
@constraints.dependent_property(is_discrete=True, event_dim=1)
def support(self): ...
"沉浸式翻译"
返回 _DependentProperty(
函数,
是否离散=self._is_discrete,
事件维度=self._event_dim
)
类
_独立约束(
约束):
""
包装一个约束，通过聚合 `reinterpreted_batch_ndims`-多个维度在 :meth:`check` 中，使得事件只有在所有其独立条目都有效时才有效。
因此，在 :meth:`check` 方法中，只有当所有独立条目都有效时，事件才有效。
独立条目都有效时才有效。
"沉浸式翻译"
def __init__(self, 基本约束,
重新解释的批量维度):
断言 isinstance(
基本约束,
约束)
断言 isinstance(
重新解释的批量维度, int)
断言
重新解释的批量维度
≥ 0
self.基础约束 =
基础约束
self.重新解释的批量维度 =
重新解释的批次维度
超级().__init__()
@property
def 是否离散(self) -> bool:
# 类型：忽略[重写]
返回 self.
基础约束.
是否离散
@property
def 事件维度(self) -> int:
# 类型：忽略[重写]
返回 self.
基础约束.
事件维度 + self.
重新解释的批次维度
def 检查(self, value):
结果 = self.
基础约束.
检查(value)
如果
结果.
暗() <
自我.
重新解释的批次维度:
预期 = self.
基础约束.
事件维度 + self.
重新解释的批量维度
抛出
值错误(
f期望值.dim() >={
预期}
但是得到了{value.
暗淡()}"
)
结果 =
结果.
重塑(
结果.
形状
[
结果.
暗淡() - self.
重新解释的批次维度] + (-1,)
)
结果 =
结果.
所有(-1)
返回
结果
def __repr__(self):
返回 f"{self.
类.__name__[1
]}({
表示(self.
基础约束)}, {self.
重新解释的批次维度})"
类
布尔型(
约束):
""
限制为两个值 `{0, 1}`。
"沉浸式翻译"
是离散的 =
真实
def 检查(self, value):
返回 (
值 == 0) | (
值 == 1)
类
_独热编码(
约束):
""
限制为一维热向量。
"沉浸式翻译"
是否为离散 =
真实
事件维度 = 1
def 检查(self, value):
是布尔值 = (
值 == 0) | (
值 == 1)
是否已归一化 = value.
总和(-1).eq(1)
返回
是布尔值.
所有(-1) &
是否已归一化
类
整数区间(
约束):
""
限制在整数区间 `[lower_bound, upper_bound]`。
"沉浸式翻译"
是否离散 =
真实
def __init__(self, 下界,
上限):
self.下限 =
下限
self.上界 =
上界
超级().__init__()
def 检查(self, value):
返回 (
(值 % 1 == 0) & (self.
下限 <= value) & (
值 <= self.
上限)
)
def __repr__(self):
格式化字符串 = self.
类.__name__[1
]
格式化字符串 += (
f"(下界="{self.
下界}
，上界="{self.
上限})"
)
返回
格式化字符串
类
_整数小于(
约束):
""
限制为整数区间 `(-∞, 上界]`。
"沉浸式翻译"
is 离散 =
真实
def __init__(self, 上限):
self.上界 =
上界
超级().__init__()
def 检查(self, value):
返回 (
值 % 1 == 0) & (
值 <= self.
上限)
def __repr__(self):
格式化字符串 = self.
类.__name__[1
]
格式化字符串 += f
"(上界="{self.
上限})"
返回
格式化字符串
类
_整数大于(
约束):
""
约束到整数区间 `[lower_bound, +∞)`。
"沉浸式翻译"
离散 =
真实
def __init__(self, 下限):
self.下限 =
下限
超级().__init__()
def 检查(self, value):
返回 (
值 % 1 == 0) & (
值
≥ self.
下限)
def __repr__(self):
格式化字符串 = self.
类.__name__[1
]
格式化字符串 += f
"(下限="{self.
下限})"
返回
格式化字符串
类
_实数(
约束):
""
任意约束到扩展实数线 `[-∞, ∞]`。
"沉浸式翻译"
def 检查(self, value):
返回
值 ==
值
对于非数字（NANs）为假。
类
_大于(
约束):
""
约束到实数半线 `(下界, ∞]`。
"沉浸式翻译"
def __init__(self, 下限):
self.下限 =
下限
超级().__init__()
def 检查(self, value):
返回 self.
下限 <
值
def __repr__(self):
格式化字符串 = self.
类.__name__[1
]
格式化字符串 += f
(lower_bound={self.
下限})"
返回
格式化字符串
类
大于等于(
约束):
""
限制在实半线 `[lower_bound, +∞)` 上。
"沉浸式翻译"
def __init__(self, 下限):
self.下限 =
下限
超级().__init__()
def 检查(self, value):
返回 self.
下限 <=
值
def __repr__(self):
格式化字符串 = self.
类.__name__[1
]
格式化字符串 += f
"(lower_bound="{
我.
下界})"
返回
格式化字符串
类
_小于(
约束):
""
将约束限制在实半线 `[-∞, 上界)`。
"沉浸式翻译"
def __init__(self, 上限):
self.上界 =
上界
超级().__init__()
def 检查(self, value):
返回
值 <
自身.
上界
def __repr__(self):
格式化字符串 = self.
类.__name__[1
]
格式化字符串 += f
"(上界="{self.
上限})"
返回
格式化字符串
类
_区间(
约束):
""
将约束为实数区间 `[下界, 上界]`。
"沉浸式翻译"
def __init__(self, 下限,
上限):
self.下限 =
下限
self.上界 =
上界
超级().__init__()
def 检查(self, value):
返回 (self.
下限 <= value) & (
值 <= self.
上限)
def __repr__(self):
格式化字符串 = self.
类.__name__[1
]
格式化字符串 += (
f"(下界="{self.
下限}
, 上限={
自身.
上限})"
)
返回
格式化字符串
类
_半开区间(
约束):
"""
约束到实际区间 `[下界, 上界)`。
"沉浸式翻译"
def __init__(self, 下界,
上限):
self.下限 =
下限
self.上界 =
上界
超级().__init__()
def 查看(self, value):
返回 (self.
下限 <= value) & (
值 < self.
上限)
def __repr__(self):
格式化字符串 = self.
类.__name__[1
]
格式化字符串 += (
f"(下界="{self.
下限}
, 上界={self.
上限})"
)
返回
格式化字符串
类 _Simplex(
约束):
""
将约束限制在内部最深层（最右侧）维度的单位单纯形中。
专门：`x >= 0` 和 `x.sum(-1) == 1`。
"沉浸式翻译"
事件维度 = 1
def 检查(self,
值):
返回 torch.
所有(
值
≥ 0,
暗淡=-1) & ((value.
总和(-1) - 1).
绝对值() <
0.000001)
类
多项式(
约束):
""
将约束为非负整数，其和不超过上限。
由于多项式分布的限制，目前
检查较弱的条件 `value.sum(-1) <= upper_bound`。将来
这可能被加强为 `value.sum(-1) == upper_bound`。
"沉浸式翻译"
是否为离散 =
真实
事件维度 = 1
def __init__(self, 上限):
self.上限 =
上界
定义
检查(self, x):
返回 (x
≥ 0).
所有(
暗淡=-1) & (x.
总和(
暗淡=-1) <= self.
上限)
类
_下三角(
约束):
"""
限制为下三角方阵。
"沉浸式翻译"
事件维度 = 2
def 查看(self, value):
三角值 = value.
三角()
返回 (
三角值 == value).
视图(value.
形状
[-2] + (-1,)).
最小值(-1
)0]
类
_下三角 Cholesky(
约束):
""
限制为具有正对角线的下三角正方形矩阵。
"沉浸式翻译"
事件维度 = 2
def 检查(self, value):
value_tril = value.三角()
下三角 = (
(三角值 == value).
视图(value.
形状
[-2] + (-1,)).
最小值(-1
)0]
)
正对角线 = (value.
对角线(dim1=-2, dim2=-1) > 0).
最小值(-1
)]0]
返回
下三角 &
正对角线
类 _CorrCholesky(
约束):
""
限制为具有正对角线和单位长度行向量的下三角正方形矩阵。
每行向量长度为 1。
"沉浸式翻译"
事件维度 = 2
def 检查(self, value):
托尔 = (
torch.finfo(value.数据类型).eps *
值.
大小(-1) * 10
) # 10 是一个可调整的调整因子
行范数 = torch.
线性代数.
归一化(value.detach(),
暗淡=-1)
单位行范数 = (
行范数 - 1.0).
绝对值().
小于等于(
容差).
所有(
暗淡=-1)
返回
_下三角 Cholesky 分解().
检查(value) &
单元行规范
类
_正方形(
约束):
""
限制为正方形矩阵。
"""
事件维度 = 2
定义
检查(self, value):
返回 torch.full(
尺寸=value.
形状
[-2
]
填充值=(value.
形状[-2] == value.
形状[-1
)]
数据类型=torch.bool,
设备=value.
设备,
)
类
_对称(
_正方形):
"""
将矩阵限制为对称正方形矩阵。
"沉浸式翻译"
def 检查(self, value):
正方形勾选 =
超级().
检查(value)
如果
不是
正方形勾选.
所有():
返回
正方形勾号
返回 torch.isclose(value,
值.mT,
精度=1e-6).
所有(-2).
所有(-1)
类
正定半正定(
对称):
"""
将矩阵约束为正定半正定矩阵。
"沉浸式翻译"
def 检查(self, value):
符号检查 =
超级().
检查(value)
如果
不是
符号检查.
所有():
返回
符号检查
返回 torch.
线性代数.eigvalsh(value).
大于等于(0).
所有(-1)
类
正定(
对称):
```python
# 假设输入文本为：
input_text = """Immersive Translate"""
# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
# 这里应该调用真实的翻译 API 进行翻译
# 由于示例中不使用真实的 API，以下为模拟翻译结果
return text # 假设翻译结果与原文相同
# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
输出：
```
Immersive Translate
```
约束为正定矩阵。
"沉浸式翻译"
def 查看(self, value):
符号检查 =
超级().
查看(value)
如果
不是
符号检查.
所有():
返回
符号检查
返回 torch.
线性代数.
Cholesky 分解(value).
信息.eq(0)
类
猫(
约束):
""
应用一系列约束的约束函子
在维度 `dim` 的子矩阵上应用 `cseq`
每个大小为 `lengths[dim]`，与 :func:`torch.cat` 兼容的方式。
"沉浸式翻译"
def __init__(self, cseq, 暗淡=0,
长度=
无):
断言
所有(isinstance(c,
约束) for c
在 cseq)
self.cseq = 列表(cseq)
if lengths is None:
长度 = [1] *
长度(self.cseq)
self.长度 =
列表(
长度)
断言
长度(self.
长度) ==
长度(self.cseq)
self.维度 =
维度
超级().__init__()
@property
定义
是否离散(self) -> bool:
# 类型：忽略[重写]
返回
任何(c.
是否为离散 for c
在 self.
连续序列)
@property
def 事件维度(self) -> int:
# 类型：忽略[重写]
返回
最大值(c.
事件维度 for c
在
自身.
连续序列)
定义
检查(self, value):
断言 -value.
暗淡() <= self.
维度 < value.
暗淡()
检查 =
输入文本为空，请提供需要翻译的文本
开始 = 0
for 构造,
长度
在 zip(self.
顺序, self.
长度):
v = value.狭窄(self.
暗淡,
开始,
长度)
检查.append(
构造.
检查(v))
开始 =
开始 +
长度
避免使用 += 以兼容 JIT
返回 torch.
猫(
检查, self.
暗淡)
类
_堆栈(
约束):
"""
应用一系列约束的约束函子
在维度 `dim` 的子矩阵中的 `cseq`，
与 :func:`torch.stack` 兼容的方式。
"沉浸式翻译"
def __init__(self, cseq, 暗淡=0):
断言
所有(isinstance(c,
约束) for c
在 cseq)
self.cseq = 列表(cseq)
self.维度 =
维度
超级().__init__()
@property
def 是否离散(self) ->
布尔:
# 类型：忽略[覆盖]
返回
任何(c.
is 离散 for c
在 self.cseq)
@property
def 事件维度(self) -> int:
# 类型：忽略[重写]
维度 =
最大值(c.
事件维度 for c
在 self.cseq)
如果 self.
维度 +
维度 < 0:
维度 += 1
返回
维度
def 查看(self, value):
断言 -value.
暗淡() <= self.
维度 < value.
暗淡()
vs = [value.选择(self.
暗淡, i) for i
在
范围(
值.
尺寸(self.
暗淡))]
返回 torch.
栈(
[constr.查看(v) for v, constr
在 zip(vs,
我.cseq
)]，
我.
维度
)
# 公共接口。
依赖的 =
依赖()
依赖属性 =
_依赖属性
独立 =
独立约束
布尔 =
布尔型()
热编码 =
_独热编码()
非负整数 =
_整数大于(0)
正整数 =
_整数大于(1)
整数区间 =
整数区间
真实 =
_实数()
实向量 =
独立的(
真实, 1)
正向 =
_大于(0.0)
非负的 =
大于等于(0.0)
大于 =
_大于
大于等于 =
_大于等于
小于 =
_小于
多项式 =
_多项式
单位区间 =
间隔(0.0, 1.0)
区间 =
间隔
半开区间 =
半开区间
单纯形 =
单纯形_()
下三角 =
下三角()
下三角 Cholesky =
_下三角 Cholesky()
相关 Cholesky = _CorrCholesky()
矩形 =
_正方形()
对称的 =
_对称()
正定半正定 =
_正定半正定()
正定 =
_正定()
猫 =
_猫
栈 =
_栈
