torch.distributions.distribution 的源代码

# mypy: 允许未类型化定义
导入 警告
来自 打字 导入 可选
来自 typing_extensions 导入 已弃用

导入 火炬
来自 火炬 导入 张量
来自 torch.distributions 导入 约束
来自 torch.distributions.utils 导入 懒属性
来自 torch 的类型 导入 _大小


全部 = [分布式]


类 分发:
    r"""
分布是概率分布的抽象基类。
"沉浸式翻译"

    has_rsample = 假
    支持枚举 = 假
    验证参数 = __debug__

[文档]    @静态方法
def set_default_validate_args(value: bool) -> None:
"""
设置是否启用或禁用验证。

默认行为模仿 Python 的 ``assert`` 语句：验证
默认开启，但在以优化模式运行 Python 时被禁用
（通过 ``python -O``）。验证可能很昂贵，所以你可能想
禁用模型工作后。

参数:
value (bool): 是否启用验证。
```python
# 输入文本
input_text = '"""'

# 翻译函数（此处为示例，实际翻译功能需调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 假设的翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
如果 value 不在 [True, False] 中：
引发 ValueError
Distribution._validate_args = 值

    定义 __init__(
        我,
        批量形状: torch.大小 = torch.尺寸(),
        事件形状: torch.大小 = torch.尺寸(),
        验证参数: 可选[bool] = 无,
    ):
        self.批次形状 = 批量形状
        self.事件形状 = 事件形状
        如果 验证参数 是 不是 无:
            self.验证参数 = 验证参数
        如果 self._validate_args:
            尝试:
                约束参数 = self.约束参数
            除了 不支持的操作异常:
                约束参数 = {}
                警告.警告(
                    f"{self.类}未定义 `arg_constraints`。
                    + "请设置 `arg_constraints = "{}` 或初始化分布 "`
                    + 使用 `validate_args=False` 来关闭验证。
                )
            for 参数, 约束 在 参数约束.项目():
                如果 约束.是否依赖(约束):
                    continue  # 跳过无法检查的约束
                如果 参数 不是 在 self.字典 和 isinstance(
                    getattr(类型(self), 参数), 懒加载属性
                ):
                    continue  # 跳过检查懒构建的参数
                值 = getattr(self, 参数)
                有效的 = 约束.查看(值)
                如果 不是 torch.全部为真(有效的):
                    抛出 值错误(
                        f预期参数{参数} "
                        f“（”{类型(值).__name__}形状的{元组(值.形状)})
                        f分布的{表示(我)} "
                        f满足约束的{表示(约束)}，"
                        f"但是发现无效的值："输入文本翻译为简体中文为：\n{值}"
                    )
        超级().__init__()

[文档]    def expand(self, batch_shape: _size, _instance=None):
"""
返回一个新的分布实例（或填充现有的实例）
由派生类提供（）将批量维度扩展到
`batch_shape`. 此方法调用 :class:`~torch.Tensor.expand` 方法
该发行版的参数。因此，这不会分配新的
内存用于扩展分布实例。此外，
这不会重复任何参数检查或参数广播
`__init__.py`，当实例首次创建时。

参数:
batch_shape (torch.Size):期望的扩展大小。
_instance：由子类提供的新实例，需要重写 `.expand`。
需要重写 `.expand` 的。

返回：
新的分布实例，批量维度扩展到
`批量大小`。
“”
抛出未实现异常

    @property
    def 批量形状(我) -> torch.尺寸:
        """
返回参数批处理的形状。
"沉浸式翻译"
        返回 自身._batch_shape

    @property
    定义 event_shape(自身) -> torch.尺寸:
        """
返回单个样本的形状（不包含批处理）。
"沉浸式翻译"
        返回 自身.事件形状

    @property
    定义 参数约束(自身) -> 字典[str, 约束.约束]
        """
返回一个从参数名称到
class:`~torch.distributions.constraints.Constraint` 对象的字典，其中
应由该分布的每个参数满足。不需要出现在此字典中的非张量参数。
不需要出现在此字典中。
"沉浸式翻译"
        抛出 未实现异常

    @property
    定义 支持(自身) -> 可选[约束.约束]
        """
返回一个代表此分布支持范围的 :class:`~torch.distributions.constraints.Constraint` 对象。
表示此分布的支持范围。
"沉浸式翻译"
        抛出 未实现异常

    @property
    定义 均值(自身) -> 张量:
        """
返回分布的平均值。
"沉浸式翻译"
        抛出 未实现异常

    @property
    定义 模式(self) -> 张量:
        """
返回分布的模式。
"沉浸式翻译"
        抛出 不支持的操作异常(f"{self.类}未实现模式")

    @property
    def 方差(self) -> 张量:
        """
返回分布的方差。
"沉浸式翻译"
        抛出 未实现异常

    @property
    def 标准差(self) -> 张量:
        """
返回分布的标准差。
"沉浸式翻译"
        返回 self.方差.平方根()

[docs]    def sample(self, sample_shape: _size = torch.Size()) -> Tensor: 
[docs]    def sample(self, sample_shape: _size = 火炬.Size()) -> 火炬.Tensor:
```python
# 输入文本
input_text = '"""'

# 翻译函数（此处为示例，实际翻译功能需调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 假设的翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
生成一个形状为 sample_shape 的样本或形状为 sample_shape 的批次
样本如果分布参数被批处理。
"""
使用 torch.no_grad():
返回 self.rsample(sample_shape)

[docs]    def rsample(self, sample_shape: _size = torch.Size()) -> Tensor:
"""
生成形状为 sample_shape 的重新参数化样本或 sample_shape
形状的重新参数化样本批次，如果分布参数
批量处理。
"""
抛出未实现异常。

[文档]    @弃用(
"`sample_n(n)` 将被弃用。请使用 `sample((n,))` 代替。",
category=FutureWarning,
    )
def sample_n(self, n: int) -> Tensor:
""
生成 n 个样本或 n 批样本，如果分布参数是批量的。
分布参数批量处理。
""
return self.sample(torch.Size((n,)))

[文档]    def log_prob(self, value: Tensor) -> Tensor:
"""
返回在 n 个维度上评估的概率密度/质量函数的对数
`值`.

Args:
value (张量):
"""
引发未实现错误

[文档]    def cdf(self, value: 张量) -> 张量:
```python
# 输入文本
input_text = '"""'

# 翻译函数（此处为示例，实际翻译功能需调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 假设的翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
返回在指定点评估的累积密度/质量函数
`值`.

Args:
value (张量):
"""
抛出未实现异常

[文档] def icdf(self, value: Tensor) -> Tensor:
"""
返回在给定值处评估的逆累积分布/质量函数
`值`.

Args:
value (张量):
"""
抛出未实现异常

[文档] def enumerate_support(self, expand: bool = True) -> Tensor:
"""
返回包含所有离散值支持的张量
分布。结果将遍历维度 0，因此形状
结果将是 `(cardinality,) + batch_shape + event_shape`
（其中 `event_shape = ()` 用于一元分布）。

请注意，这将在锁定步骤中枚举所有批处理张量
`[[0, 0], [1, 1], ...]` 在 `expand=False` 的情况下进行枚举
沿着第 0 维，但剩余的批次维度为
单例维度，`[[0], [1], ..`.

遍历完整笛卡尔积
itertools.product(m.enumerate_support())

参数:
expand (bool): 是否扩展支持范围
批维度与分布的 `batch_shape` 匹配。

返回：
张量遍历维度 0。
```python
# 输入文本
input_text = '"""'

# 翻译函数（此处为示例，实际翻译功能需调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 假设的翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
引发未实现错误

[文档]    def entropy(self) -> Tensor:
"""
返回分布的熵，批处理在 batch_shape 上。

返回：
批量形状的张量。
"""
抛出未实现异常。

[文档]    def perplexity(self) -> 张量：
"``"
返回分布的困惑度，批处理在 batch_shape 上。

返回：
形状为 batch_shape 的张量。
```python
# 输入文本
input_text = '"""'

# 翻译函数（此处为示例，实际翻译功能需调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 假设的翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
返回 torch.exp(self.熵())

    def _扩展形状(self, 样本形状: _大小 = torch.尺寸()) -> torch.尺寸:
        """
返回分布返回的样本的大小
一个 `sample_shape`。注意，实例的批量和事件形状在构造时是固定的。如果为空，则返回的形状提升为（1，）。
如果为空，则返回的形状提升为（1，）。
sample_shape（torch.Size）：要抽取的样本的大小。

参数：
sample_shape（torch.Size）：要抽取的样本的大小。
"沉浸式翻译"
        如果 不是 isinstance(样本形状, torch.尺寸):
            样本形状 = torch.尺寸(样本形状)
        返回 torch.尺寸(样本形状 + 我._batch_shape + 我._event_shape)

    def _validate_sample(我, 值: 张量) -> 无:
        """
分布方法的参数验证，例如 `log_prob`
`cdf` 和 `icdf`。要计算的值的右侧维度
通过这些方法得出的分数必须与分布的批次一致
并且事件形状。

参数：
value（张量）：要计算对数概率的张量
通过`log_prob`方法计算得出。
抛出异常。
ValueError：当`value`的最右侧维度与分布的批量和事件形状不匹配时。
抛出异常。
"沉浸式翻译"
        如果 不是 isinstance(值, torch.张量):
            抛出 值错误("log_prob 的值参数必须是一个张量")

        事件维度起始 = 长度(值.尺寸()) - 长度(自身._事件形状)
        如果 值.尺寸()[事件维度起始] != 自身.事件形状:
            抛出 值错误(
                f值的最右侧大小必须与 event_shape 匹配：{值.大小()} vs {自身.事件形状}。
            )

        实际形状 = 值.大小()
        预期形状 = 自身._批次形状 + 自身._事件形状
        for i, j 在 zip(反转(实际形状), 反转(预期形状)):
            如果 i != 1 和 j != 1 和 i != j:
                抛出 值错误(
                    f"值不能与 batch_shape+event_shape 广播：{实际形状}与...{预期形状}。
                )
        尝试:
            支持 = 自身.支持
        除了 不支持的操作异常:
            警告.警告(
                f"{自身.类}未定义 `support` 以启用 "
                + "请初始化分布以进行样本验证。"
                + `validate_args=False` 关闭验证。
            )
            返回
        断言 支持 是 不是 无
        有效 = 支持.检查(值)
        如果 不是 torch.全部为真(有效):
            抛出 值错误(
                预期值参数
                f“（”{类型(值).__name__}形状的{元组(值.形状)})
                f“在分布的支持范围内（”{表示(支持)})
                f“的分布中（”{表示(自身)}，"
                f"但发现无效值："输入文本翻译为简体中文为：\n{值}"
            )

    定义 _get_checked_instance(自身, 类, _instance=无):
        如果 _instance 是 无 和 类型(自身).__init__ != 类.__init__:
            抛出 不支持的操作异常(
                f子类{我.类.__name__}的{类.__name__}定义一个自定义的 __init__ 方法的
                "必须还要定义一个自定义的 .expand() 方法。"
            )
        返回 我.__new__(类型(我)) 如果 _实例 是 无 否则 _实例

    定义 __repr__(我) -> str:
        参数名称 = [k for k, _ 在 我.参数约束.项目() 如果 k 在 我.字典]
        参数字符串 = “，”.连接(
            [
                f"{p}: {我.字典[p] 如果 self.字典[p].元素数量() == 1 否则 self.字典[p].尺寸()}"
                for p 在 参数名称
            ]
        )
        返回 self.类.__name__ + “（” + 参数字符串 + “）”