Вероятностные распределения - torch.distributions

Функция скора

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

где $\theta$ — параметры, $\alpha$ — скорость обучения, $r$ — вознаграждение, и $p(a|\pi^\theta(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=torch.Size([]), event_shape=torch.Size([]), validate_args=None) [source]

Bases: object

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

property arg_constraints: Dict[str, Constraint]

Возвращает словарь, где ключи — имена аргументов, а значения — объекты Constraint, которые должны удовлетворяться каждым аргументом этого распределения. Аргументы, которые не являются тензорами, в этом словаре не нужны.

property batch_shape

Возвращает форму, по которой параметрам присваиваются значения в группе.

cdf(value) [source]

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

Параметры:

value (Тензор) –

entropy() [source]

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

Возвращает:

Тензор формы batch_shape.

enumerate_support(expand=True) [source]

Возвращает тензор, содержащий все значения, поддерживаемые дискретным распределением. Результат будет перечисляться по измерению 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.

property event_shape

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

expand(batch_shape, _instance=None) [source]

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

Параметры:

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

Возвращает:

Новый экземпляр распределения с расширенными измерениями группы до batch_size.

icdf(value) [source]

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

Параметры:

value (Тензор) –

log_prob(value) [source]

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

Параметры:

value (Тензор) –

property mean

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

property mode

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

perplexity() [source]

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

Возвращает:

Тензор формы batch_shape.

rsample(sample_shape=torch.Size([])) [source]

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

sample(sample_shape=torch.Size([])) [source]

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

sample_n(n) [source]

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

static set_default_validate_args(value) [source]

Устанавливает, включена или выключена валидация.

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

Параметры:

value (bool) – Включить или выключить валидацию.

property stddev

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

property support: Optional[Any]

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

property variance

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

Семейство экспоненциальных распределений

class torch.distributions.exp_family.ExponentialFamily(batch_shape=torch.Size([]), event_shape=torch.Size([]), validate_args=None) [source]

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

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

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

Примечание

Этот класс является посредником между классом Distribution и распределениями, принадлежащими к семейству экспоненциальных распределений, в основном для проверки корректности методов .entropy() и аналитического расхождения Кульбака-Лейблера. Мы используем этот класс для вычисления энтропии и расхождения Кульбака-Лейблера с использованием фреймворка AD и расхождений Брегмана (по материалам: Франка Нильсена и Ричарда Нокка, Энтропии и перекрёстные энтропии экспоненциальных семейств).

entropy() [source]

Метод для вычисления энтропии с использованием расхождения Брегмана логарифмической функции нормировки.

Биномиальное

class torch.distributions.bernoulli.Bernoulli(probs=None, logits=None, validate_args=None) [source]

Создаёт распределение Бернулли, параметризованное значениями 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 (Число, Тензор) – вероятность получить значение 1
• logits (Число, Тензор) – логарифм отношения шансов получить значение 1

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

entropy() [source]

enumerate_support(expand=True) [source]

expand(batch_shape, _instance=None) [source]

has_enumerate_support = True

log_prob(value) [source]

property logits

property mean

property mode

property param_shape

property probs

sample(sample_shape=torch.Size([])) [source]

support = Boolean()

property variance

Бета

class torch.distributions.beta.Beta(concentration1, concentration0, validate_args=None) [source]

Bases: 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) – первый параметр концентрации распределения (часто обозначается как альфа)
• concentration0 (float или Tensor) – второй параметр концентрации распределения (часто обозначается как бета)

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

property concentration0

property concentration1

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

log_prob(value) [source]

property mean

property mode

rsample(sample_shape=()) [source]

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

property variance

Биномиальное

class torch.distributions.binomial.Binomial(total_count=1, probs=None, logits=None, validate_args=None) [source]

Bases: 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() [source]

enumerate_support(expand=True) [source]

expand(batch_shape, _instance=None) [source]

has_enumerate_support = True

log_prob(value) [source]

property logits

property mean

property mode

property param_shape

property probs

sample(sample_shape=torch.Size([])) [source]

property support

property variance

Категориальное

class torch.distributions.categorical.Categorical(probs=None, logits=None, validate_args=None) [source]

Bases: 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() [source]

enumerate_support(expand=True) [source]

expand(batch_shape, _instance=None) [source]

has_enumerate_support = True

log_prob(value) [source]

property logits

property mean

property mode

property param_shape

property probs

sample(sample_shape=torch.Size([])) [source]

property support

property variance

Коши

class torch.distributions.cauchy.Cauchy(loc, scale, validate_args=None) [source]

Bases: 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) [source]

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

icdf(value) [source]

log_prob(value) [source]

property mean

property mode

rsample(sample_shape=torch.Size([])) [source]

support = Real()

property variance

Chi2

class torch.distributions.chi2.Chi2(df, validate_args=None) [source]

Bases: 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 или Тензор) – параметр формы распределения

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

property df

expand(batch_shape, _instance=None) [source]

ContinuousBernoulli

class torch.distributions.continuous_bernoulli.ContinuousBernoulli(probs=None, logits=None, lims=(0.499, 0.501), validate_args=None) [source]

Bases: ExponentialFamily

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

Распределение поддерживается на [0, 1] и параметризуется «probs» (в (0,1)) или «logits» (вещественные значения). Обратите внимание, что, в отличие от распределения Бернулли, «probs» не соответствует вероятности, а «logits» — не соответствует логарифмическим вероятностям, но используются те же имена из-за сходства с Бернулли. Более подробную информацию см. в [1].

Пример:

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

Параметры:

• probs (Число, Тензор) – параметры со значениями в (0,1)
• logits (Число, Тензор) – вещественные параметры, синус которых соответствует ‘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) [source]

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

icdf(value) [source]

log_prob(value) [source]

property logits

property mean

property param_shape

property probs

rsample(sample_shape=torch.Size([])) [source]

sample(sample_shape=torch.Size([])) [source]

property stddev

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

property variance

Dirichlet

class torch.distributions.dirichlet.Dirichlet(concentration, validate_args=None) [source]

Bases: 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 (Тензор) – параметр концентрации распределения (часто обозначается как альфа)

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

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

log_prob(value) [source]

property mean

property mode

rsample(sample_shape=()) [source]

support = Simplex()

property variance

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

class torch.distributions.exponential.Exponential(rate, validate_args=None) [source]

Bases: ExponentialFamily

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

Пример:

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

Параметры:

rate (float или Tensor) – rate = 1 / scale распределения

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

cdf(value) [source]

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

icdf(value) [source]

log_prob(value) [source]

property mean

property mode

rsample(sample_shape=torch.Size([])) [source]

property stddev

support = GreaterThanEq(lower_bound=0.0)

property variance

Фишера-Снедекора

class torch.distributions.fishersnedecor.FisherSnedecor(df1, df2, validate_args=None) [source]

Bases: 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) [source]

has_rsample = True

log_prob(value) [source]

property mean

property mode

rsample(sample_shape=torch.Size([])) [source]

support = GreaterThan(lower_bound=0.0)

property variance

Гамма

class torch.distributions.gamma.Gamma(concentration, rate, validate_args=None) [source]

Bases: 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) – параметр скорости = 1 / масштаб распределения (часто обозначается как beta)

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

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

log_prob(value) [source]

property mean

property mode

rsample(sample_shape=torch.Size([])) [source]

support = GreaterThanEq(lower_bound=0.0)

property variance

Geometric

class torch.distributions.geometric.Geometric(probs=None, logits=None, validate_args=None) [source]

Bases: Distribution

Создаёт распределение Гипергеометрического параметризованное с помощью probs, где probs — вероятность успеха в испытаниях Бернулли. Оно представляет собой вероятность того, что в $k + 1$ испытаниях Бернулли первые $k$ испытаний завершились неудачей, прежде чем произойдёт успех.

Выборка — неотрицательные целые числа [0, $\inf$).

Пример:

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

Параметры:

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

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

entropy() [source]

expand(batch_shape, _instance=None) [source]

log_prob(value) [source]

property logits

property mean

property mode

property probs

sample(sample_shape=torch.Size([])) [source]

support = IntegerGreaterThan(lower_bound=0)

property variance

Gumbel

class torch.distributions.gumbel.Gumbel(loc, scale, validate_args=None) [source]

Bases: 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 или Тензор) — Параметр местоположения распределения
• scale (float или Тензор) — Параметр масштаба распределения

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

entropy() [source]

expand(batch_shape, _instance=None) [source]

log_prob(value) [source]

property mean

property mode

property stddev

support = Real()

property variance

Полукаучи

class torch.distributions.half_cauchy.HalfCauchy(scale, validate_args=None) [source]

Основывается на 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)}

cdf(value) [source]

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

icdf(prob) [source]

log_prob(value) [source]

property mean

property mode

property scale

support = GreaterThanEq(lower_bound=0.0)

property variance

Полунормаль

class torch.distributions.half_normal.HalfNormal(scale, validate_args=None) [source]

Основывается на 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)}

cdf(value) [source]

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

icdf(prob) [source]

log_prob(value) [source]

property mean

property mode

property scale

support = GreaterThanEq(lower_bound=0.0)

property variance

Independent

class torch.distributions.independent.Independent(base_distribution, reinterpreted_batch_ndims, validate_args=None) [source]

Bases: Distribution

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

Это в основном полезно для изменения формы результата 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] = {}

entropy() [source]

enumerate_support(expand=True) [source]

expand(batch_shape, _instance=None) [source]

property has_enumerate_support

property has_rsample

log_prob(value) [source]

property mean

property mode

rsample(sample_shape=torch.Size([])) [source]

sample(sample_shape=torch.Size([])) [source]

property support

property variance

Kumaraswamy

class torch.distributions.kumaraswamy.Kumaraswamy(concentration1, concentration0, validate_args=None) [source]

Bases: 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) – 1-й параметр концентрации распределения (часто обозначаемый как alpha)
• concentration0 (float или Tensor) – 2-й параметр концентрации распределения (часто обозначаемый как beta)

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

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

property mean

property mode

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

property variance

LKJХолеский

class torch.distributions.lkj_cholesky.LKJCholesky(dim, concentration=1.0, validate_args=None) [source]

Bases: Distribution

Распределение LKJ для нижнего треугольного фактора Холески корреляционных матриц. Распределение контролируется параметром $\eta$, чтобы вероятность корреляционной матрицы $M$, сгенерированной из фактора Холески, была пропорциональна $\det(M)^{\eta - 1}$. Вследствие этого, при значении $\eta = 1$ мы получаем равномерное распределение по факторам Холески корреляционных матриц. Обратите внимание, что это распределение генерирует фактор Холески корреляционных матриц, а не сами корреляционные матрицы, и таким образом несколько отличается от производных в [1] для распределения LKJCorr. Для генерации используется метод «Луковицы» из [1], раздел 3.

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

Пример:

>>> 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]])

Параметры:

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

Ссылки

[1] Generating random correlation matrices based on vines and extended onion method, Daniel Lewandowski, Dorota Kurowicka, Harry Joe.

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

expand(batch_shape, _instance=None) [source]

log_prob(value) [source]

sample(sample_shape=torch.Size([])) [source]

support = CorrCholesky()

Лаплас

class torch.distributions.laplace.Laplace(loc, scale, validate_args=None) [source]

Bases: 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) [source]

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

icdf(value) [source]

log_prob(value) [source]

property mean

property mode

rsample(sample_shape=torch.Size([])) [source]

property stddev

support = Real()

property variance

Логарифмически-нормальное

class torch.distributions.log_normal.LogNormal(loc, scale, validate_args=None) [source]

Bases: 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)}

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

property loc

property mean

property mode

property scale

support = GreaterThan(lower_bound=0.0)

property variance

Матрица с низким рангом для многомерного нормального распределения

class torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal(loc, cov_factor, cov_diag, validate_args=None) [source]

Bases: Distribution

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

covariance_matrix = cov_factor @ cov_factor.T + cov_diag

Пример

>>> m = LowRankMultivariateNormal(torch.zeros(2), torch.tensor([[1.], [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

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

log_prob(value) [source]

property mean

property mode

property precision_matrix

rsample(sample_shape=torch.Size([])) [source]

property scale_tril

support = IndependentConstraint(Real(), 1)

property variance

MixtureSameFamily

class torch.distributions.mixture_same_family.MixtureSameFamily(mixture_distribution, component_distribution, validate_args=None) [source]

Bases: 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 Modle 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 – torch.distributions.Categorical-подобный экземпляр. Управляет вероятностью выбора компоненты. Количество категорий должно соответствовать правой конечной размерности пакета component_distribution. Должен иметь либо скалярное значение batch_shape или batch_shape, соответствующее component_distribution.batch_shape[:-1]
• component_distribution – torch.distributions.Distribution-подобный экземпляр. Правая конечная размерность пакета индексирует компонент.

arg_constraints: Dict[str, Constraint] = {}

cdf(x) [source]

property component_distribution

expand(batch_shape, _instance=None) [source]

has_rsample = False

log_prob(x) [source]

property mean

property mixture_distribution

sample(sample_shape=torch.Size([])) [source]

property support

property variance

Multinomial

class torch.distributions.multinomial.Multinomial(total_count=1, probs=None, logits=None, validate_args=None) [source]

Bases: 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() [source]

expand(batch_shape, _instance=None) [source]

log_prob(value) [source]

property logits

property mean

property param_shape

property probs

sample(sample_shape=torch.Size([])) [source]

property support

total_count: int

property variance

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

class torch.distributions.multivariate_normal.MultivariateNormal(loc, covariance_matrix=None, precision_matrix=None, scale_tril=None, validate_args=None) [source]

Bases: 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 (Тензор) – среднее значение распределения
• covariance_matrix (Тензор) – положительно определённая матрица ковариации
• precision_matrix (Тензор) – положительно определённая матрица точности
• scale_tril (Тензор) – нижнетреугольная часть фактора ковариации с положительными диагональными элементами

Примечание

Можно указать только один из 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

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

log_prob(value) [source]

property mean

property mode

property precision_matrix

rsample(sample_shape=torch.Size([])) [source]

property scale_tril

support = IndependentConstraint(Real(), 1)

property variance

Отрицательное биномиальное распределение

class torch.distributions.negative_binomial.NegativeBinomial(total_count, probs=None, logits=None, validate_args=None) [source]

Bases: Distribution

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

Параметры:

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

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) [source]

log_prob(value) [source]

property logits

property mean

property mode

property param_shape

property probs

sample(sample_shape=torch.Size([])) [source]

support = IntegerGreaterThan(lower_bound=0)

property variance

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

class torch.distributions.normal.Normal(loc, scale, validate_args=None) [source]

Bases: 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 или Тензор) – среднее значение распределения (часто обозначается как mu)
• scale (float или Тензор) – стандартное отклонение распределения (часто обозначается как sigma)

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

cdf(value) [source]

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

icdf(value) [source]

log_prob(value) [source]

property mean

property mode

rsample(sample_shape=torch.Size([])) [source]

sample(sample_shape=torch.Size([])) [source]

property stddev

support = Real()

property variance

OneHotCategorical

class torch.distributions.one_hot_categorical.OneHotCategorical(probs=None, logits=None, validate_args=None) [source]

Bases: 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 (Тензор) – вероятности событий
• logits (Тензор) – логарифмированные вероятности событий (ненормализованные)

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

entropy() [source]

enumerate_support(expand=True) [source]

expand(batch_shape, _instance=None) [source]

has_enumerate_support = True

log_prob(value) [source]

property logits

property mean

property mode

property param_shape

property probs

sample(sample_shape=torch.Size([])) [source]

support = OneHot()

property variance

Pareto

class torch.distributions.pareto.Pareto(scale, alpha, validate_args=None) [source]

Bases: TransformedDistribution

Генерирует образцы из распределения Парето 1 типа.

Пример:

>>> 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 или Тензор) – Параметр масштаба распределения
• alpha (float или Тензор) – Параметр формы распределения

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

entropy() [source]

expand(batch_shape, _instance=None) [source]

property mean

property mode

property support

property variance

Пуассон

class torch.distributions.poisson.Poisson(rate, validate_args=None) [source]

Bases: ExponentialFamily

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

Образцы — неотрицательные целые числа с функцией вероятности

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

Пример:

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

Parameters:

rate (Число, Тензор) – параметр скорости

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

expand(batch_shape, _instance=None) [source]

log_prob(value) [source]

property mean

property mode

sample(sample_shape=torch.Size([])) [source]

support = IntegerGreaterThan(lower_bound=0)

property variance

RelaxedBernoulli

class torch.distributions.relaxed_bernoulli.RelaxedBernoulli(temperature, probs=None, logits=None, validate_args=None) [source]

Bases: 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])

Parameters:

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

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

expand(batch_shape, _instance=None) [source]

has_rsample = True

property logits

property probs

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

property temperature

LogitRelaxedBernoulli

class torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli(temperature, probs=None, logits=None, validate_args=None) [source]

Bases: Distribution

Создаёт распределение LogitRelaxedBernoulli, параметризованное probs или logits (но не оба), что является логарифмом отношения шансов распределения RelaxedBernoulli.

Образцы — логарифмы отношений шансов значений в интервале (0, 1). Подробнее см. [1].

Parameters:

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

[1] The Concrete Distribution: A Continuous Relaxation of Discrete Random Variables (Maddison et al, 2017)

[2] Categorical Reparametrization with Gumbel-Softmax (Jang et al, 2017)

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

expand(batch_shape, _instance=None) [source]

log_prob(value) [source]

property logits

property param_shape

property probs

rsample(sample_shape=torch.Size([])) [source]

support = Real()

RelaxedOneHotCategorical

class torch.distributions.relaxed_categorical.RelaxedOneHotCategorical(temperature, probs=None, logits=None, validate_args=None) [source]

Bases: 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 (Тензор) – температура релаксации
• probs (Тензор) – вероятности событий
• logits (Тензор) – ненормализованный логарифм вероятности каждого события

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

expand(batch_shape, _instance=None) [source]

has_rsample = True

property logits

property probs

support = Simplex()

property temperature

StudentT

class torch.distributions.studentT.StudentT(df, loc=0.0, scale=1.0, validate_args=None) [source]

Bases: 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 или Тензор) – степень свободы
• loc (float или Тензор) – среднее значение распределения
• scale (float или Тензор) – масштаб распределения

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

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

log_prob(value) [source]

property mean

property mode

rsample(sample_shape=torch.Size([])) [source]

support = Real()

property variance

Преобразованное распределение

class torch.distributions.transformed_distribution.TransformedDistribution(base_distribution, transforms, validate_args=None) [source]

Основано на классе 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) [source]

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

expand(batch_shape, _instance=None) [source]

property has_rsample

icdf(value) [source]

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

log_prob(value) [source]

Вычисляет логарифм вероятности выборки, обращая преобразование(ия) и вычисляя значение с использованием значения базового распределения и логарифма абсолютного определителя якобиана.

rsample(sample_shape=torch.Size([])) [source]

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

sample(sample_shape=torch.Size([])) [source]

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

property support

Равномерное распределение

class torch.distributions.uniform.Uniform(low, high, validate_args=None) [source]

Основано на 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) — верхний предел (исключительно).

arg_constraints = {'high': Dependent(), 'low': Dependent()}

cdf(value) [source]

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

icdf(value) [source]

log_prob(value) [source]

property mean

property mode

rsample(sample_shape=torch.Size([])) [source]

property stddev

property support

property variance

VonMises

class torch.distributions.von_mises.VonMises(loc, concentration, validate_args=None) [source]

Bases: Distribution

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

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

Пример::

>>> 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) [source]

has_rsample = False

log_prob(value) [source]

property mean

Указанное среднее значение — круговое.

property mode

sample(sample_shape=torch.Size([])) [source]

Алгоритм генерации выборок для распределения фон Мизеса основан на следующей статье: Best, D. J., and Nicholas I. Fisher. “Efficient simulation of the von Mises distribution.” Applied Statistics (1979): 152-157.

support = Real()

property variance

Указанная дисперсия — круговая.

Weibull

class torch.distributions.weibull.Weibull(scale, concentration, validate_args=None) [source]

Bases: 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) – Параметр масштаба распределения (лямбда).
• concentration (float или Tensor) – Параметр концентрации распределения (k/форма).

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

entropy() [source]

expand(batch_shape, _instance=None) [source]

property mean

property mode

support = GreaterThan(lower_bound=0.0)

property variance

Wishart

class torch.distributions.wishart.Wishart(df, covariance_matrix=None, precision_matrix=None, scale_tril=None, validate_args=None) [source]

Bases: ExponentialFamily

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

Пример

>>> m = Wishart(torch.eye(2), torch.Tensor([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

Параметры:

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

Примечание

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

Ссылки

[1] On equivalence of the LKJ distribution and the restricted Wishart distribution, Zhenxun Wang, Yunan Wu, Haitao Chu.

arg_constraints = {'covariance_matrix': PositiveDefinite(), 'df': GreaterThan(lower_bound=0), 'precision_matrix': PositiveDefinite(), 'scale_tril': LowerCholesky()}

property covariance_matrix

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

log_prob(value) [source]

property mean

property mode

property precision_matrix

rsample(sample_shape=torch.Size([]), max_try_correction=None) [source]

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

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

property scale_tril

support = PositiveDefinite()

property variance

KL Divergence

torch.distributions.kl.kl_divergence(p, q) [source]

Вычислить дивергенцию Кульбака-Лейблера $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) [source]

Декоратор для регистрации функции попарного сравнения с 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) [source]

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

class torch.distributions.transforms.AffineTransform(loc, scale, event_dim=0, cache_size=0) [source]

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

Параметры:

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

class torch.distributions.transforms.CatTransform(tseq, dim=0, lengths=None, cache_size=0) [source]

Функтор преобразования, применяющий последовательность преобразований 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) [source]

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

Параметры:

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

class torch.distributions.transforms.CorrCholeskyTransform(cache_size=0) [source]

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

1. Сначала мы преобразуем x в нижнюю треугольную матрицу в порядке строк.
2. Для каждой строки $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) [source]

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

Параметры:

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) [source]

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

class torch.distributions.transforms.IndependentTransform(base_transform, reinterpreted_batch_ndims, cache_size=0) [source]

Обёртка вокруг другого преобразования для обработки 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) [source]

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

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

class torch.distributions.transforms.PowerTransform(exponent, cache_size=0) [source]

Преобразование с помощью отображения $y = x^{\text{exponent}}$.

class torch.distributions.transforms.ReshapeTransform(in_shape, out_shape, cache_size=0) [source]

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

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

Параметры:

• in_shape (torch.Size) – Форма входного события.
• out_shape (torch.Size) – Форма выходного события.

class torch.distributions.transforms.SigmoidTransform(cache_size=0) [source]

Преобразование с помощью отображения $y = \frac{1}{1 + \exp(-x)}$ и $x = \text{logit}(y)$.

class torch.distributions.transforms.SoftplusTransform(cache_size=0) [source]

Преобразование с помощью отображения $\text{Softplus}(x) = \log(1 + \exp(x))$. Реализация возвращается к линейной функции, когда $x > 20$.

class torch.distributions.transforms.TanhTransform(cache_size=0) [source]

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

Это эквивалентно ` ComposeTransform([AffineTransform(0., 2.), SigmoidTransform(), AffineTransform(-1., 2.)]) `. Однако это может быть нечисленно стабильно, поэтому рекомендуется использовать TanhTransform вместо этого.

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

class torch.distributions.transforms.SoftmaxTransform(cache_size=0) [source]

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

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

class torch.distributions.transforms.StackTransform(tseq, dim=0, cache_size=0) [source]

Функтор преобразования, который применяет последовательность преобразований 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) [source]

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

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

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

class torch.distributions.transforms.Transform(cache_size=0) [source]

Абстрактный класс для инвертируемых преобразований с вычислимыми логарифмами определителей якобианов. Они в основном используются в 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 данного преобразования. Это должно удовлетворять t.inv.inv is t.

property sign

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

log_abs_det_jacobian(x, y) [source]

Вычисляет логарифм определителя якобиана log |dy/dx| для заданных входных и выходных данных.

forward_shape(shape) [source]

Определяет форму вычисления вперёд, зная форму входных данных. По умолчанию сохраняет форму.

inverse_shape(shape) [source]

Определяет форму вычисления назад, зная форму выходных данных. По умолчанию сохраняет форму.

Constraints

Реализованы следующие ограничения:

• constraints.boolean
• constraints.cat
• constraints.corr_cholesky
• constraints.dependent
• constraints.greater_than(lower_bound)
• constraints.greater_than_eq(lower_bound)
• constraints.independent(constraint, reinterpreted_batch_ndims)
• constraints.integer_interval(lower_bound, upper_bound)
• constraints.interval(lower_bound, upper_bound)
• constraints.less_than(upper_bound)
• constraints.lower_cholesky
• constraints.lower_triangular
• constraints.multinomial
• constraints.nonnegative_integer
• constraints.one_hot
• constraints.positive_integer
• constraints.positive
• constraints.positive_semidefinite
• constraints.positive_definite
• constraints.real_vector
• constraints.real
• constraints.simplex
• constraints.symmetric
• constraints.stack
• constraints.square
• constraints.symmetric
• constraints.unit_interval

class torch.distributions.constraints.Constraint [source]

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

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

Переменные:

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

check(value) [source]

Возвращает байтовую тензорную sample_shape + batch_shape, указывающую, удовлетворяет ли каждое событие в значении данному ограничению.

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.less_than

псевдоним _LessThan

torch.distributions.constraints.multinomial

псевдоним _Multinomial

torch.distributions.constraints.stack

псевдоним _Stack

Constraint Registry

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

1. biject_to(constraint) ищет биективное Transform от constraints.real к заданному constraint. Возвращаемое преобразование гарантированно .bijective = True и должно реализовывать .log_abs_det_jacobian().
2. 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() полезен для алгоритма Hamiltonian Monte Carlo, где образцы из распределения вероятностей с ограниченными .support распространяются в неограниченном пространстве, а алгоритмы обычно инвариантны к вращению.:

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

Объекты 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 [source]

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

register(constraint, factory=None) [source]

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

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

Параметры:

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