torch.distributions.one_hot_categorical 的源代码

# mypy: 允许未类型化定义
导入 火炬
from 火炬 导入 张量
from torch.distributions 导入 约束
from torch.distributions.categorical 导入 离散型
from torch.distributions.distribution 导入 分布
from torch.types 导入 _大小


全部 = [OneHotCategorical, "OneHotCategoricalStraightThrough"]


类 单热分类变量(分发):
    r""
通过：attr:`probs`或
attr:`logits`进行参数化。

样本是一组大小为`probs.size(-1)`的 one-hot 编码向量。

.. 注意:: `probs` 参数必须是非负的、有限的，并且总和不为零，
它将在最后一个维度上归一化，使其总和为 1。:attr:`probs`
将返回这个归一化值。
`logits` 参数将被解释为未归一化的对数概率
因此可以是任何实数。它同样会被归一化，以便
结果概率在最后一个维度上求和为 1。:attr:`logits`
将返回这个归一化值。

参见：:func:`torch.distributions.Categorical` 以获取规格说明
attr:`probs` 和 :attr:`logits`。

示例::

>>> # xdoctest: +IGNORE_WANT("非确定性")
        >>> m = OneHotCategorical(torch.tensor([ 0.25, 0.25, 0.25, 0.25 ]))
>>> m.sample()  # 等概率选择 0, 1, 2, 3
        tensor([ 0.,  0.,  0.,  1.])

参数：
probs (Tensor)：事件概率
logits (Tensor)：事件对数概率（未归一化）
""

    约束参数 = {"概率": 约束.单形, "logits": 约束.实向量}
    支持 = 约束.热编码
    支持枚举 = 真实

    def __init__(self, 概率=无, logits=无, 验证参数=无):
        self._分类 = 离散型随机变量分布(概率, logits)
        批量形状 = self._分类.批量形状
        事件形状 = self._分类.参数形状[-1]
        超级().__init__(批量形状, event_shape, 验证参数=验证参数)

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

    def 新(self, *参数, **kwargs):
        返回 self._分类.新(*参数, **kwargs)

    @property
    def _param(self) 翻译 张量:
        返回 self._分类._参数

    @property
    def 概率(self) 翻译 张量:
        返回 self._分类.概率

    @property
    def logits(self) 翻译 张量:
        返回 self._分类.logits

    @property
    def 均值(self) 翻译 张量:
        返回 self._分类.概率

    @property
    def 模式(self) 翻译 张量:
        概率 = self._分类.概率
        模式 = 概率.argmax(暗=-1)
        返回 火炬.神经网络.功能性.one_hot(模式, 类别数量=概率.形状[-1]).到(概率)

    @property
    def 方差(self) 翻译 张量:
        返回 self._分类.概率 * (1 - self._分类.概率)

    @property
    def 参数形状(self) 翻译 火炬.尺寸:
        返回 self._分类.参数形状

[文档]    def sample(self, sample_shape=torch.Size()):
sample_shape = torch.Size(sample_shape)
probs = self._categorical.probs
num_events = self._categorical._num_events
indices = self._categorical.sample(sample_shape)
return torch.nn.functional.one_hot(indices, num_events).to(probs)

[文档]    def log_prob(self, value):
if self._validate_args:
self._validate_sample(value)
indices = value.max(-1)[1]
返回 self._categorical.log_prob(indices)

[文档] def entropy(self):
返回 self._categorical.entropy()

[文档] def enumerate_support(self, expand=True):
n = self.event_shape[0]
values = torch.eye(n, dtype=self._param.dtype, device=self._param.device)
values = values.view((n,) + (1,) * len(self.batch_shape) + (n,))
if expand:
values = values.expand((n,) + self.batch_shape + (n,))
return values



类 OneHotCategoricalStraightThrough(单热分类变量):
    r""
基于直通法的可重新参数化的 :class:`OneHotCategorical` 分布创建
通过梯度估计器从[1]。

[1] 通过随机神经元估计或传播梯度进行条件计算
(Bengio 等人，2013)
""

    has_rsample = 真实

    def rsample(self, 样本形状: _大小 = 火炬.尺寸()) 翻译 张量:
        样本 = self.样例(样本形状)
        概率 = self._分类.概率  # 通过 @lazy_property 缓存
        返回 样本 + (概率 - 概率.detach())