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

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

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

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

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

\Delta\theta = \alpha r \frac{\partial\log p(a|\pi^\theta(s))}{\partial\theta}

где $\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: Size: Возвращает форму, по которой параметры сгруппированы.

cdf(value) [source]

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

Parameters: value (Тензор) –
Return type: Тензор

entropy() [source]

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

Returns: Тензор формы `batch_shape`.
Return type: Тензор

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()).

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

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

expand(batch_shape, _instance=None) [source]

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

Parameters

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

Returns

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

icdf(value) [source]

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

Parameters: value (Тензор) –
Return type: Тензор

log_prob(value) [source]

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

Parameters: value (Тензор) –
Return type: Тензор

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

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

perplexity() [source]

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

Returns: Тензор формы `batch_shape`.
Return type: Тензор

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

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

Return type: Тензор

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

Return type: Тензор

sample_n(n) [source]

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

Return type: Тензор

static set_default_validate_args(value) [source]

Устанавливает, включена или отключена проверка.

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

Parameters: value (bool) – Включить ли проверку.

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

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

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

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

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() и аналитического расчета расхождения Кульбака-Лейблера. Мы используем этот класс для вычисления энтропии и расхождения Кульбака-Лейблера с помощью метода автоматической дифференциации и брегмановских расхождений (благодаря: Франку Нильсену и Ричарду Ноку, Энтропии и кросс-энтропии экспоненциальных семейств).

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

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 или Тензор) – количество бинарных испытаний
probs (Тензор) – Вероятности событий
logits (Тензор) – Логарифмы вероятностей событий

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 (Тензор) – вероятности событий
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]

property support

property variance

Cauchy

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 или Тензор) – мода или медиана распределения.
scale (float или Тензор) – половина ширины на половине максимума.

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

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

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

property df

expand(batch_shape, _instance=None) [source]

НепрерывныйБернулли

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

Parameters

probs (Число, Tensor) – (0,1) значения параметров
logits (Число, 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) [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

Дирихле

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

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

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 / масштаб распределения

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

Создаёт распределение Гамма-типа, параметризованное через shape 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) – параметр формы распределения (часто обозначается как альфа)
rate (float или Tensor) – параметр скорости = 1 / масштаб распределения (часто обозначается как бета)

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

cdf(value) [source]

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

Геометрическое

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

Основы: 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

Гамбелл

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

Основы: 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 или Тензор) — масштаб полного распределения Каучи

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]

Основы: 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]

Основы: 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() [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

LKJCholesky

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

Основы: Distribution

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

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

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

Пример:

>>> 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 (2009), Daniel Lewandowski, Dorota Kurowicka, Harry Joe. Журнал многомерного анализа. 100. 10.1016/j.jmva.2009.04.008

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]

Создаёт распределение Лапласа, параметризованное 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

Смесь одинаковой семьи

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 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 – 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

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

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

Parameters

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

NegativeBinomial

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

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

Одномерно-горячее категорическое

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

Bases: Distribution

Создаёт распределение вероятностей с одним горячим кодированием, параметризованное значениями probs или logits.

Образцы — векторы с одним горячим кодированием размера 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

Парето

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

Параметры: 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])

Параметры

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

Параметры

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

Распределение Стьюдента

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

Расширение класса 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]: Генерирует образец размером sample_shape или пакет образцов размером sample_shape, если параметры распределения сгруппированы. Сначала генерируются образцы из базового распределения, а затем применяется transform() для каждого преобразования в списке.

sample(sample_shape=torch.Size([])) [source]: Генерирует образец размером sample_shape или пакет образцов размером sample_shape, если параметры распределения сгруппированы. Сначала генерируются образцы из базового распределения, а затем применяется 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

Функция распределения Вон Миса

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 or Tensor) – Параметр масштаба распределения (лямбда).
concentration (float or 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.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 SampleCovariance Matrix. JASA, 61(313):199-203. [5] Ku, Y.-C. & Bloomfield, P., 2010. Generating Random Wishart Matrices with Fractional Degrees of Freedom in OX.

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.

Возвращает

Массив расхождений Куллбека-Лайблера формы batch_shape.

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

Tensor

Возбуждает

NotImplementedError – Если типы распределений не зарегистрированы с помощью register_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|$ .

END_OF_DOCUMENT_MARKER

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. Данный фактор Холески представляет собой нижнюю треугольную матрицу с положительными диагональными элементами и единичной евклидовой нормой для каждой строки.

Преобразование выполняется следующим образом:

Сначала мы преобразуем 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) [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.PositiveDefiniteTransform(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: первый logit преобразуется с помощью сигмоиды в первую вероятность и вероятность всего остального, а затем процесс повторяется.

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

END_OF_DOCUMENT_MARKER

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
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. Оба объекта принимают на вход ограничения и возвращают преобразования, но у них разные гарантии биективности.

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

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