torch.distributions.laplace 的源代码

# mypy: 允许未类型化定义
导入 火炬
from 火炬 导入 张量
from torch.distributions 导入 约束
from torch.distributions.distribution 导入 分布
from torch.distributions.utils 导入 广播全部
from torch.types 导入 数, _大小


全部 = [拉普拉斯]


类 拉普拉斯分布(分发):
    r```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
```
创建一个由 :attr:`loc` 和 :attr:`scale` 参数化的拉普拉斯分布。

示例::

>>> # xdoctest: +IGNORE_WANT("非确定性")
        >>> m = Laplace(torch.tensor([0.0]), torch.tensor([1.0]))
>>> m.sample()  # Laplace 分布，均值=0，尺度=1
        tensor([ 0.1046])

参数：
loc (float or Tensor): 分布的均值
scale (float or Tensor): 分布的尺度
    """

    约束参数 = {"loc": 约束.真实, "缩放": 约束.正的}
    支持 = 约束.真实
    has_rsample = 真实

    @property
    定义 均值(self) 翻译 张量:
        return self.定位

    @property
    定义 模式(self) 翻译 张量:
        return self.定位

    @property
    定义 方差(self) 翻译 张量:
        return 2 * self.比例.pow(2)

    @property
    定义 标准差(self) 翻译 张量:
        return (2**0.5) * self.缩放

    定义 __init__(self, 位置, 比例, 验证参数=无):
        self.位置, self.缩放 = 广播全部(位置, 比例)
        如果 isinstance(位置, 数) 和 isinstance(比例, 数):
            批量形状 = 火炬.尺寸()
        else:
            批量形状 = self.位置.大小()
        超级().__init__(批量形状, 验证参数=验证参数)

[文档]    def expand(self, batch_shape, _instance=None):
new = self._get_checked_instance(Laplace, _instance)
batch_shape = torch.Size(batch_shape)
new.loc = self.loc.expand(batch_shape)
new.scale = self.scale.expand(batch_shape)
super(Laplace, new).__init__(batch_shape, validate_args=False)
new._validate_args = self._validate_args
return new

[文档]    def rsample(self, sample_shape: _size = torch.Size()):
shape = self._extended_shape(sample_shape)
finfo = torch.finfo(self.loc.dtype)
if torch._C._get_tracing_state():
# [JIT WORKAROUND] 对 .uniform_() 的支持不足
u = torch.rand(shape, dtype=self.loc.dtype, device=self.loc.device) * 2 - 1
return self.loc - self.scale * u.sign() * torch.log1p(
-u.abs().clamp(min=finfo.tiny)
            )
u = self.loc.new(shape).uniform_(finfo.eps - 1, 1)
# TODO: 如果我们将来实现 tensor.nextafter，以下是我们理想中的实现。
# u = self.loc.new(shape).uniform_(self.loc.nextafter(-.5, 0), .5)
return self.loc - self.scale * u.sign() * torch.log1p(-u.abs())

[文档]    def log_prob(self, value):
if self._validate_args:
self._validate_sample(value)
return -torch.log(2 * self.scale) - torch.abs(value - self.loc) / self.scale

[文档] def cdf(self, value):
if self._validate_args:
self._validate_sample(value)
return 0.5 - 0.5 * (value - self.loc).sign() * torch.expm1(
-(value - self.loc).abs() / self.scale
        )

[文档]    def icdf(self, value):
term = value - 0.5
return self.loc - self.scale * (term).sign() * torch.log1p(-2 * term.abs())

[文档] def entropy(self):
return 1 + torch.log(2 * self.scale)