Распределения вероятностей — torch.distributions

Создано: 19 окт. 2017 г. | Последнее обновление: 24 апр. 2026 г.

Пакет distributions содержит настраиваемые распределения вероятностей и функции выборки. Это позволяет создавать стохастические графы вычислений и оцениватели стохастического градиента для оптимизации. В целом этот пакет следует архитектуре пакета TensorFlow Distributions.

Невозможно выполнить обратное распространение ошибки непосредственно через случайные выборки. Однако существует два основных метода создания суррогатных функций, через которые можно выполнить обратное распространение ошибки. Это оцениватель функции оценки/оцениватель отношения правдоподобия/REINFORCE и оцениватель производной по траектории. REINFORCE обычно рассматривается как основа методов градиента политики в обучении с подкреплением, а оцениватель производной по траектории обычно используется в трюке репараметризации в вариационных автокодировщиках. В то время как для функции оценки требуется только значение выборок $f(x)$ , для производной по траектории требуется производная $f'(x)$ . В следующих разделах эти два метода рассматриваются на примере обучения с подкреплением. Подробнее см. в статье Оценивание градиента с помощью стохастических графов вычислений .

Функция оценки

Если функция плотности вероятности дифференцируема по своим параметрам, для реализации REINFORCE нам нужны только sample() и log_prob():

\Delta\theta = \alpha r \nabla_\theta \log \pi_\theta(a \mid s)

где $\theta$ — параметры, $\alpha$ — скорость обучения, $r$ — вознаграждение, а $\pi_\theta(a \mid s)$ — вероятность выполнения действия $a$ в состоянии $s$ при заданной политике $\pi_\theta$ .

На практике мы бы взяли выборку действия из выходных данных сети, применили это действие в среде, а затем использовали log_prob для построения эквивалентной функции потерь. Обратите внимание, что мы используем отрицательный знак, поскольку оптимизаторы используют градиентный спуск, тогда как приведённое выше правило предполагает градиентный подъём. Для категориальной политики код реализации REINFORCE выглядел бы так:

probs = policy_network(state)
# Note that this is equivalent to what used to be called multinomial
m = Categorical(probs)
action = m.sample()
next_state, reward = env.step(action)
loss = -m.log_prob(action) * reward
loss.backward()

Производная по траектории

Другой способ вычисления этих стохастических градиентов/градиентов политики — использовать трюк репараметризации из метода rsample(), при котором параметризованную случайную величину можно получить с помощью параметризованной детерминированной функции от случайной величины, не зависящей от параметров. Поэтому репараметризованная выборка становится дифференцируемой. Код реализации производной по траектории выглядел бы так:

params = policy_network(state)
m = Normal(*params)
# Any distribution with .has_rsample == True could work based on the application
action = m.rsample()
next_state, reward = env.step(action)  # Assuming that reward is differentiable
loss = -reward
loss.backward()

Распределение

class torch.distributions.distribution.Distribution(batch_shape=(), event_shape=(), validate_args=None) [исходный код]

Базовые классы: object

Distribution — абстрактный базовый класс для распределений вероятностей.

Параметры:

batch_shape (torch.Size) – Форма, по которой сгруппированы параметры.
event_shape (torch.Size) – Форма отдельной выборки (без пакетной обработки).
validate_args (bool, необязательно) – Нужно ли проверять аргументы. По умолчанию: None.

property arg_constraints: dict[str, Constraint]: Возвращает словарь, сопоставляющий имена аргументов с объектами Constraint, которым должен удовлетворять каждый аргумент этого распределения. Аргументы, не являющиеся тензорами, можно не включать в этот словарь.

property batch_shape: Size: Возвращает форму, по которой сгруппированы параметры.

cdf(value) [исходный код]

Возвращает функцию кумулятивного распределения/массовую функцию, вычисленную для value.

Параметры:: value (Tensor) –
Тип возвращаемого значения:: Tensor

entropy() [исходный код]

Возвращает энтропию распределения, сгруппированную по batch_shape.

Возвращает:: Тензор формы batch_shape.
Тип возвращаемого значения:: Tensor

enumerate_support(expand=True) [исходный код]

Возвращает тензор, содержащий все значения, входящие в носитель дискретного распределения. Перечисление результатов выполняется по измерению 0, поэтому форма результата будет (cardinality,) + batch_shape + event_shape (где event_shape = () для одномерных распределений).

Обратите внимание, что здесь выполняется синхронное перечисление всех пакетных тензоров [[0, 0], [1, 1], …]. При использовании expand=False перечисление выполняется вдоль измерения 0, а оставшиеся пакетные измерения являются singleton-измерениями, [[0], [1], ...

Для перебора полного декартова произведения используйте itertools.product(m.enumerate_support()).

Параметры:: expand (bool) – нужно ли расширить носитель по пакетным измерениям, чтобы он соответствовал batch_shape распределения.
Возвращает:: Тензор с перебором по измерению 0.
Тип возвращаемого значения:: Tensor

property event_shape: Size: Возвращает форму отдельной выборки (без пакетной обработки).

expand(batch_shape, _instance=None) [исходный код]

Возвращает новый экземпляр распределения (или заполняет существующий экземпляр, переданный производным классом) с расширенными пакетными измерениями до batch_shape. Этот метод вызывает expand для параметров распределения. Поэтому для расширенного экземпляра распределения не выделяется новая память. Кроме того, при создании экземпляра не выполняется повторная проверка аргументов или широковещательное распространение параметров в __init__.py.

Параметры:

batch_shape (torch.Size) – требуемый расширенный размер.
_instance – новый экземпляр, предоставленный подклассами, которым требуется переопределить .expand.

Возвращает:

Новый экземпляр распределения с пакетными измерениями, расширенными до batch_shape.

icdf(value) [исходный код]

Возвращает обратную функцию кумулятивного распределения/массовую функцию, вычисленную для value.

Параметры:: value (Tensor) –
Тип возвращаемого значения:: Tensor

log_prob(value) [исходный код]

Возвращает логарифм функции плотности вероятности/массовой функции, вычисленный для value.

Параметры:: value (Tensor) –
Тип возвращаемого значения:: Tensor

property mean: Tensor: Возвращает среднее значение распределения.

property mode: Tensor: Возвращает моду распределения.

perplexity() [исходный код]

Возвращает перплексию распределения, сгруппированную по batch_shape.

Возвращает:: Тензор формы batch_shape.
Тип возвращаемого значения:: Tensor

rsample(sample_shape=()) [исходный код]

Создаёт выборку формы sample_shape с репараметризацией или пакет выборок формы sample_shape с репараметризацией, если параметры распределения сгруппированы.

Тип возвращаемого значения:: Tensor

sample(sample_shape=()) [исходный код]

Создаёт выборку формы sample_shape или пакет выборок формы sample_shape, если параметры распределения сгруппированы.

Тип возвращаемого значения:: Tensor

sample_n(n) [исходный код]

Создаёт n выборок или n пакетов выборок, если параметры распределения сгруппированы.

Тип возвращаемого значения:: Tensor

static set_default_validate_args(value) [исходный код]

Включает или отключает проверку.

Поведение по умолчанию имитирует инструкцию assert в Python: проверка включена по умолчанию, но отключается, если Python запущен в оптимизированном режиме (с помощью python -O). Проверка может быть затратной, поэтому после отладки модели её можно отключить.

Параметры:: value (bool) – Нужно ли включить проверку.

property stddev: Tensor: Возвращает стандартное отклонение распределения.

property support: Constraint | None: Возвращает объект Constraint, представляющий носитель этого распределения.

property variance: Tensor: Возвращает дисперсию распределения.

ExponentialFamily

class torch.distributions.exp_family.ExponentialFamily(batch_shape=(), event_shape=(), validate_args=None) [исходный код]

Базовые классы: Distribution

ExponentialFamily — абстрактный базовый класс для распределений вероятностей, принадлежащих экспоненциальному семейству, функция плотности вероятности/массовая функция которого определена ниже

p_{F}(x; \theta) = \exp(\langle t(x), \theta\rangle - F(\theta) + k(x))

где $\theta$ обозначает естественные параметры, $t(x)$ — достаточную статистику, $F(\theta)$ — функцию логарифма нормирующей константы для заданного семейства, а $k(x)$ — меру-носитель.

Примечание

Этот класс служит промежуточным звеном между классом Distribution и распределениями, принадлежащими экспоненциальному семейству, главным образом для проверки корректности методов .entropy() и аналитической дивергенции KL. Мы используем этот класс для вычисления энтропии и дивергенции KL с помощью фреймворка автоматического дифференцирования и дивергенций Брегмана (по материалам: Frank Nielsen и Richard Nock, «Энтропии и кросс-энтропии экспоненциальных семейств»).

entropy() [исходный код]: Метод вычисления энтропии с использованием дивергенции Брегмана для логарифма нормирующей константы.

Bernoulli

class torch.distributions.bernoulli.Bernoulli(probs=None, logits=None, validate_args=None) [исходный код]

Базовые классы: ExponentialFamily

Создаёт распределение Бернулли, параметризованное с помощью probs или logits (но не обоими параметрами одновременно).

Выборки являются бинарными (0 или 1). Значение 1 принимается с вероятностью p, а 0 — с вероятностью 1 - p.

Пример:

>>> m = Bernoulli(torch.tensor([0.3]))
>>> m.sample()  # 30% chance 1; 70% chance 0
tensor([ 0.])

Параметры:

probs (Number, Tensor) – вероятность получения выборки 1
logits (Number, Tensor) – логарифм шансов получения выборки 1
validate_args (bool, необязательно) – нужно ли проверять аргументы; по умолчанию None

arg_constraints = {'logits': Real(), 'probs': Interval(lower_bound=0.0, upper_bound=1.0)}

entropy() [исходный код]

enumerate_support(expand=True) [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_enumerate_support = True

log_prob(value) [исходный код]

property logits: Tensor

property mean: Tensor

property mode: Tensor

property param_shape: Size

property probs: Tensor

sample(sample_shape=()) [исходный код]

support = Boolean()

property variance: Tensor

Бета

class torch.distributions.beta.Beta(concentration1, concentration0, validate_args=None) [исходный код]

Базовые классы: ExponentialFamily

Бета-распределение с параметрами concentration1 и concentration0.

Пример:

>>> m = Beta(torch.tensor([0.5]), torch.tensor([0.5]))
>>> m.sample()  # Beta distributed with concentration concentration1 and concentration0
tensor([ 0.1046])

Параметры:

concentration1 (float или Tensor) – первый параметр концентрации распределения (часто обозначается alpha)
concentration0 (float или Tensor) – второй параметр концентрации распределения (часто обозначается beta)

arg_constraints = {'concentration0': GreaterThan(lower_bound=0.0), 'concentration1': GreaterThan(lower_bound=0.0)}

property concentration0: Tensor

property concentration1: Tensor

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

support = Interval(lower_bound=0.0, upper_bound=1.0)

property variance: Tensor

Биномиальное распределение

class torch.distributions.binomial.Binomial(total_count=1, probs=None, logits=None, validate_args=None) [исходный код]

Базовые классы: Distribution

Создает биномиальное распределение с параметрами total_count и одним из значений: probs или logits (но не обоими). total_count должен допускать широковещательное преобразование с probs/logits.

Пример:

>>> m = Binomial(100, torch.tensor([0 , .2, .8, 1]))
>>> x = m.sample()
tensor([   0.,   22.,   71.,  100.])

>>> m = Binomial(torch.tensor([[5.], [10.]]), torch.tensor([0.5, 0.8]))
>>> x = m.sample()
tensor([[ 4.,  5.],
        [ 7.,  6.]])

Параметры:

total_count (int или Tensor) – число испытаний Бернулли
probs (Tensor) – вероятности событий
logits (Tensor) – логарифмы шансов событий

arg_constraints = {'logits': Real(), 'probs': Interval(lower_bound=0.0, upper_bound=1.0), 'total_count': IntegerGreaterThan(lower_bound=0)}

entropy() [исходный код]

enumerate_support(expand=True) [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_enumerate_support = True

log_prob(value) [исходный код]

property logits: Tensor

property mean: Tensor

property mode: Tensor

property param_shape: Size

property probs: Tensor

sample(sample_shape=()) [исходный код]

property support

Тип возвращаемого значения:: _DependentProperty

property variance: Tensor

Категориальное распределение

class torch.distributions.categorical.Categorical(probs=None, logits=None, validate_args=None) [исходный код]

Базовые классы: Distribution

Создает категориальное распределение с одним из параметров: probs или logits (но не обоими).

Примечание

Оно эквивалентно распределению, из которого выполняет выборку функция torch.multinomial().

Выборки — целые числа из множества $\{0, \ldots, K-1\}$ , где K — это probs.size(-1).

Если probs является одномерным массивом длины K, каждый элемент представляет собой относительную вероятность выборки класса с соответствующим индексом.

Если probs является N-мерным массивом, первые N-1 измерений рассматриваются как пакет векторов относительных вероятностей.

Примечание

Аргумент probs должен быть неотрицательным, конечным и иметь ненулевую сумму; он будет нормализован так, чтобы сумма значений вдоль последнего измерения равнялась 1. probs вернет это нормализованное значение. Аргумент logits интерпретируется как ненормированные логарифмы вероятностей и поэтому может принимать любые действительные значения. Он также будет нормализован так, чтобы сумма результирующих вероятностей вдоль последнего измерения равнялась 1. logits вернет это нормализованное значение.

См. также: torch.multinomial()

Пример:

>>> m = Categorical(torch.tensor([ 0.25, 0.25, 0.25, 0.25 ]))
>>> m.sample()  # equal probability of 0, 1, 2, 3
tensor(3)

Параметры:

probs (Tensor) – вероятности событий
logits (Tensor) – логарифмы вероятностей событий (ненормированные)

arg_constraints = {'logits': IndependentConstraint(Real(), 1), 'probs': Simplex()}

entropy() [исходный код]

enumerate_support(expand=True) [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_enumerate_support = True

log_prob(value) [исходный код]

property logits: Tensor

property mean: Tensor

property mode: Tensor

property param_shape: Size

property probs: Tensor

sample(sample_shape=()) [исходный код]

property support

Тип возвращаемого значения:: _DependentProperty

property variance: Tensor

Коши

class torch.distributions.cauchy.Cauchy(loc, scale, validate_args=None) [исходный код]

Базовые классы: Distribution

Выборки из распределения Коши (Лоренца). Отношение независимых нормально распределенных случайных величин со средними 0 имеет распределение Коши.

Пример:

>>> m = Cauchy(torch.tensor([0.0]), torch.tensor([1.0]))
>>> m.sample()  # sample from a Cauchy distribution with loc=0 and scale=1
tensor([ 2.3214])

Параметры:

loc (float или Tensor) – мода или медиана распределения.
scale (float или Tensor) – полуширина на половине максимума.

arg_constraints = {'loc': Real(), 'scale': GreaterThan(lower_bound=0.0)}

cdf(value) [исходный код]

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

icdf(value) [исходный код]

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

support = Real()

property variance: Tensor

Хи-квадрат

class torch.distributions.chi2.Chi2(df, validate_args=None) [исходный код]

Базовые классы: Gamma

Создает распределение хи-квадрат с параметром формы df. Оно в точности эквивалентно Gamma(alpha=0.5*df, beta=0.5)

Пример:

>>> m = Chi2(torch.tensor([1.0]))
>>> m.sample()  # Chi2 distributed with shape df=1
tensor([ 0.1046])

Параметры:: df (float или Tensor) – параметр формы распределения

arg_constraints = {'df': GreaterThan(lower_bound=0.0)}

property df: Tensor

expand(batch_shape, _instance=None) [исходный код]

Непрерывное распределение Бернулли

class torch.distributions.continuous_bernoulli.ContinuousBernoulli(probs=None, logits=None, lims=(0.499, 0.501), validate_args=None) [исходный код]

Базовые классы: ExponentialFamily

Создает непрерывное распределение Бернулли с параметром probs или logits (но не обоими).

Область определения распределения — [0, 1]; оно задается параметром ‘probs’ (из (0,1)) или ‘logits’ (действительное число). Обратите внимание: в отличие от распределения Бернулли, ‘probs’ не соответствует вероятности, а ‘logits’ не соответствует логарифму шансов. Тем не менее используются те же имена из-за сходства с распределением Бернулли. Подробнее см. [1].

Пример:

>>> m = ContinuousBernoulli(torch.tensor([0.3]))
>>> m.sample()
tensor([ 0.2538])

Параметры:

probs (Number, Tensor) – параметры со значениями в (0,1)
logits (Number, Tensor) – параметры с действительными значениями, сигмоида которых соответствует ‘probs’

[1] Непрерывное распределение Бернулли: исправление распространенной ошибки в вариационных автокодировщиках, Loaiza-Ganem G и Cunningham JP, NeurIPS 2019. https://arxiv.org/abs/1907.06845

arg_constraints = {'logits': Real(), 'probs': Interval(lower_bound=0.0, upper_bound=1.0)}

cdf(value) [исходный код]

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

icdf(value) [исходный код]

log_prob(value) [исходный код]

property logits: Tensor

property mean: Tensor

property param_shape: Size

property probs: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

sample(sample_shape=()) [исходный код]

property stddev: Tensor

support = Interval(lower_bound=0.0, upper_bound=1.0)

property variance: Tensor

Распределение Дирихле

class torch.distributions.dirichlet.Dirichlet(concentration, validate_args=None) [исходный код]

Базовые классы: ExponentialFamily

Создаёт распределение Дирихле, параметризованное параметром концентрации concentration.

Пример:

>>> m = Dirichlet(torch.tensor([0.5, 0.5]))
>>> m.sample()  # Dirichlet distributed with concentration [0.5, 0.5]
tensor([ 0.1046,  0.8954])

Параметры:: concentration (Tensor) – параметр концентрации распределения (часто обозначается как alpha)

arg_constraints = {'concentration': IndependentConstraint(GreaterThan(lower_bound=0.0), 1)}

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

support = Simplex()

property variance: Tensor

Экспоненциальное распределение

class torch.distributions.exponential.Exponential(rate, validate_args=None) [исходный код]

Базовые классы: ExponentialFamily

Создаёт экспоненциальное распределение, параметризованное параметром rate.

Пример:

>>> m = Exponential(torch.tensor([1.0]))
>>> m.sample()  # Exponential distributed with rate=1
tensor([ 0.1046])

Параметры:: rate (float или Tensor) – интенсивность = 1 / масштаб распределения

arg_constraints = {'rate': GreaterThan(lower_bound=0.0)}

cdf(value) [исходный код]

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

icdf(value) [исходный код]

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

property stddev: Tensor

support = GreaterThanEq(lower_bound=0.0)

property variance: Tensor

Распределение Фишера — Снедекора

class torch.distributions.fishersnedecor.FisherSnedecor(df1, df2, validate_args=None) [исходный код]

Базовые классы: Distribution

Создаёт распределение Фишера — Снедекора, параметризованное параметрами df1 и df2.

Пример:

>>> m = FisherSnedecor(torch.tensor([1.0]), torch.tensor([2.0]))
>>> m.sample()  # Fisher-Snedecor-distributed with df1=1 and df2=2
tensor([ 0.2453])

Параметры:

df1 (float или Tensor) – параметр 1, число степеней свободы
df2 (float или Tensor) – параметр 2, число степеней свободы

arg_constraints = {'df1': GreaterThan(lower_bound=0.0), 'df2': GreaterThan(lower_bound=0.0)}

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

support = GreaterThan(lower_bound=0.0)

property variance: Tensor

Гамма-распределение

class torch.distributions.gamma.Gamma(concentration, rate, validate_args=None) [исходный код]

Базовые классы: ExponentialFamily

Создаёт гамма-распределение, параметризованное параметром формы concentration и rate.

Пример:

>>> m = Gamma(torch.tensor([1.0]), torch.tensor([1.0]))
>>> m.sample()  # Gamma distributed with concentration=1 and rate=1
tensor([ 0.1046])

Параметры:

concentration (float или Tensor) – параметр формы распределения (часто обозначается как alpha)
rate (float или Tensor) – параметр интенсивности распределения (часто обозначается как beta), интенсивность = 1 / масштаб

arg_constraints = {'concentration': GreaterThan(lower_bound=0.0), 'rate': GreaterThan(lower_bound=0.0)}

cdf(value) [исходный код]

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

rsample(sample_shape=(), generator=None) [исходный код]

Тип возвращаемого значения:: Tensor

sample(sample_shape=(), *, generator=None) [исходный код]

Тип возвращаемого значения:: Tensor

support = GreaterThanEq(lower_bound=0.0)

property variance: Tensor

Обобщённое распределение Парето

class torch.distributions.generalized_pareto.GeneralizedPareto(loc, scale, concentration, validate_args=None) [исходный код]

Базовые классы: Distribution

Создаёт обобщённое распределение Парето, параметризованное параметрами loc, scale и concentration.

Обобщённое распределение Парето — это семейство непрерывных распределений вероятностей на действительной прямой. Частные случаи включают экспоненциальное распределение (когда loc = 0, concentration = 0), распределение Парето (когда concentration > 0, loc = scale / concentration) и равномерное распределение (когда concentration = -1).

Это распределение часто используется для моделирования хвостов других распределений. Эта реализация основана на реализации в TensorFlow Probability.

Пример:

>>> m = GeneralizedPareto(torch.tensor([0.1]), torch.tensor([2.0]), torch.tensor([0.4]))
>>> m.sample()  # sample from a Generalized Pareto distribution with loc=0.1, scale=2.0, and concentration=0.4
tensor([ 1.5623])

Параметры:

loc (float или Tensor) – параметр положения распределения
scale (float или Tensor) – параметр масштаба распределения
concentration (float или Tensor) – параметр концентрации распределения

arg_constraints = {'concentration': Real(), 'loc': Real(), 'scale': GreaterThan(lower_bound=0.0)}

cdf(value) [исходный код]

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

icdf(value) [исходный код]

log_cdf(value) [исходный код]

log_prob(value) [исходный код]

log_survival_function(value) [исходный код]

property mean

property mode

rsample(sample_shape=()) [исходный код]

property support

Тип возвращаемого значения:: _DependentProperty

property variance

Геометрическое распределение

class torch.distributions.geometric.Geometric(probs=None, logits=None, validate_args=None) [исходный код]

Базовые классы: Distribution

Создаёт геометрическое распределение, параметризованное параметром probs, где probs — вероятность успеха в испытаниях Бернулли.

P(X=k) = (1-p)^{k} p, k = 0, 1, ...

Примечание

В torch.distributions.geometric.Geometric() испытание с номером $(k+1)$ является первым успешным, поэтому выборки принимают значения из множества $\{0, 1, \ldots\}$ , тогда как в torch.Tensor.geometric_() испытание с номером k является первым успешным, поэтому выборки принимают значения из множества $\{1, 2, \ldots\}$ .

Пример:

>>> m = Geometric(torch.tensor([0.3]))
>>> m.sample()  # underlying Bernoulli has 30% chance 1; 70% chance 0
tensor([ 2.])

Параметры:

probs (Number, Tensor) – вероятность выборки 1. Должна находиться в диапазоне (0, 1]
logits (Number, Tensor) – логарифм отношения шансов для выборки 1.

arg_constraints = {'logits': Real(), 'probs': Interval(lower_bound=0.0, upper_bound=1.0)}

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

log_prob(value) [исходный код]

property logits: Tensor

property mean: Tensor

property mode: Tensor

property probs: Tensor

sample(sample_shape=()) [исходный код]

support = IntegerGreaterThan(lower_bound=0)

property variance: Tensor

Gumbel

class torch.distributions.gumbel.Gumbel(loc, scale, validate_args=None) [исходный код]

Базовые классы: TransformedDistribution

Выборки из распределения Гумбеля.

Примеры:

>>> m = Gumbel(torch.tensor([1.0]), torch.tensor([2.0]))
>>> m.sample()  # sample from Gumbel distribution with loc=1, scale=2
tensor([ 1.0124])

Параметры:

loc (float или Tensor) – параметр положения распределения
scale (float или Tensor) – параметр масштаба распределения

arg_constraints: dict[str, Constraint] = {'loc': Real(), 'scale': GreaterThan(lower_bound=0.0)}

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

property stddev: Tensor

support = Real()

property variance: Tensor

HalfCauchy

class torch.distributions.half_cauchy.HalfCauchy(scale, validate_args=None) [исходный код]

Базовые классы: TransformedDistribution

Создает распределение Коши на положительной полуоси, параметризованное scale, где:

X ~ Cauchy(0, scale)
Y = |X| ~ HalfCauchy(scale)

Пример:

>>> m = HalfCauchy(torch.tensor([1.0]))
>>> m.sample()  # half-cauchy distributed with scale=1
tensor([ 2.3214])

Параметры:: scale (float или Tensor) – масштаб полного распределения Коши

arg_constraints: dict[str, Constraint] = {'scale': GreaterThan(lower_bound=0.0)}

base_dist: Cauchy

cdf(value) [исходный код]

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

icdf(prob) [исходный код]

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

property scale: Tensor

support = GreaterThanEq(lower_bound=0.0)

property variance: Tensor

HalfNormal

class torch.distributions.half_normal.HalfNormal(scale, validate_args=None) [исходный код]

Базовые классы: TransformedDistribution

Создает полу-нормальное распределение, параметризованное scale, где:

X ~ Normal(0, scale)
Y = |X| ~ HalfNormal(scale)

Пример:

>>> m = HalfNormal(torch.tensor([1.0]))
>>> m.sample()  # half-normal distributed with scale=1
tensor([ 0.1046])

Параметры:: scale (float или Tensor) – масштаб полного нормального распределения

arg_constraints: dict[str, Constraint] = {'scale': GreaterThan(lower_bound=0.0)}

base_dist: Normal

cdf(value) [исходный код]

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

icdf(prob) [исходный код]

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

property scale: Tensor

support = GreaterThanEq(lower_bound=0.0)

property variance: Tensor

Independent

class torch.distributions.independent.Independent(base_distribution, reinterpreted_batch_ndims, validate_args=None) [исходный код]

Базовые классы: Distribution, Generic[D]

Интерпретирует некоторые измерения пакета распределения как измерения события.

Это в основном полезно для изменения формы результата log_prob(). Например, чтобы создать диагональное нормальное распределение той же формы, что и многомерное нормальное распределение (чтобы они были взаимозаменяемы), можно выполнить следующее:

>>> from torch.distributions.multivariate_normal import MultivariateNormal
>>> from torch.distributions.normal import Normal
>>> loc = torch.zeros(3)
>>> scale = torch.ones(3)
>>> mvn = MultivariateNormal(loc, scale_tril=torch.diag(scale))
>>> [mvn.batch_shape, mvn.event_shape]
[torch.Size([]), torch.Size([3])]
>>> normal = Normal(loc, scale)
>>> [normal.batch_shape, normal.event_shape]
[torch.Size([3]), torch.Size([])]
>>> diagn = Independent(normal, 1)
>>> [diagn.batch_shape, diagn.event_shape]
[torch.Size([]), torch.Size([3])]

Параметры:

base_distribution (torch.distributions.distribution.Distribution) – базовое распределение
reinterpreted_batch_ndims (int) – количество измерений пакета, которые следует интерпретировать как измерения события

arg_constraints: dict[str, Constraint] = {}

base_dist: D

entropy() [исходный код]

enumerate_support(expand=True) [исходный код]

expand(batch_shape, _instance=None) [исходный код]

property has_enumerate_support: bool

property has_rsample: bool

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

sample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

property support

Тип возвращаемого значения:: _DependentProperty

property variance: Tensor

InverseGamma

class torch.distributions.inverse_gamma.InverseGamma(concentration, rate, validate_args=None) [исходный код]

Базовые классы: TransformedDistribution

Создает обратное гамма-распределение, параметризованное concentration и rate, где:

X ~ Gamma(concentration, rate)
Y = 1 / X ~ InverseGamma(concentration, rate)

Пример:

>>> m = InverseGamma(torch.tensor([2.0]), torch.tensor([3.0]))
>>> m.sample()
tensor([ 1.2953])

Параметры:

concentration (float или Tensor) – параметр формы распределения (часто обозначается alpha)
rate (float или Tensor) – интенсивность = 1 / масштаб распределения (часто обозначается beta)

arg_constraints: dict[str, Constraint] = {'concentration': GreaterThan(lower_bound=0.0), 'rate': GreaterThan(lower_bound=0.0)}

base_dist: Gamma

property concentration: Tensor

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

property mean: Tensor

property mode: Tensor

property rate: Tensor

support = GreaterThan(lower_bound=0.0)

property variance: Tensor

Kumaraswamy

class torch.distributions.kumaraswamy.Kumaraswamy(concentration1, concentration0, validate_args=None) [исходный код]

Базовые классы: TransformedDistribution

Выборки из распределения Кумарасвами.

Пример:

>>> m = Kumaraswamy(torch.tensor([1.0]), torch.tensor([1.0]))
>>> m.sample()  # sample from a Kumaraswamy distribution with concentration alpha=1 and beta=1
tensor([ 0.1729])

Параметры:

concentration1 (float или Tensor) – первый параметр концентрации распределения (часто обозначается alpha)
concentration0 (float или Tensor) – второй параметр концентрации распределения (часто обозначается beta)

arg_constraints: dict[str, Constraint] = {'concentration0': GreaterThan(lower_bound=0.0), 'concentration1': GreaterThan(lower_bound=0.0)}

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

property mean: Tensor

property mode: Tensor

support = Interval(lower_bound=0.0, upper_bound=1.0)

property variance: Tensor

LKJCholesky

class torch.distributions.lkj_cholesky.LKJCholesky(dim, concentration=1.0, validate_args=None) [исходный код]

Базовые классы: Distribution

Распределение LKJ для нижнего треугольного множителя Холецкого корреляционных матриц. Распределение определяется параметром concentration $\eta$ , чтобы вероятность корреляционной матрицы $M$ , полученной из множителя Холецкого, была пропорциональна $\det(M)^{\eta - 1}$ . Поэтому, когда concentration == 1, мы имеем равномерное распределение множителей Холецкого корреляционных матриц:

L ~ LKJCholesky(dim, concentration)
X = L @ L' ~ LKJCorr(dim, concentration)

Обратите внимание, что это распределение генерирует выборки множителей Холецкого корреляционных матриц, а не самих корреляционных матриц, и поэтому несколько отличается от выводов в [1] для распределения LKJCorr. Для генерации выборок используется метод Onion из раздела 3 работы [1].

Пример:

>>> l = LKJCholesky(3, 0.5)
>>> l.sample()  # l @ l.T is a sample of a correlation 3x3 matrix
tensor([[ 1.0000,  0.0000,  0.0000],
        [ 0.3516,  0.9361,  0.0000],
        [-0.1899,  0.4748,  0.8593]])

Параметры:

dimension (dim) – размерность матриц
concentration (float или Tensor) – параметр концентрации/формы распределения (часто обозначается eta)

Список литературы

[1] Generating random correlation matrices based on vines and extended onion method (2009), Даниэль Левандовски, Дорота Куровицка, Гарри Джо. Journal of Multivariate Analysis. 100. 10.1016/j.jmva.2009.04.008

arg_constraints = {'concentration': GreaterThan(lower_bound=0.0)}

expand(batch_shape, _instance=None) [исходный код]

log_prob(value) [исходный код]

sample(sample_shape=()) [исходный код]

support = CorrCholesky()

Laplace

class torch.distributions.laplace.Laplace(loc, scale, validate_args=None) [исходный код]

Базовые классы: Distribution

Создает распределение Лапласа, параметризованное с помощью loc и scale.

Пример:

>>> m = Laplace(torch.tensor([0.0]), torch.tensor([1.0]))
>>> m.sample()  # Laplace distributed with loc=0, scale=1
tensor([ 0.1046])

Параметры:

loc (float или Tensor) – математическое ожидание распределения
scale (float или Tensor) – масштаб распределения

arg_constraints = {'loc': Real(), 'scale': GreaterThan(lower_bound=0.0)}

cdf(value) [исходный код]

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

icdf(value) [исходный код]

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

property stddev: Tensor

support = Real()

property variance: Tensor

LogNormal

class torch.distributions.log_normal.LogNormal(loc, scale, validate_args=None) [исходный код]

Базовые классы: TransformedDistribution

Создает логнормальное распределение, параметризованное с помощью loc и scale, где:

X ~ Normal(loc, scale)
Y = exp(X) ~ LogNormal(loc, scale)

Пример:

>>> m = LogNormal(torch.tensor([0.0]), torch.tensor([1.0]))
>>> m.sample()  # log-normal distributed with mean=0 and stddev=1
tensor([ 0.1046])

Параметры:

loc (float или Tensor) – математическое ожидание логарифма распределения
scale (float или Tensor) – стандартное отклонение логарифма распределения

arg_constraints: dict[str, Constraint] = {'loc': Real(), 'scale': GreaterThan(lower_bound=0.0)}

base_dist: Normal

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

property loc: Tensor

property mean: Tensor

property mode: Tensor

property scale: Tensor

support = GreaterThan(lower_bound=0.0)

property variance: Tensor

LowRankMultivariateNormal

class torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal(loc, cov_factor, cov_diag, validate_args=None) [исходный код]

Базовые классы: Distribution

Создает многомерное нормальное распределение с ковариационной матрицей низкого ранга, параметризованной с помощью cov_factor и cov_diag:

covariance_matrix = cov_factor @ cov_factor.T + cov_diag

Пример

>>> m = LowRankMultivariateNormal(
...     torch.zeros(2), torch.tensor([[1.0], [0.0]]), torch.ones(2)
... )
>>> m.sample()  # normally distributed with mean=`[0,0]`, cov_factor=`[[1],[0]]`, cov_diag=`[1,1]`
tensor([-0.2102, -0.5429])

Параметры:

loc (Tensor) – математическое ожидание распределения с формой batch_shape + event_shape
cov_factor (Tensor) – множитель низкорангового представления ковариационной матрицы с формой batch_shape + event_shape + (rank,)
cov_diag (Tensor) – диагональная часть низкорангового представления ковариационной матрицы с формой batch_shape + event_shape

Примечание

Вычисление определителя и обратной матрицы ковариационной матрицы не требуется, когда cov_factor.shape[1] << cov_factor.shape[0], благодаря матричному тождеству Вудбери и лемме об определителе матрицы. Благодаря этим формулам достаточно вычислить определитель и обратную матрицу небольшой «емкостной» матрицы:

capacitance = I + cov_factor.T @ inv(cov_diag) @ cov_factor

arg_constraints = {'cov_diag': IndependentConstraint(GreaterThan(lower_bound=0.0), 1), 'cov_factor': IndependentConstraint(Real(), 2), 'loc': IndependentConstraint(Real(), 1)}

property covariance_matrix: Tensor

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

property precision_matrix: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

property scale_tril: Tensor

support = IndependentConstraint(Real(), 1)

property variance: Tensor

MixtureSameFamily

class torch.distributions.mixture_same_family.MixtureSameFamily(mixture_distribution, component_distribution, validate_args=None) [исходный код]

Базовые классы: Distribution

Распределение MixtureSameFamily реализует смесь распределений (или пакет таких смесей), в которой все компоненты принадлежат к одному типу распределения, но имеют разные параметризации. Оно параметризуется с помощью Categorical «распределения выбора» (по k компонентам) и распределения компонентов, то есть Distribution с крайней правой размерностью пакета (равной [k]), которая индексирует каждый компонент (или пакет компонентов).

Примеры:

>>> # Construct Gaussian Mixture Model in 1D consisting of 5 equally
>>> # weighted normal distributions
>>> mix = D.Categorical(torch.ones(5,))
>>> comp = D.Normal(torch.randn(5,), torch.rand(5,))
>>> gmm = MixtureSameFamily(mix, comp)

>>> # Construct Gaussian Mixture Model in 2D consisting of 5 equally
>>> # weighted bivariate normal distributions
>>> mix = D.Categorical(torch.ones(5,))
>>> comp = D.Independent(D.Normal(
...          torch.randn(5,2), torch.rand(5,2)), 1)
>>> gmm = MixtureSameFamily(mix, comp)

>>> # Construct a batch of 3 Gaussian Mixture Models in 2D each
>>> # consisting of 5 random weighted bivariate normal distributions
>>> mix = D.Categorical(torch.rand(3,5))
>>> comp = D.Independent(D.Normal(
...         torch.randn(3,5,2), torch.rand(3,5,2)), 1)
>>> gmm = MixtureSameFamily(mix, comp)

Параметры:

mixture_distribution (Categorical) – экземпляр типа torch.distributions.Categorical. Определяет вероятность выбора компонентов. Число категорий должно совпадать с крайней правой размерностью пакета распределения component_distribution. Должен иметь либо скалярный batch_shape, либо batch_shape, соответствующий component_distribution.batch_shape[:-1]
component_distribution (Distribution) – экземпляр типа torch.distributions.Distribution. Крайняя правая размерность пакета индексирует компонент.

arg_constraints: dict[str, Constraint] = {}

cdf(x) [исходный код]

property component_distribution: Distribution

expand(batch_shape, _instance=None) [исходный код]

has_rsample = False

log_prob(x) [исходный код]

property mean: Tensor

property mixture_distribution: Categorical

sample(sample_shape=()) [исходный код]

property support

Тип возвращаемого значения:: _DependentProperty

property variance: Tensor

Multinomial

class torch.distributions.multinomial.Multinomial(total_count=1, probs=None, logits=None, validate_args=None) [исходный код]

Базовые классы: Distribution

Создает мультиномиальное распределение, параметризованное с помощью total_count и одного из параметров — probs или logits (но не обоих одновременно). Самая внутренняя размерность probs индексирует категории. Все остальные размерности индексируют пакеты.

Обратите внимание, что total_count можно не указывать, если вызывается только log_prob() (см. пример ниже)

Примечание

Аргумент probs должен быть неотрицательным, конечным и иметь ненулевую сумму; он будет нормализован так, чтобы сумма вдоль последней размерности равнялась 1. probs возвращает это нормализованное значение. Аргумент logits интерпретируется как ненормированные логарифмы вероятностей, поэтому может принимать любые вещественные значения. Он также нормализуется так, чтобы сумма полученных вероятностей вдоль последней размерности равнялась 1. logits возвращает это нормализованное значение.

sample() требует единого общего значения total_count для всех параметров и выборок.
log_prob() допускает различные значения total_count для каждого параметра и выборки.

Пример:

>>> m = Multinomial(100, torch.tensor([ 1., 1., 1., 1.]))
>>> x = m.sample()  # equal probability of 0, 1, 2, 3
tensor([ 21.,  24.,  30.,  25.])

>>> Multinomial(probs=torch.tensor([1., 1., 1., 1.])).log_prob(x)
tensor([-4.1338])

Параметры:

total_count (int) – число испытаний
probs (Tensor) – вероятности событий
logits (Tensor) – логарифмы вероятностей событий (ненормированные)

arg_constraints = {'logits': IndependentConstraint(Real(), 1), 'probs': Simplex()}

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

log_prob(value) [исходный код]

property logits: Tensor

property mean: Tensor

property param_shape: Size

property probs: Tensor

sample(sample_shape=()) [исходный код]

property support

Тип возвращаемого значения:: _DependentProperty

total_count: int

property variance: Tensor

MultivariateNormal

class torch.distributions.multivariate_normal.MultivariateNormal(loc, covariance_matrix=None, precision_matrix=None, scale_tril=None, validate_args=None) [исходный код]

Базовые классы: Distribution

Создает многомерное нормальное (также называемое гауссовым) распределение, заданное вектором среднего и ковариационной матрицей.

Многомерное нормальное распределение можно задать через положительно определенную ковариационную матрицу $\mathbf{\Sigma}$ , положительно определенную матрицу точности $\mathbf{\Sigma}^{-1}$ или нижнетреугольную матрицу $\mathbf{L}$ с положительными диагональными элементами так, чтобы $\mathbf{\Sigma} = \mathbf{L}\mathbf{L}^\top$ . Эту треугольную матрицу можно получить, например, с помощью разложения Холецкого ковариационной матрицы.

Пример

>>> m = MultivariateNormal(torch.zeros(2), torch.eye(2))
>>> m.sample()  # normally distributed with mean=`[0,0]` and covariance_matrix=`I`
tensor([-0.2102, -0.5429])

Параметры:

loc (Tensor) – среднее распределения
covariance_matrix (Tensor) – положительно определенная ковариационная матрица
precision_matrix (Tensor) – положительно определенная матрица точности
scale_tril (Tensor) – нижнетреугольный множитель ковариационной матрицы с положительными диагональными элементами

Примечание

Можно задать только один из параметров covariance_matrix, precision_matrix или scale_tril.

Использование scale_tril эффективнее: все вычисления внутри основаны на scale_tril. Если вместо него переданы covariance_matrix или precision_matrix, они используются только для вычисления соответствующих нижнетреугольных матриц с помощью разложения Холецкого.

arg_constraints = {'covariance_matrix': PositiveDefinite(), 'loc': IndependentConstraint(Real(), 1), 'precision_matrix': PositiveDefinite(), 'scale_tril': LowerCholesky()}

property covariance_matrix: Tensor

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

property precision_matrix: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

property scale_tril: Tensor

support = IndependentConstraint(Real(), 1)

property variance: Tensor

NegativeBinomial

class torch.distributions.negative_binomial.NegativeBinomial(total_count, probs=None, logits=None, validate_args=None) [исходный код]

Базовые классы: Distribution

Создает отрицательное биномиальное распределение, то есть распределение числа успешных независимых испытаний Бернулли с одинаковыми параметрами до наступления total_count неудач. Вероятность успеха каждого испытания Бернулли задается параметром probs.

Параметры:

total_count (float или Tensor) – неотрицательное число неудачных испытаний Бернулли, после которого следует остановиться; распределение остается допустимым и для вещественных значений числа испытаний
probs (Tensor) – вероятности наступления события в полуоткрытом интервале [0, 1)
logits (Tensor) – логарифмы шансов наступления события

arg_constraints = {'logits': Real(), 'probs': HalfOpenInterval(lower_bound=0.0, upper_bound=1.0), 'total_count': GreaterThanEq(lower_bound=0)}

expand(batch_shape, _instance=None) [исходный код]

log_prob(value) [исходный код]

property logits: Tensor

property mean: Tensor

property mode: Tensor

property param_shape: Size

property probs: Tensor

sample(sample_shape=()) [исходный код]

support = IntegerGreaterThan(lower_bound=0)

property variance: Tensor

Normal

class torch.distributions.normal.Normal(loc, scale, validate_args=None) [исходный код]

Базовые классы: ExponentialFamily

Создает нормальное (также называемое гауссовым) распределение, заданное параметрами loc и scale.

Пример:

>>> m = Normal(torch.tensor([0.0]), torch.tensor([1.0]))
>>> m.sample()  # normally distributed with loc=0 and scale=1
tensor([ 0.1046])

Параметры:

loc (float или Tensor) – среднее распределения (часто обозначается mu)
scale (float или Tensor) – стандартное отклонение распределения (часто обозначается sigma)

arg_constraints = {'loc': Real(), 'scale': GreaterThan(lower_bound=0.0)}

cdf(value) [исходный код]

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

icdf(value) [исходный код]

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

sample(sample_shape=()) [исходный код]

property stddev: Tensor

support = Real()

property variance: Tensor

OneHotCategorical

class torch.distributions.one_hot_categorical.OneHotCategorical(probs=None, logits=None, validate_args=None) [исходный код]

Базовые классы: Distribution

Создает категориальное распределение с one-hot-кодированием, заданное параметром probs или logits.

Выборки представляют собой векторы с one-hot-кодированием размера probs.size(-1).

Примечание

Аргумент probs должен быть неотрицательным, конечным и иметь ненулевую сумму; он будет нормализован так, чтобы сумма значений вдоль последнего измерения равнялась 1. probs возвращает это нормализованное значение. Аргумент logits интерпретируется как ненормализованные логарифмы вероятностей, поэтому может принимать любые вещественные значения. Он также будет нормализован так, чтобы сумма полученных вероятностей вдоль последнего измерения равнялась 1. logits возвращает это нормализованное значение.

См. также: torch.distributions.Categorical() — описание параметров probs и logits.

Пример:

>>> m = OneHotCategorical(torch.tensor([ 0.25, 0.25, 0.25, 0.25 ]))
>>> m.sample()  # equal probability of 0, 1, 2, 3
tensor([ 0.,  0.,  0.,  1.])

Параметры:

probs (Tensor) – вероятности событий
logits (Tensor) – логарифмы вероятностей событий (ненормализованные)

arg_constraints = {'logits': IndependentConstraint(Real(), 1), 'probs': Simplex()}

entropy() [исходный код]

enumerate_support(expand=True) [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_enumerate_support = True

log_prob(value) [исходный код]

property logits: Tensor

property mean: Tensor

property mode: Tensor

property param_shape: Size

property probs: Tensor

sample(sample_shape=()) [исходный код]

support = OneHot()

property variance: Tensor

Pareto

class torch.distributions.pareto.Pareto(scale, alpha, validate_args=None) [исходный код]

Базовые классы: TransformedDistribution

Выбирает значения из распределения Парето I типа.

Пример:

>>> m = Pareto(torch.tensor([1.0]), torch.tensor([1.0]))
>>> m.sample()  # sample from a Pareto distribution with scale=1 and alpha=1
tensor([ 1.5623])

Параметры:

scale (float или Tensor) – параметр масштаба распределения
alpha (float или Tensor) – параметр формы распределения

arg_constraints: dict[str, Constraint] = {'alpha': GreaterThan(lower_bound=0.0), 'scale': GreaterThan(lower_bound=0.0)}

entropy() [исходный код]

Тип возвращаемого значения:: Tensor

expand(batch_shape, _instance=None) [исходный код]

Тип возвращаемого значения:: Pareto

property mean: Tensor

property mode: Tensor

property support: Constraint

Тип возвращаемого значения:: _DependentProperty

property variance: Tensor

Poisson

class torch.distributions.poisson.Poisson(rate, validate_args=None) [исходный код]

Базовые классы: ExponentialFamily

Создает распределение Пуассона, заданное параметром rate — параметром интенсивности.

Выборки представляют собой неотрицательные целые числа; функция вероятностей задается формулой

\mathrm{rate}^k \frac{e^{-\mathrm{rate}}}{k!}

Пример:

>>> m = Poisson(torch.tensor([4]))
>>> m.sample()
tensor([ 3.])

Параметры:: rate (Число, Tensor) – параметр интенсивности

arg_constraints = {'rate': GreaterThanEq(lower_bound=0.0)}

expand(batch_shape, _instance=None) [исходный код]

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

sample(sample_shape=()) [исходный код]

support = IntegerGreaterThan(lower_bound=0)

property variance: Tensor

RelaxedBernoulli

class torch.distributions.relaxed_bernoulli.RelaxedBernoulli(temperature, probs=None, logits=None, validate_args=None) [исходный код]

Базовые классы: TransformedDistribution

Создаёт распределение RelaxedBernoulli, параметризованное с помощью temperature и либо probs, либо logits (но не обоими одновременно). Это релаксированная версия распределения Bernoulli, поэтому значения принадлежат интервалу (0, 1), а выборки допускают репараметризацию.

Пример:

>>> m = RelaxedBernoulli(torch.tensor([2.2]),
...                      torch.tensor([0.1, 0.2, 0.3, 0.99]))
>>> m.sample()
tensor([ 0.2951,  0.3442,  0.8918,  0.9021])

Параметры:

temperature (Tensor) – температура релаксации
probs (Number, Tensor) – вероятность выборки 1
logits (Number, Tensor) – логарифм отношения шансов выборки 1

arg_constraints: dict[str, Constraint] = {'logits': Real(), 'probs': Interval(lower_bound=0.0, upper_bound=1.0)}

base_dist: LogitRelaxedBernoulli

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

property logits: Tensor

property probs: Tensor

support = Interval(lower_bound=0.0, upper_bound=1.0)

property temperature: Tensor

LogitRelaxedBernoulli

class torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli(temperature, probs=None, logits=None, validate_args=None) [исходный код]

Базовые классы: Distribution

Создаёт распределение LogitRelaxedBernoulli, параметризованное с помощью probs или logits (но не обоими одновременно); это логит распределения RelaxedBernoulli.

Выборки представляют собой логиты значений из интервала (0, 1). Подробнее см. [1].

Параметры:

temperature (Tensor) – температура релаксации
probs (Number, Tensor) – вероятность выборки 1
logits (Number, Tensor) – логарифм отношения шансов выборки 1

[1] Распределение Concrete: непрерывная релаксация дискретных случайных переменных (Maddison и др., 2017)

[2] Репараметризация категориального распределения с помощью Gumbel-Softmax (Jang и др., 2017)

arg_constraints = {'logits': Real(), 'probs': Interval(lower_bound=0.0, upper_bound=1.0)}

expand(batch_shape, _instance=None) [исходный код]

log_prob(value) [исходный код]

property logits: Tensor

property param_shape: Size

property probs: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

support = Real()

RelaxedOneHotCategorical

class torch.distributions.relaxed_categorical.RelaxedOneHotCategorical(temperature, probs=None, logits=None, validate_args=None) [исходный код]

Базовые классы: TransformedDistribution

Создаёт распределение RelaxedOneHotCategorical, параметризованное с помощью temperature и либо probs, либо logits. Это релаксированная версия распределения OneHotCategorical, поэтому его выборки лежат на симплексе и допускают репараметризацию.

Пример:

>>> m = RelaxedOneHotCategorical(torch.tensor([2.2]),
...                              torch.tensor([0.1, 0.2, 0.3, 0.4]))
>>> m.sample()
tensor([ 0.1294,  0.2324,  0.3859,  0.2523])

Параметры:

temperature (Tensor) – температура релаксации
probs (Tensor) – вероятности событий
logits (Tensor) – ненормированный логарифм вероятности каждого события

arg_constraints: dict[str, Constraint] = {'logits': IndependentConstraint(Real(), 1), 'probs': Simplex()}

base_dist: ExpRelaxedCategorical

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

property logits: Tensor

property probs: Tensor

support = Simplex()

property temperature: Tensor

StudentT

class torch.distributions.studentT.StudentT(df, loc=0.0, scale=1.0, validate_args=None) [исходный код]

Базовые классы: Distribution

Создаёт распределение Стьюдента с параметрами: число степеней свободы df, среднее loc и масштаб scale.

Пример:

>>> m = StudentT(torch.tensor([2.0]))
>>> m.sample()  # Student's t-distributed with degrees of freedom=2
tensor([ 0.1046])

Параметры:

df (float или Tensor) – число степеней свободы
loc (float или Tensor) – среднее распределения
scale (float или Tensor) – масштаб распределения

arg_constraints = {'df': GreaterThan(lower_bound=0.0), 'loc': Real(), 'scale': GreaterThan(lower_bound=0.0)}

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

support = Real()

property variance: Tensor

TransformedDistribution

class torch.distributions.transformed_distribution.TransformedDistribution(base_distribution, transforms, validate_args=None) [исходный код]

Базовые классы: Distribution

Расширение класса Distribution, применяющее к базовому распределению последовательность преобразований. Пусть f — композиция применённых преобразований:

X ~ BaseDistribution
Y = f(X) ~ TransformedDistribution(BaseDistribution, f)
log p(Y) = log p(X) + log |det (dX/dY)|

Обратите внимание, что .event_shape объекта TransformedDistribution — это максимальная форма его базового распределения и преобразований, поскольку преобразования могут создавать корреляции между событиями.

Пример использования TransformedDistribution:

# Building a Logistic Distribution
# X ~ Uniform(0, 1)
# f = a + b * logit(X)
# Y ~ f(X) ~ Logistic(a, b)
base_distribution = Uniform(0, 1)
transforms = [SigmoidTransform().inv, AffineTransform(loc=a, scale=b)]
logistic = TransformedDistribution(base_distribution, transforms)

Дополнительные примеры см. в реализациях Gumbel, HalfCauchy, HalfNormal, LogNormal, Pareto, Weibull, RelaxedBernoulli и RelaxedOneHotCategorical

arg_constraints: dict[str, Constraint] = {}

cdf(value) [исходный код]: Вычисляет функцию распределения, обращая преобразования и вычисляя значение функции распределения базового распределения.

expand(batch_shape, _instance=None) [исходный код]

property has_rsample: bool

icdf(value) [исходный код]: Вычисляет обратную функцию распределения, применяя преобразования и вычисляя значение функции распределения базового распределения.

log_prob(value) [исходный код]: Вычисляет логарифм плотности выборки, обращая преобразования и используя логарифм плотности базового распределения и логарифм абсолютного определителя якобиана.

rsample(sample_shape=()) [исходный код]

Создаёт выборку с формой sample_shape, допускающую репараметризацию, или пакет таких выборок с формой sample_shape, если параметры распределения заданы пакетами. Сначала выполняет выборку из базового распределения, а затем применяет transform() для каждого преобразования в списке.

Тип возвращаемого значения:: Tensor

sample(sample_shape=()) [исходный код]: Создаёт выборку с формой sample_shape или пакет выборок с формой sample_shape, если параметры распределения заданы пакетами. Сначала выполняет выборку из базового распределения, а затем применяет transform() для каждого преобразования в списке.

property support

Тип возвращаемого значения:: _DependentProperty

Uniform

class torch.distributions.uniform.Uniform(low, high, validate_args=None) [исходный код]

Базовые классы: Distribution

Генерирует равномерно распределённые случайные выборки из полуоткрытого интервала [low, high).

Пример:

>>> m = Uniform(torch.tensor([0.0]), torch.tensor([5.0]))
>>> m.sample()  # uniformly distributed in the range [0.0, 5.0)
tensor([ 2.3418])

Параметры:

low (float или Tensor) – нижняя граница диапазона (включительно).
high (float или Tensor) – верхняя граница диапазона (исключительно).

property arg_constraints

cdf(value) [исходный код]

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

icdf(value) [исходный код]

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

rsample(sample_shape=()) [исходный код]

Тип возвращаемого значения:: Tensor

property stddev: Tensor

property support

Тип возвращаемого значения:: _DependentProperty

property variance: Tensor

VonMises

class torch.distributions.von_mises.VonMises(loc, concentration, validate_args=None) [исходный код]

Базовые классы: Distribution

Круговое распределение фон Мизеса.

В этой реализации используются полярные координаты. Аргументы loc и value могут принимать любые вещественные значения (для упрощения оптимизации без ограничений), но интерпретируются как углы по модулю 2 pi.

Пример::

>>> m = VonMises(torch.tensor([1.0]), torch.tensor([1.0]))
>>> m.sample()  # von Mises distributed with loc=1 and concentration=1
tensor([1.9777])

Параметры:

loc (torch.Tensor) – угол в радианах.
concentration (torch.Tensor) – параметр концентрации

arg_constraints = {'concentration': GreaterThan(lower_bound=0.0), 'loc': Real()}

expand(batch_shape, _instance=None) [исходный код]

has_rsample = False

log_prob(value) [исходный код]

property mean: Tensor: Здесь указано круговое среднее.

property mode: Tensor

sample(sample_shape=()) [исходный код]

Алгоритм выборки для распределения фон Мизеса основан на следующей статье: D.J. Best и N.I. Fisher, «Эффективное моделирование распределения фон Мизеса». Applied Statistics (1979): 152–157.

Выборка всегда выполняется внутри в двойной точности, чтобы избежать зависания в _rejection_sample() при малых значениях концентрации; для одинарной точности это начинает происходить примерно при 1e-4 (см. issue #88443).

support = Real()

property variance: Tensor: Здесь указана круговая дисперсия.

Вейбулла

class torch.distributions.weibull.Weibull(scale, concentration, validate_args=None) [исходный код]

Базовые классы: TransformedDistribution

Выборки из двухпараметрического распределения Вейбулла.

Пример

>>> m = Weibull(torch.tensor([1.0]), torch.tensor([1.0]))
>>> m.sample()  # sample from a Weibull distribution with scale=1, concentration=1
tensor([ 0.4784])

Параметры:

scale (float или Tensor) – Параметр масштаба распределения (lambda).
concentration (float или Tensor) – Параметр концентрации распределения (k/shape).
validate_args (bool, необязательно) – Проверять ли аргументы. По умолчанию: None.

arg_constraints: dict[str, Constraint] = {'concentration': GreaterThan(lower_bound=0.0), 'scale': GreaterThan(lower_bound=0.0)}

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

property mean: Tensor

property mode: Tensor

support = GreaterThan(lower_bound=0.0)

property variance: Tensor

Уишарта

class torch.distributions.wishart.Wishart(df, covariance_matrix=None, precision_matrix=None, scale_tril=None, validate_args=None) [исходный код]

Базовые классы: ExponentialFamily

Создает распределение Уишарта, параметризованное симметричной положительно определенной матрицей $\Sigma$ или ее разложением Холецкого $\mathbf{\Sigma} = \mathbf{L}\mathbf{L}^\top$

Пример

>>> m = Wishart(torch.Tensor([2]), covariance_matrix=torch.eye(2))
>>> m.sample()  # Wishart distributed with mean=`df * I` and
>>> # variance(x_ij)=`df` for i != j and variance(x_ij)=`2 * df` for i == j

Параметры:

df (float или Tensor) – вещественный параметр, превышающий размерность квадратной матрицы минус 1
covariance_matrix (Tensor) – положительно определенная ковариационная матрица
precision_matrix (Tensor) – положительно определенная матрица точности
scale_tril (Tensor) – нижнетреугольный множитель ковариации с положительными элементами на диагонали

Примечание

Можно указать только один из параметров covariance_matrix, precision_matrix или scale_tril. Использование scale_tril будет более эффективным: все вычисления внутри основаны на scale_tril. Если вместо этого передан параметр covariance_matrix или precision_matrix, он используется только для вычисления соответствующих нижнетреугольных матриц посредством разложения Холецкого. «torch.distributions.LKJCholesky» — ограниченное распределение Уишарта.[1]

Литература

[1] Wang, Z., Wu, Y. and Chu, H., 2018. On equivalence of the LKJ distribution and the restricted Wishart distribution. [2] Sawyer, S., 2007. Wishart Distributions and Inverse-Wishart Sampling. [3] Anderson, T. W., 2003. An Introduction to Multivariate Statistical Analysis (3rd ed.). [4] Odell, P. L. & Feiveson, A. H., 1966. A Numerical Procedure to Generate a Sample Covariance Matrix. JASA, 61(313):199-203. [5] Ku, Y.-C. & Bloomfield, P., 2010. Generating Random Wishart Matrices with Fractional Degrees of Freedom in OX.

property arg_constraints

property covariance_matrix: Tensor

entropy() [исходный код]

expand(batch_shape, _instance=None) [исходный код]

has_rsample = True

log_prob(value) [исходный код]

property mean: Tensor

property mode: Tensor

property precision_matrix: Tensor

rsample(sample_shape=(), max_try_correction=None) [исходный код]

Предупреждение

В некоторых случаях алгоритм выборки, основанный на разложении Бартлетта, может возвращать вырожденные матрицы. По умолчанию предпринимается несколько попыток исправить вырожденные выборки, однако в итоге могут быть возвращены вырожденные матрицы. Вырожденные выборки могут приводить к значениям -inf в .log_prob(). В таких случаях пользователю следует проверить выборки и либо исправить значение df, либо соответствующим образом скорректировать значение max_try_correction аргумента в .rsample.

Тип возвращаемого значения:: Tensor

property scale_tril: Tensor

support = PositiveDefinite()

property variance: Tensor

`KL Divergence`

torch.distributions.kl.kl_divergence(p, q) [исходный код]

Вычисляет дивергенцию Кульбака — Лейблера $KL(p \| q)$ между двумя распределениями.

KL(p \| q) = \int p(x) \log\frac {p(x)} {q(x)} \,dx

Параметры:

p (Distribution) – Объект Distribution.
q (Distribution) – Объект Distribution.

Возвращает:

Пакет значений дивергенции KL формы batch_shape.

Тип возвращаемого значения:

Tensor

Вызывает исключение:

NotImplementedError – Если типы распределений не зарегистрированы с помощью register_kl().

В настоящее время дивергенция KL реализована для следующих пар распределений:

Bernoulli и Bernoulli
Bernoulli и Poisson
Beta и Beta
Beta и ContinuousBernoulli
Beta и Exponential
Beta и Gamma
Beta и Normal
Beta и Pareto
Beta и Uniform
Binomial и Binomial
Categorical и Categorical
Cauchy и Cauchy
ContinuousBernoulli и ContinuousBernoulli
ContinuousBernoulli и Exponential
ContinuousBernoulli и Normal
ContinuousBernoulli и Pareto
ContinuousBernoulli и Uniform
Dirichlet и Dirichlet
Exponential и Beta
Exponential и ContinuousBernoulli
Exponential и Exponential
Exponential и Gamma
Exponential и Gumbel
Exponential и Normal
Exponential и Pareto
Exponential и Uniform
ExponentialFamily и ExponentialFamily
Gamma и Beta
Gamma и ContinuousBernoulli
Gamma и Exponential
Gamma и Gamma
Gamma и Gumbel
Gamma и Normal
Gamma и Pareto
Gamma и Uniform
Geometric и Geometric
Gumbel и Beta
Gumbel и ContinuousBernoulli
Gumbel и Exponential
Gumbel и Gamma
Gumbel и Gumbel
Gumbel и Normal
Gumbel и Pareto
Gumbel и Uniform
HalfNormal и HalfNormal
Independent и Independent
Laplace и Beta
Laplace и ContinuousBernoulli
Laplace и Exponential
Laplace и Gamma
Laplace и Laplace
Laplace и Normal
Laplace и Pareto
Laplace и Uniform
LowRankMultivariateNormal и LowRankMultivariateNormal
LowRankMultivariateNormal и MultivariateNormal
MultivariateNormal и LowRankMultivariateNormal
MultivariateNormal и MultivariateNormal
Normal и Beta
Normal и ContinuousBernoulli
Normal и Exponential
Normal и Gamma
Normal и Gumbel
Normal и Laplace
Normal и Normal
Normal и Pareto
Normal и Uniform
OneHotCategorical и OneHotCategorical
Pareto и Beta
Pareto и ContinuousBernoulli
Pareto и Exponential
Pareto и Gamma
Pareto и Normal
Pareto и Pareto
Pareto и Uniform
Poisson и Bernoulli
Poisson и Binomial
Poisson и Poisson
TransformedDistribution и TransformedDistribution
Uniform и Beta
Uniform и ContinuousBernoulli
Uniform и Exponential
Uniform и Gamma
Uniform и Gumbel
Uniform и Normal
Uniform и Pareto
Uniform и Uniform

torch.distributions.kl.register_kl(type_p, type_q) [исходный код]

Декоратор для регистрации попарной функции с помощью kl_divergence(). Использование:

@register_kl(Normal, Normal)
def kl_normal_normal(p, q):
    # insert implementation here

Поиск возвращает наиболее конкретное соответствие (тип, тип), упорядоченное по подклассам. Если соответствие неоднозначно, возникает исключение RuntimeWarning. Например, чтобы разрешить неоднозначную ситуацию:

@register_kl(BaseP, DerivedQ)
def kl_version1(p, q): ...
@register_kl(DerivedP, BaseQ)
def kl_version2(p, q): ...

следует зарегистрировать третью, наиболее конкретную реализацию, например:

register_kl(DerivedP, DerivedQ)(kl_version1)  # Break the tie.

Параметры:

type_p (type) – Подкласс Distribution.
type_q (type) – Подкласс Distribution.

`Transforms`

class torch.distributions.transforms.AbsTransform(cache_size=0) [исходный код]: Преобразование с помощью отображения $y = |x|$ .

class torch.distributions.transforms.AffineTransform(loc, scale, event_dim=0, cache_size=0) [исходный код]

Преобразование с помощью поточечного аффинного отображения $y = \text{loc} + \text{scale} \times x$ .

Параметры:

loc (Tensor или float) – Параметр положения.
scale (Tensor или float) – Параметр масштаба.
event_dim (int) – Необязательный размер event_shape. Для одномерных случайных величин он должен быть равен нулю, для распределений на векторах — 1, для распределений на матрицах — 2 и т. д.

class torch.distributions.transforms.CatTransform(tseq, dim=0, lengths=None, cache_size=0) [исходный код]

Функтор преобразования, который применяет последовательность преобразований tseq покомпонентно к каждой подматрице по оси dim длины lengths[dim], совместимым с torch.cat().

Пример:

x0 = torch.cat([torch.range(1, 10), torch.range(1, 10)], dim=0)
x = torch.cat([x0, x0], dim=0)
t0 = CatTransform([ExpTransform(), identity_transform], dim=0, lengths=[10, 10])
t = CatTransform([t0, t0], dim=0, lengths=[20, 20])
y = t(x)

class torch.distributions.transforms.ComposeTransform(parts, cache_size=0) [исходный код]

Объединяет несколько преобразований в цепочку. За кэширование отвечают объединяемые преобразования.

Параметры:

parts (список объектов Transform) – Список преобразований для объединения.
cache_size (int) – Размер кэша. Если равен нулю, кэширование не выполняется. Если равен единице, кэшируется последнее значение. Поддерживаются только значения 0 и 1.

class torch.distributions.transforms.CorrCholeskyTransform(cache_size=0) [исходный код]

Преобразует неограниченный вещественный вектор $x$ длины $D*(D-1)/2$ в разложение Холецкого корреляционной матрицы размера D. Это разложение Холецкого представляет собой нижнюю треугольную матрицу с положительными диагональными элементами и единичной евклидовой нормой каждой строки. Преобразование выполняется следующим образом:

Сначала преобразуем x в нижнюю треугольную матрицу, заполняя её построчно.
Для каждой строки $X_i$ нижней треугольной части применяем знаковую версию класса StickBreakingTransform, чтобы преобразовать $X_i$ в вектор с единичной евклидовой нормой, выполнив следующие действия: - Масштабируем значения до интервала $(-1, 1)$ : $r_i = \tanh(X_i)$ . - Преобразуем значения в область неотрицательных чисел: $z_i = r_i^2$ . - Применяем $s_i = StickBreakingTransform(z_i)$ . - Возвращаем значения в знаковую область: $y_i = sign(r_i) * \sqrt{s_i}$ .

class torch.distributions.transforms.CumulativeDistributionTransform(distribution, cache_size=0) [исходный код]

Преобразование с помощью функции распределения вероятности.

Параметры:: distribution (Distribution) – Распределение, функцию распределения которого следует использовать для преобразования.

Пример:

# Construct a Gaussian copula from a multivariate normal.
base_dist = MultivariateNormal(
    loc=torch.zeros(2),
    scale_tril=LKJCholesky(2).sample(),
)
transform = CumulativeDistributionTransform(Normal(0, 1))
copula = TransformedDistribution(base_dist, [transform])

class torch.distributions.transforms.ExpTransform(cache_size=0) [исходный код]: Преобразование с помощью отображения $y = \exp(x)$ .

class torch.distributions.transforms.IndependentTransform(base_transform, reinterpreted_batch_ndims, cache_size=0) [исходный код]

Обёртка над другим преобразованием, позволяющая считать reinterpreted_batch_ndims дополнительных крайних справа измерений зависимыми. Это не влияет на прямое и обратное преобразования, но суммирует reinterpreted_batch_ndims крайних справа измерений в log_abs_det_jacobian().

Параметры:

base_transform (Transform) – Базовое преобразование.
reinterpreted_batch_ndims (int) – Число дополнительных крайних справа измерений, которые следует считать зависимыми.

class torch.distributions.transforms.LowerCholeskyTransform(cache_size=0) [исходный код]

Преобразование неограниченных матриц в нижние треугольные матрицы с неотрицательными диагональными элементами.

Это полезно для параметризации положительно определённых матриц через их разложение Холецкого.

class torch.distributions.transforms.PositiveDefiniteTransform(cache_size=0) [исходный код]: Преобразование неограниченных матриц в положительно определённые матрицы.

class torch.distributions.transforms.PowerTransform(exponent, cache_size=0) [исходный код]: Преобразование с помощью отображения $y = x^{\text{exponent}}$ .

class torch.distributions.transforms.ReshapeTransform(in_shape, out_shape, cache_size=0) [исходный код]

Преобразование с единичным якобианом для изменения формы крайней справа части тензора.

Обратите внимание: in_shape и out_shape должны содержать одинаковое число элементов, как и в случае с torch.Tensor.reshape().

Параметры:

in_shape (torch.Size) – Форма входного события.
out_shape (torch.Size) – Форма выходного события.
cache_size (int) – Размер кэша. Если равен нулю, кэширование не выполняется. Если равен единице, кэшируется последнее значение. Поддерживаются только значения 0 и 1. (По умолчанию — 0.)

class torch.distributions.transforms.SigmoidTransform(cache_size=0) [исходный код]: Преобразование с помощью отображений $y = \frac{1}{1 + \exp(-x)}$ и $x = \text{logit}(y)$ .

class torch.distributions.transforms.SoftplusTransform(cache_size=0) [исходный код]: Преобразование с помощью отображения $\text{Softplus}(x) = \log(1 + \exp(x))$ . При $x > 20$ реализация переключается на линейную функцию.

class torch.distributions.transforms.TanhTransform(cache_size=0) [исходный код]

Преобразование с помощью отображения $y = \tanh(x)$ .

Это эквивалентно

ComposeTransform(
    [
        AffineTransform(0.0, 2.0),
        SigmoidTransform(),
        AffineTransform(-1.0, 2.0),
    ]
)

Однако такое вычисление может быть численно нестабильным, поэтому рекомендуется использовать вместо него TanhTransform.

Обратите внимание: для значений NaN/Inf следует использовать cache_size=1.

class torch.distributions.transforms.SoftmaxTransform(cache_size=0) [исходный код]

Преобразование из неограниченного пространства в симплекс: применяется $y = \exp(x)$ , а затем выполняется нормализация.

Это преобразование не является биекцией и не может использоваться для HMC. Однако оно действует преимущественно покоординатно (за исключением заключительной нормализации), поэтому подходит для алгоритмов покоординатной оптимизации.

class torch.distributions.transforms.StackTransform(tseq, dim=0, cache_size=0) [исходный код]

Функтор преобразования, который применяет последовательность преобразований tseq покомпонентно к каждой подматрице по оси dim совместимым с torch.stack().

Пример:

x = torch.stack([torch.range(1, 10), torch.range(1, 10)], dim=1)
t = StackTransform([ExpTransform(), identity_transform], dim=1)
y = t(x)

class torch.distributions.transforms.StickBreakingTransform(cache_size=0) [исходный код]

Преобразование из неограниченного пространства в симплекс на одно измерение большей размерности с помощью процесса разбиения палочки.

Это преобразование представляет собой последовательное применение сигмоидального преобразования в построении распределения Dirichlet методом разбиения палочки: первый логит преобразуется сигмоидой в первую вероятность и вероятность всех остальных исходов, после чего процесс повторяется.

Это преобразование является биекцией и подходит для использования в HMC; однако оно связывает координаты друг с другом и меньше подходит для оптимизации.

class torch.distributions.transforms.Transform(cache_size=0) [исходный код]

Абстрактный класс для обратимых преобразований с вычислимым логарифмом определителя якобиана. Они используются главным образом в torch.distributions.TransformedDistribution.

Кэширование полезно для преобразований, обратные операции которых требуют больших вычислительных затрат или численно нестабильны. Обратите внимание: при работе с мемоизированными значениями нужно соблюдать осторожность, поскольку граф autograd может быть обращён. Например, следующий код работает как с кэшированием, так и без него:

y = t(x)
t.log_abs_det_jacobian(x, y).backward()  # x will receive gradients.

Однако следующий код вызовет ошибку при кэшировании из-за обращения зависимостей:

y = t(x)
z = t.inv(y)
grad(z.sum(), [y])  # error because z is x

Производные классы должны реализовать один или оба метода: _call() и _inverse(). Производные классы, задающие bijective=True, также должны реализовать log_abs_det_jacobian().

Параметры:

cache_size (int) – Размер кэша. Если равен нулю, кэширование не выполняется. Если равен единице, кэшируется последнее значение. Поддерживаются только значения 0 и 1.

Переменные:

domain (Constraint) – Ограничение, задающее допустимые входные значения этого преобразования.
codomain (Constraint) – Ограничение, задающее допустимые выходные значения этого преобразования, которые являются входными значениями обратного преобразования.
bijective (bool) – Является ли это преобразование биекцией. Преобразование t является биекцией тогда и только тогда, когда t.inv(t(x)) == x и t(t.inv(y)) == y для каждого x из области определения и y из области значений. Преобразования, не являющиеся биекциями, должны по крайней мере удовлетворять более слабым свойствам псевдообратимости t(t.inv(t(x)) == t(x) и t.inv(t(t.inv(y))) == t.inv(y).
sign (int или Tensor) – Для биективных одномерных преобразований это значение должно быть +1 или -1 в зависимости от того, является ли преобразование монотонно возрастающим или убывающим.

property inv: Transform: Возвращает обратное Transform для этого преобразования. Оно должно удовлетворять условию t.inv.inv is t.

property sign: int: Возвращает знак определителя якобиана, если это применимо. В общем случае это имеет смысл только для биективных преобразований.

log_abs_det_jacobian(x, y) [исходный код]: Вычисляет логарифм определителя якобиана log |dy/dx| по заданным входному и выходному значениям.

forward_shape(shape) [исходный код]: Определяет форму результата прямого вычисления по форме входных данных. По умолчанию форма сохраняется.

inverse_shape(shape) [исходный код]: Определяет формы результата обратного вычисления по форме выходных данных. По умолчанию форма сохраняется.

identity_transform

Объединяет несколько преобразований в цепочку.

`Constraints`

class torch.distributions.constraints.Constraint [исходный код]

Абстрактный базовый класс для ограничений.

Объект ограничения задаёт область, в которой переменная является допустимой, например область, в пределах которой можно оптимизировать переменную.

Переменные:

is_discrete (bool) – Является ли ограниченное пространство дискретным. По умолчанию False.
event_dim (int) – Количество крайних справа измерений, которые вместе определяют событие. Метод check() удаляет это количество измерений при вычислении допустимости.

check(value) [исходный код]: Возвращает байтовый тензор sample_shape + batch_shape, указывающий, удовлетворяет ли каждое событие в value этому ограничению.

torch.distributions.constraints.cat [исходный код]: псевдоним _Cat

torch.distributions.constraints.dependent_property [исходный код]: псевдоним _DependentProperty

torch.distributions.constraints.greater_than [исходный код]: псевдоним _GreaterThan

torch.distributions.constraints.greater_than_eq [исходный код]: псевдоним _GreaterThanEq

torch.distributions.constraints.independent [исходный код]: псевдоним _IndependentConstraint

torch.distributions.constraints.integer_interval [исходный код]: псевдоним _IntegerInterval

torch.distributions.constraints.interval [исходный код]: псевдоним _Interval

torch.distributions.constraints.half_open_interval [исходный код]: псевдоним _HalfOpenInterval

torch.distributions.constraints.is_dependent(constraint) [исходный код]

Проверяет, является ли constraint объектом _Dependent.

Параметры:: constraint – Объект Constraint.
Возвращает:: True, если constraint можно уточнить до типа _Dependent, иначе False.
Тип возвращаемого значения:: bool

Примеры

>>> import torch
>>> from torch.distributions import 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]:
>>>     if is_dependent(constraint):
>>>         continue

torch.distributions.constraints.less_than [исходный код]: псевдоним _LessThan

class torch.distributions.constraints.MixtureSameFamilyConstraint(base_constraint) [исходный код]

Ограничение для распределения MixtureSameFamily, которое восстанавливает крайнее справа измерение пакета перед проверкой допустимости с использованием ограничения распределения-компонента.

Параметры:: base_constraint – Объект Constraint распределения-компонента распределения MixtureSameFamily.

check(value) [исходный код]: Проверяет допустимость value в качестве возможного результата выборки из распределения MixtureSameFamily.

torch.distributions.constraints.multinomial [исходный код]: псевдоним _Multinomial

torch.distributions.constraints.stack [исходный код]: псевдоним _Stack

dependent

Заполнитель для переменных, область допустимых значений которых зависит от других переменных.

`Constraint Registry`

PyTorch предоставляет два глобальных объекта ConstraintRegistry, которые связывают объекты Constraint с объектами Transform. Оба объекта принимают ограничения и возвращают преобразования, но гарантии биективности у них различаются.

biject_to(constraint) ищет биективное преобразование Transform из constraints.real в указанное constraint. Гарантируется, что возвращаемое преобразование обладает .bijective = True и реализует .log_abs_det_jacobian().
transform_to(constraint) ищет не обязательно биективное преобразование Transform из constraints.real в указанное constraint. Не гарантируется, что возвращаемое преобразование реализует .log_abs_det_jacobian().

Реестр transform_to() полезен для выполнения неограниченной оптимизации ограниченных параметров распределений вероятностей, которые указаны в словаре .arg_constraints каждого распределения. Эти преобразования часто используют параметризацию с избыточными параметрами, чтобы избежать поворота; поэтому они лучше подходят для алгоритмов оптимизации по координатам, таких как Adam:

loc = torch.zeros(100, requires_grad=True)
unconstrained = torch.zeros(100, requires_grad=True)
scale = transform_to(Normal.arg_constraints["scale"])(unconstrained)
loss = -Normal(loc, scale).log_prob(data).sum()

Реестр biject_to() полезен для метода Монте-Карло с гамильтоновой динамикой, где выборки из распределения вероятностей с ограниченным .support переносятся в неограниченное пространство, а алгоритмы обычно инвариантны относительно поворота.:

dist = Exponential(rate)
unconstrained = torch.zeros(100, requires_grad=True)
sample = biject_to(dist.support)(unconstrained)
potential_energy = -dist.log_prob(sample).sum()

Примечание

Примером, в котором transform_to и biject_to различаются, является constraints.simplex: transform_to(constraints.simplex) возвращает SoftmaxTransform, которое просто возводит входные значения в экспоненту и нормализует их; это недорогая операция, в основном выполняемая покоординатно, подходящая для таких алгоритмов, как SVI. В отличие от этого, biject_to(constraints.simplex) возвращает StickBreakingTransform, которое биективно отображает входные данные в пространство на одно измерение меньшей размерности; это более затратное и менее численно устойчивое преобразование, необходимое для таких алгоритмов, как HMC.

Объекты biject_to и transform_to можно расширять пользовательскими ограничениями и преобразованиями с помощью метода .register() — либо как функцию для одиночных ограничений:

transform_to.register(my_constraint, my_transform)

либо как декоратор для параметризованных ограничений:

@transform_to.register(MyConstraintClass)
def my_factory(constraint):
    assert isinstance(constraint, MyConstraintClass)
    return MyTransform(constraint.param1, constraint.param2)

Вы можете создать собственный реестр, создав новый объект ConstraintRegistry.

class torch.distributions.constraint_registry.ConstraintRegistry [исходный код]

Реестр для связывания ограничений с преобразованиями.

register(constraint, factory=None) [исходный код]

Регистрирует подкласс Constraint в этом реестре. Использование:

@my_registry.register(MyConstraintClass)
def construct_transform(constraint):
    assert isinstance(constraint, MyConstraint)
    return MyTransform(constraint.arg_constraints)

Параметры:

constraint (подкласс Constraint) – Подкласс Constraint или одиночный объект требуемого класса.
factory (Callable) – Вызываемый объект, который принимает объект ограничения и возвращает объект Transform.

`biject_to`	Реестр для связывания ограничений с преобразованиями.
`transform_to`	Реестр для связывания ограничений с преобразованиями.

`broadcast_all`	Принимает список значений (возможно, содержащий числа) и возвращает список, в котором каждое значение преобразовано с учётом широковещательной передачи по следующим правилам:
`clamp_probs`	Ограничивает вероятности открытым интервалом `(0, 1)`.
`logits_to_probs`	Преобразует тензор логитов в вероятности.
`probs_to_logits`	Преобразует тензор вероятностей в логиты.
`tril_matrix_to_vec`	Преобразует матрицу `D x D` или пакет матриц в (пакет) векторов, содержащих элементы нижнего треугольника матрицы в построчном порядке.
`vec_to_tril_matrix`	Преобразует вектор или пакет векторов в пакет нижних треугольных матриц `D x D`, содержащих элементы вектора в построчном порядке.

© 2026, PyTorch Contributors
PyTorch has a BSD-style license, as found in the LICENSE file.
https://docs.pytorch.org/docs/2.14/distributions.html