▷Ejemplo de Pytorch torch.distributions ✔️ Foro Ayuda 【 2024 】

los distributions El paquete contiene distribuciones de probabilidad y funciones de muestreo parametrizables. Esto permite la construcción de gráficos de cálculo estocásticos y estimadores de gradientes estocásticos para su optimización. Este paquete generalmente sigue el diseño del Distribuciones de TensorFlow paquete.

No es posible retropropagar directamente a través de muestras aleatorias. Sin embargo, existen dos métodos principales para crear funciones sustitutas que se pueden propagar hacia atrás. Estos son el estimador de función de puntuación / estimador de razón de verosimilitud / REFORZAR y el estimador de derivada de ruta. REFORZAR se ve comúnmente como la base para los métodos de gradiente de políticas en el aprendizaje por refuerzo, y el estimador derivado de ruta se ve comúnmente en el truco de reparametrización en codificadores automáticos variacionales. Mientras que la función de puntuación solo requiere el valor de las muestras $f (x)$ , la derivada de trayectoria requiere la derivada $f ‘(x)$ . Las siguientes secciones discuten estos dos en un ejemplo de aprendizaje por refuerzo. Para obtener más detalles, consulte Estimación de gradientes mediante gráficos de cálculo estocástico .

Función de puntuación

Cuando la función de densidad de probabilidad es diferenciable con respecto a sus parámetros, solo necesitamos sample() y log_prob() para implementar REFORZAR:

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

dónde $theta$ son los parámetros, $alfa$ es la tasa de aprendizaje, $r$ es la recompensa y $p (a | pi ^ theta (s))$ es la probabilidad de actuar $a$ en estado $s$ política dada $pi ^ theta$ .

En la práctica, probaríamos una acción de la salida de una red, aplicaríamos esta acción en un entorno y luego usaríamos log_prob para construir una función de pérdida equivalente. Tenga en cuenta que usamos un valor negativo porque los optimizadores usan el descenso de gradiente, mientras que la regla anterior asume un ascenso de gradiente. Con una política categórica, el código para implementar REFORZAR sería el siguiente:

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

Derivada de trayectoria

La otra forma de implementar estos gradientes estocásticos / políticas sería utilizar el truco de reparametrización del rsample() método, donde la variable aleatoria parametrizada se puede construir a través de una función determinista parametrizada de una variable aleatoria libre de parámetros. Por tanto, la muestra reparametrizada se vuelve diferenciable. El código para implementar la derivada de ruta sería el siguiente:

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

Distribución

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

Bases: object

La distribución es la clase base abstracta para distribuciones de probabilidad.

property arg_constraints: Devuelve un diccionario de los nombres de los argumentos a Constraint objetos que deben ser satisfechos por cada argumento de esta distribución. Los argumentos que no son tensores no tienen por qué aparecer en este dictamen.

property batch_shape: Devuelve la forma sobre la que se agrupan los parámetros.

cdf(value) [source]

Devuelve la función de densidad / masa acumulada evaluada en value.

Parámetros: valor (Tensor) –

entropy() [source]

Devuelve la entropía de distribución, por lotes sobre batch_shape.

Devoluciones: Tensor de forma batch_shape.

enumerate_support(expand=True) [source]

Devuelve el tensor que contiene todos los valores admitidos por una distribución discreta. El resultado se enumerará sobre la dimensión 0, por lo que la forma del resultado será (cardinality,) + batch_shape + event_shape (dónde event_shape = () para distribuciones univariadas).

Tenga en cuenta que esto enumera todos los tensores en lote en el paso de bloqueo [[0, 0], [1, 1], …]. Con expand=False, la enumeración ocurre a lo largo de dim 0, pero con las dimensiones restantes del lote siendo dimensiones singleton, [[0], [1], ...

Para iterar sobre el uso completo del producto cartesiano itertools.product(m.enumerate_support()).

Parámetros: expandir (bool) – si expandir el soporte sobre la atenuación del lote para que coincida con la distribución batch_shape.
Devoluciones: Tensor en iteración sobre la dimensión 0.

property event_shape: Devuelve la forma de una sola muestra (sin lotes).

expand(batch_shape, _instance=None) [source]

Devuelve una nueva instancia de distribución (o rellena una instancia existente proporcionada por una clase derivada) con dimensiones de lote expandidas a batch_shape. Este método llama expand en los parámetros de la distribución. Como tal, esto no asigna nueva memoria para la instancia de distribución expandida. Además, esto no repite ninguna verificación de argumentos o transmisión de parámetros en __init__.py, cuando se crea una instancia por primera vez.

Parámetros

batch_shape (antorcha Tamaño) – el tamaño expandido deseado.
_ejemplo – nueva instancia proporcionada por subclases que deben anularse .expand.

Devoluciones

Nueva instancia de distribución con dimensiones de lote expandidas a batch_size.

icdf(value) [source]

Devuelve la función de masa / densidad acumulada inversa evaluada en value.

Parámetros: valor (Tensor) –

log_prob(value) [source]

Devuelve el logaritmo de la función de densidad / masa de probabilidad evaluada en value.

Parámetros: valor (Tensor) –

property mean: Devuelve la media de la distribución.

perplexity() [source]

Devuelve la perplejidad de la distribución, por lotes sobre batch_shape.

Devoluciones: Tensor de forma batch_shape.

rsample(sample_shape=torch.Size([])) [source]: Genera una muestra reparametrizada con forma de sample_shape o un lote de muestras reparametrizadas con forma de sample_shape si los parámetros de distribución son lotes.

sample(sample_shape=torch.Size([])) [source]: Genera una muestra con forma de sample_shape o un lote de muestras con forma de sample_shape si los parámetros de distribución son lotes.

sample_n(n) [source]: Genera n muestras o n lotes de muestras si los parámetros de distribución son lotes.

static set_default_validate_args(value) [source]

Establece si la validación está habilitada o deshabilitada.

El comportamiento predeterminado imita el de Python assert declaración: la validación está activada de forma predeterminada, pero está desactivada si Python se ejecuta en modo optimizado (a través de python -O). La validación puede ser costosa, por lo que es posible que desee deshabilitarla una vez que un modelo esté funcionando.

Parámetros: valor (bool): Si habilitar la validación.

property stddev: Devuelve la desviación estándar de la distribución.

property support: Devuelve un Constraint objeto que representa el soporte de esta distribución.

property variance: Devuelve la varianza de la distribución.

Familia exponencial

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

Bases: torch.distributions.distribution.Distribution

ExponentialFamily es la clase base abstracta para distribuciones de probabilidad que pertenecen a una familia exponencial, cuya función de masa / densidad de probabilidad tiene la forma que se define a continuación

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

dónde $theta$ denota los parámetros naturales, $t (x)$ denota la estadística suficiente, $F ( theta)$ es la función de normalizador de registros para una familia determinada y $k (x)$ es la medida portadora.

Nota

Esta clase es un intermediario entre los Distribution clase y distribuciones que pertenecen a una familia exponencial principalmente para comprobar la exactitud de la .entropy() y métodos analíticos de divergencia KL. Usamos esta clase para calcular la entropía y la divergencia KL usando el marco AD y las divergencias de Bregman (cortesía de: Frank Nielsen y Richard Nock, Entropies and Cross-entropies of Exponential Families).

entropy() [source]: Método para calcular la entropía utilizando la divergencia de Bregman del normalizador logarítmico.

Bernoulli

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

Bases: torch.distributions.exp_family.ExponentialFamily

Crea una distribución de Bernoulli parametrizada por probs o logits (pero no ambos).

Las muestras son binarias (0 o 1). Toman el valor 1 con probabilidad p y 0 con probabilidad 1 - p.

Ejemplo:

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

Parámetros

problemas (Número, Tensor) – la probabilidad de muestreo 1
logits (Número, Tensor): las probabilidades logarítmicas del muestreo 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]

logits [source]

property mean

property param_shape

probs [source]

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

support = Boolean()

property variance

Beta

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

Bases: torch.distributions.exp_family.ExponentialFamily

Distribución beta parametrizada por concentration1 y concentration0.

Ejemplo:

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

Parámetros

concentración1 (flotador o Tensor): primer parámetro de concentración de la distribución (a menudo denominado alfa)
concentración0 (flotador o Tensor): segundo parámetro de concentración de la distribución (a menudo denominado beta)

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

rsample(sample_shape=()) [source]

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

property variance

Binomio

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

Bases: torch.distributions.distribution.Distribution

Crea una distribución Binomial parametrizada por total_count y también probs o logits (pero no ambos). total_count debe ser retransmisible con probs/logits.

Ejemplo:

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

Parámetros

cuenta total (En t o Tensor) – número de ensayos de Bernoulli
problemas (Tensor) – Probabilidades de eventos
logits (Tensor) – Probabilidades de registro de eventos

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

enumerate_support(expand=True) [source]

expand(batch_shape, _instance=None) [source]

has_enumerate_support = True

log_prob(value) [source]

logits [source]

property mean

property param_shape

probs [source]

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

property support

property variance

Categórico

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

Bases: torch.distributions.distribution.Distribution

Crea una distribución categórica parametrizada por probs o logits (pero no ambos).

Nota

Es equivalente a la distribución que torch.multinomial() muestras de.

Las muestras son números enteros de ${0, ldots, K-1 }$ dónde K es probs.size(-1).

Si probs es unidimensional con longitudK, cada elemento es la probabilidad relativa de muestrear la clase en ese índice.

Si probs es N-dimensional, las primeras N-1 dimensiones se tratan como un lote de vectores de probabilidad relativa.

Nota

los probs El argumento debe ser no negativo, finito y tener una suma distinta de cero, y se normalizará para sumar 1 a lo largo de la última dimensión. attr:probs devolverá este valor normalizado. los logits El argumento se interpretará como probabilidades logarítmicas no normalizadas y, por lo tanto, puede ser cualquier número real. Asimismo, se normalizará de modo que las probabilidades resultantes sumen 1 a lo largo de la última dimensión. attr:logits devolverá este valor normalizado.

Ver también: torch.multinomial()

Ejemplo:

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

Parámetros

problemas (Tensor) – probabilidades de eventos
logits (Tensor) – probabilidades de registro de eventos (sin normalizar)

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]

logits [source]

property mean

property param_shape

probs [source]

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

property support

property variance

Cauchy

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

Bases: torch.distributions.distribution.Distribution

Muestras de una distribución de Cauchy (Lorentz). La distribución de la razón de variables aleatorias independientes distribuidas normalmente con medias 0 sigue una distribución de Cauchy.

Ejemplo:

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

Parámetros

loc (flotador o Tensor): modo o mediana de la distribución.
escala (flotador o Tensor) – mitad de ancho a mitad de máximo.

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

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

support = Real()

property variance

Chi2

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

Bases: torch.distributions.gamma.Gamma

Crea una distribución Chi2 parametrizada por parámetro de forma df. Esto es exactamente equivalente a Gamma(alpha=0.5*df, beta=0.5)

Ejemplo:

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

Parámetros: df (flotador o Tensor) – parámetro de forma de la distribución

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

property df

expand(batch_shape, _instance=None) [source]

ContinuoBernoulli

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

Bases: torch.distributions.exp_family.ExponentialFamily

Crea una distribución de Bernoulli continua parametrizada por probs o logits (pero no ambos).

La distribución se apoya en [0, 1] y parametrizado por ‘probs’ (en (0,1)) o ‘logits’ (valor real). Tenga en cuenta que, a diferencia de Bernoulli, ‘probs’ no corresponde a una probabilidad y ‘logits’ no corresponde a log-odds, pero se utilizan los mismos nombres debido a la similitud con Bernoulli. Ver [1] para más detalles.

Ejemplo:

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

Parámetros

problemas (Número, Tensor) – (0,1) parámetros valorados
logits (Número, Tensor): parámetros de valor real cuyo sigmoide coincide con ‘probs’

[1] El Bernoulli continuo: corrección de un error generalizado en codificadores automáticos variacionales, Loaiza-Ganem G y 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]

logits [source]

property mean

property param_shape

probs [source]

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: torch.distributions.exp_family.ExponentialFamily

Crea una distribución de Dirichlet parametrizada por concentración concentration.

Ejemplo:

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

Parámetros: concentración (Tensor): parámetro de concentración de la distribución (a menudo denominado alfa)

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

rsample(sample_shape=()) [source]

support = Simplex()

property variance

Exponencial

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

Bases: torch.distributions.exp_family.ExponentialFamily

Crea una distribución exponencial parametrizada por rate.

Ejemplo:

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

Parámetros: índice (flotador o Tensor) – tasa = 1 / escala de la distribución

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

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

property stddev

support = GreaterThan(lower_bound=0.0)

property variance

FisherSnedecor

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

Bases: torch.distributions.distribution.Distribution

Crea una distribución de Fisher-Snedecor parametrizada por df1 y df2.

Ejemplo:

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

Parámetros

df1 (flotador o Tensor) – grados de libertad parámetro 1
df2 (flotador o Tensor) – grados de libertad parámetro 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

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

support = GreaterThan(lower_bound=0.0)

property variance

Gama

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

Bases: torch.distributions.exp_family.ExponentialFamily

Crea una distribución Gamma parametrizada por forma concentration y rate.

Ejemplo:

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

Parámetros

concentración (flotador o Tensor): parámetro de forma de la distribución (a menudo denominado alfa)
índice (flotador o Tensor) – tasa = 1 / escala de la distribución (a menudo denominada 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

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

support = GreaterThan(lower_bound=0.0)

property variance

Geométrico

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

Bases: torch.distributions.distribution.Distribution

Crea una distribución geométrica parametrizada por probs, dónde probs es la probabilidad de éxito de los ensayos de Bernoulli. Representa la probabilidad de que en $k + 1$ Ensayos de Bernoulli, los primeros $k$ los ensayos fracasaron antes de ver un éxito.

Las muestras son números enteros no negativos[0[0 $inf$ ).

Ejemplo:

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

Parámetros

problemas (Número, Tensor) – la probabilidad de muestreo 1. Debe estar dentro del rango (0, 1]
logits (Número, Tensor): las probabilidades logarítmicas del muestreo 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]

logits [source]

property mean

probs [source]

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: torch.distributions.transformed_distribution.TransformedDistribution

Muestras de una distribución de Gumbel.

Ejemplos:

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

Parámetros

loc (flotador o Tensor): parámetro de ubicación de la distribución
escala (flotador o Tensor): parámetro de escala de la distribución

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

entropy() [source]

expand(batch_shape, _instance=None) [source]

log_prob(value) [source]

property mean

property stddev

support = Real()

property variance

HalfCauchy

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

Bases: torch.distributions.transformed_distribution.TransformedDistribution

Crea una distribución de media Cauchy parametrizada por scale dónde:

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

Ejemplo:

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

Parámetros: escala (flotador o Tensor) – escala de la distribución de Cauchy completa

arg_constraints: Dict[str, torch.distributions.constraints.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 scale

support = GreaterThan(lower_bound=0.0)

property variance

HalfNormal

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

Bases: torch.distributions.transformed_distribution.TransformedDistribution

Crea una distribución media normal parametrizada por scale dónde:

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

Ejemplo:

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

Parámetros: escala (flotador o Tensor): escala de la distribución normal completa

arg_constraints: Dict[str, torch.distributions.constraints.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 scale

support = GreaterThan(lower_bound=0.0)

property variance

Independiente

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

Bases: torch.distributions.distribution.Distribution

Reinterpreta algunas de las atenuaciones por lotes de una distribución a medida que se atenúan los eventos.

Esto es principalmente útil para cambiar la forma del resultado de log_prob(). Por ejemplo, para crear una distribución normal diagonal con la misma forma que una distribución normal multivariante (para que sean intercambiables), puede:

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

Parámetros

distribución_base (Torch.distributions.distribution.Distribution) – una distribución base
reinterpreted_batch_ndims (En t) – el número de atenuaciones de lote para reinterpretar como atenuaciones de eventos

arg_constraints: Dict[str, torch.distributions.constraints.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

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: torch.distributions.transformed_distribution.TransformedDistribution

Muestras de una distribución de Kumaraswamy.

Ejemplo:

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

Parámetros

concentración1 (flotador o Tensor): primer parámetro de concentración de la distribución (a menudo denominado alfa)
concentración0 (flotador o Tensor): segundo parámetro de concentración de la distribución (a menudo denominado beta)

arg_constraints: Dict[str, torch.distributions.constraints.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

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]

Bases: torch.distributions.distribution.Distribution

Distribución LKJ para el factor de Cholesky más bajo de matrices de correlación. La distribución está controlada por concentration parámetro $eta$ para hacer la probabilidad de la matriz de correlación $METRO$ generado a partir de un factor Cholesky propicio para $det (M) ^ { eta – 1}$ . Por eso, cuando concentration == 1, tenemos una distribución uniforme sobre los factores de Cholesky de matrices de correlación. Tenga en cuenta que esta distribución muestra el factor Cholesky de las matrices de correlación y no las matrices de correlación en sí mismas y, por lo tanto, difiere ligeramente de las derivaciones en [1] Para el LKJCorr distribución. Para el muestreo, se utiliza el método de cebolla de [1] Seccion 3.

L ~ LKJCholesky (tenue, concentración) X = L @ L ‘~ LKJCorr (tenue, concentración)

Ejemplo:

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

Parámetros

dimensión (oscuro) – dimensión de las matrices
concentración (flotador o Tensor): parámetro de concentración / forma de la distribución (a menudo denominado eta)

Referencias

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

Laplace

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

Bases: torch.distributions.distribution.Distribution

Crea una distribución de Laplace parametrizada por loc y scale.

Ejemplo:

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

Parámetros

loc (flotador o Tensor) – media de la distribución
escala (flotador o Tensor) – escala de la distribución

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

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

property stddev

support = Real()

property variance

LogNormal

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

Bases: torch.distributions.transformed_distribution.TransformedDistribution

Crea una distribución logarítmica normal parametrizada por loc y scale dónde:

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

Ejemplo:

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

Parámetros

loc (flotador o Tensor) – media del logaritmo de distribución
escala (flotador o Tensor) – desviación estándar del logaritmo de la distribución

arg_constraints: Dict[str, torch.distributions.constraints.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 scale

support = GreaterThan(lower_bound=0.0)

property variance

LowRankMultivariateNormal

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

Bases: torch.distributions.distribution.Distribution

Crea una distribución normal multivariante con una matriz de covarianza que tiene una forma de rango bajo parametrizada por cov_factor y cov_diag:

covariance_matrix = cov_factor @ cov_factor.T + cov_diag

Ejemplo

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

Parámetros

loc (Tensor) – media de la distribución con forma batch_shape + event_shape
factor_cov (Tensor) – factor parte de la forma de bajo rango de la matriz de covarianza con forma batch_shape + event_shape + (rank,)
cov_diag (Tensor): parte diagonal de la forma de bajo rango de la matriz de covarianza con forma batch_shape + event_shape

Nota

El cálculo de determinante e inverso de la matriz de covarianza se evita cuando cov_factor.shape[1] << cov_factor.shape[0] gracias a Identidad de la matriz de Woodbury y lema determinante de la matriz. Gracias a estas fórmulas, solo necesitamos calcular el determinante y el inverso de la matriz de “capacitancia” de pequeño tamaño:

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

covariance_matrix [source]

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

log_prob(value) [source]

property mean

precision_matrix [source]

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

scale_tril [source]

support = IndependentConstraint(Real(), 1)

variance [source]

Mezcla Misma Familia

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

Bases: torch.distributions.distribution.Distribution

los MixtureSameFamily La distribución implementa una distribución de mezcla (lote de) donde todos los componentes son de diferentes parametrizaciones del mismo tipo de distribución. Está parametrizado por un Categorical “Selección de distribución” (más k componente) y una distribución de componentes, es decir, un Distribution con una forma de lote más a la derecha (igual a [k]) que indexa cada (lote de) componente.

Ejemplos:

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

Parámetros

distribución_mezcla – torch.distributions.Categorical-como ejemplo. Gestiona la probabilidad de seleccionar un componente. El número de categorías debe coincidir con la dimensión de lote más a la derecha del component_distribution. Debe tener escalar batch_shape o batch_shape pareo component_distribution.batch_shape[:-1]
distribución_componente – torch.distributions.Distribution-como ejemplo. Componente de índices de dimensión de lote situado más a la derecha.

arg_constraints: Dict[str, torch.distributions.constraints.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: torch.distributions.distribution.Distribution

Crea una distribución multinomial parametrizada por total_count y también probs o logits (pero no ambos). La dimensión más interna de probs índices sobre categorías. Todas las demás dimensiones se indexan por lotes.

Tenga en cuenta que total_count no es necesario especificar si solo log_prob() se llama (ver ejemplo a continuación)

Nota

sample() requiere un solo compartido total_count para todos los parámetros y muestras.
log_prob() permite diferentes total_count para cada parámetro y muestra.

Ejemplo:

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

Parámetros

cuenta total (En t) – número de intentos
problemas (Tensor) – probabilidades de eventos
logits (Tensor) – probabilidades de registro de eventos (sin normalizar)

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

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 = None

property variance

Multivariante Normal

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

Bases: torch.distributions.distribution.Distribution

Crea una distribución normal multivariante (también denominada gaussiana) parametrizada por un vector medio y una matriz de covarianza.

La distribución normal multivariante se puede parametrizar en términos de una matriz de covarianza definida positiva $mathbf { Sigma}$ o una matriz de precisión definida positiva $mathbf { Sigma} ^ {- 1}$ o un matriz triangular inferior $mathbf {L}$ con entradas diagonales de valor positivo, de modo que $mathbf { Sigma} = mathbf {L} mathbf {L} ^ top$ . Esta matriz triangular se puede obtener mediante, por ejemplo, la descomposición de Cholesky de la covarianza.

Ejemplo

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

Parámetros

loc (Tensor) – media de la distribución
Matriz de covarianza (Tensor) – matriz de covarianza definida positiva
matriz_de_precisión (Tensor) – matriz de precisión definida positiva
scale_tril (Tensor) – factor de covarianza triangular inferior, con diagonal de valor positivo

Nota

Solo uno de covariance_matrix o precision_matrix o scale_tril se puede especificar.

Utilizando scale_tril será más eficiente: todos los cálculos internos se basan en scale_tril. Si covariance_matrix o precision_matrix se pasa en su lugar, solo se usa para calcular las matrices triangulares inferiores correspondientes usando una descomposición de Cholesky.

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

covariance_matrix [source]

entropy() [source]

expand(batch_shape, _instance=None) [source]

has_rsample = True

log_prob(value) [source]

property mean

precision_matrix [source]

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

scale_tril [source]

support = IndependentConstraint(Real(), 1)

property variance

NegativoBinomial

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

Bases: torch.distributions.distribution.Distribution

Crea una distribución binomial negativa, es decir, distribución del número de ensayos de Bernoulli independientes e idénticos exitosos antes total_count se logran los fracasos. La probabilidad de falla de cada ensayo de Bernoulli es probs.

Parámetros

cuenta total (flotador o Tensor): número no negativo de ensayos de Bernoulli negativos para detener, aunque la distribución sigue siendo válida para el recuento de valor real
problemas (Tensor) – Probabilidades de falla del evento en el intervalo semiabierto [0, 1)
logits (Tensor) – Event log-odds for probabilities of failure

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]

logits [source]

property mean

property param_shape

probs [source]

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

support = IntegerGreaterThan(lower_bound=0)

property variance

Normal

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

Bases: torch.distributions.exp_family.ExponentialFamily

Crea una distribución normal (también llamada gaussiana) parametrizada por loc y scale.

Ejemplo:

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

Parámetros

loc (flotador o Tensor): media de la distribución (a menudo denominada mu)
escala (flotador o Tensor): desviación estándar de la distribución (a menudo denominada 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

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: torch.distributions.distribution.Distribution

Crea una distribución categórica one-hot parametrizada por probs o logits.

Las muestras son vectores de tamaño codificados en caliente probs.size(-1).

Nota

Ver también: torch.distributions.Categorical() para especificaciones de probs y logits.

Ejemplo:

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

Parámetros

problemas (Tensor) – probabilidades de eventos
logits (Tensor) – probabilidades de registro de eventos (sin normalizar)

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 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: torch.distributions.transformed_distribution.TransformedDistribution

Muestras de una distribución de Pareto Tipo 1.

Ejemplo:

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

Parámetros

escala (flotador o Tensor): parámetro de escala de la distribución
alfa (flotador o Tensor): parámetro de forma de la distribución

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

entropy() [source]

expand(batch_shape, _instance=None) [source]

property mean

property support

property variance

Poisson

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

Bases: torch.distributions.exp_family.ExponentialFamily

Crea una distribución de Poisson parametrizada por rate, el parámetro de tasa.

Las muestras son números enteros no negativos, con un pmf dado por

$mathrm {tasa} ^ k frac {e ^ {- mathrm {tasa}}} {k!}$

Ejemplo:

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

Parámetros: índice (Número, Tensor) – el parámetro de tasa

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

expand(batch_shape, _instance=None) [source]

log_prob(value) [source]

property mean

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

support = IntegerGreaterThan(lower_bound=0)

property variance

RelajadoBernoulli

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

Bases: torch.distributions.transformed_distribution.TransformedDistribution

Crea una distribución RelaxedBernoulli, parametrizada por temperature, y también probs o logits (pero no ambos). Esta es una versión relajada del Bernoulli distribución, por lo que los valores están en (0, 1) y tiene muestras reparametrizables.

Ejemplo:

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

Parámetros

temperatura (Tensor) – temperatura de relajación
problemas (Número, Tensor) – la probabilidad de muestreo 1
logits (Número, Tensor): las probabilidades logarítmicas del muestreo 1

arg_constraints: Dict[str, torch.distributions.constraints.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

LogitRelajadoBernoulli

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

Bases: torch.distributions.distribution.Distribution

Crea una distribución LogitRelaxedBernoulli parametrizada por probs o logits (pero no ambos), que es el logit de una distribución RelaxedBernoulli.

Las muestras son logitos de valores en (0, 1). Ver [1] para más detalles.

Parámetros

temperatura (Tensor) – temperatura de relajación
problemas (Número, Tensor) – la probabilidad de muestreo 1
logits (Número, Tensor): las probabilidades logarítmicas del muestreo 1

[1] La distribución concreta: una relajación continua de variables aleatorias discretas (Maddison et al, 2017)

[2] Reparametrización categórica con 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]

logits [source]

property param_shape

probs [source]

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

support = Real()

RelajadoOneHotCategorical

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

Bases: torch.distributions.transformed_distribution.TransformedDistribution

Crea una distribución RelaxedOneHotCategorical parametrizada por temperature, y también probs o logits. Esta es una versión relajada del OneHotCategorical distribución, por lo que sus muestras están en símplex y son reparametrizables.

Ejemplo:

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

Parámetros

temperatura (Tensor) – temperatura de relajación
problemas (Tensor) – probabilidades de eventos
logits (Tensor): probabilidad de registro no normalizada para cada evento

arg_constraints: Dict[str, torch.distributions.constraints.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: torch.distributions.distribution.Distribution

Crea una distribución t de Student parametrizada por grado de libertad df, significar loc y escala scale.

Ejemplo:

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

Parámetros

df (flotador o Tensor) – grados de libertad
loc (flotador o Tensor) – media de la distribución
escala (flotador o Tensor) – escala de la distribución

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

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

support = Real()

property variance

Distribución transformada

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

Bases: torch.distributions.distribution.Distribution

Extensión de la clase Distribución, que aplica una secuencia de Transformaciones a una distribución base. Sea f la composición de las transformadas aplicadas:

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

Tenga en cuenta que el .event_shape de un TransformedDistribution es la forma máxima de su distribución base y sus transformadas, ya que las transformadas pueden introducir correlaciones entre eventos.

Un ejemplo del uso de TransformedDistribution sería:

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

Para obtener más ejemplos, consulte las implementaciones de Gumbel, HalfCauchy, HalfNormal, LogNormal, Pareto, Weibull, RelaxedBernoulli y RelaxedOneHotCategorical

arg_constraints: Dict[str, torch.distributions.constraints.Constraint] = {}

cdf(value) [source]: Calcula la función de distribución acumulativa invirtiendo las transformadas y calculando la puntuación de la distribución base.

expand(batch_shape, _instance=None) [source]

property has_rsample

icdf(value) [source]: Calcula la función de distribución acumulativa inversa utilizando transformadas y calculando la puntuación de la distribución base.

log_prob(value) [source]: Puntúa la muestra invirtiendo la (s) transformada (s) y calculando la puntuación usando la puntuación de la distribución base y el log abs det jacobian.

rsample(sample_shape=torch.Size([])) [source]: Genera una muestra reparametrizada con forma de sample_shape o un lote de muestras reparametrizadas con forma de sample_shape si los parámetros de distribución son lotes. Muestra primero de la distribución base y se aplica transform() para cada transformación de la lista.

sample(sample_shape=torch.Size([])) [source]: Genera una muestra con forma de sample_shape o un lote de muestras con forma de sample_shape si los parámetros de distribución son lotes. Muestra primero de la distribución base y se aplica transform() para cada transformación de la lista.

property support

Uniforme

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

Bases: torch.distributions.distribution.Distribution

Genera muestras aleatorias distribuidas uniformemente a partir del intervalo semiabierto [low, high).

Ejemplo:

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

Parámetros

bajo (flotador o Tensor) – rango inferior (incluido).
elevado (flotador o Tensor) – rango superior (exclusivo).

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

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: torch.distributions.distribution.Distribution

Una distribución circular de von Mises.

Esta implementación utiliza coordenadas polares. los loc y value Los argumentos pueden ser cualquier número real (para facilitar la optimización sin restricciones), pero se interpretan como ángulos módulo 2 pi.

Ejemplo::

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

Parámetros

loc (antorcha Tensor) – un ángulo en radianes.
concentración (antorcha.Tensor) – parámetro de concentración

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

expand(batch_shape) [source]

has_rsample = False

log_prob(value) [source]

property mean: La media proporcionada es la circular.

sample(sample_shape=torch.Size([])) [source]: El algoritmo de muestreo para la distribución de von Mises se basa en el siguiente artículo: Best, DJ y Nicholas I. Fisher. “Simulación eficiente de la distribución de von Mises”. Estadísticas aplicadas (1979): 152-157.

support = Real()

variance [source]: La variación proporcionada es la circular.

Weibull

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

Bases: torch.distributions.transformed_distribution.TransformedDistribution

Muestras de una distribución de Weibull de dos parámetros.

Ejemplo

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

Parámetros

escala (flotador o Tensor): parámetro de distribución de escala (lambda).
concentración (flotador o Tensor) – Parámetro de concentración de distribución (k / forma).

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

entropy() [source]

expand(batch_shape, _instance=None) [source]

property mean

support = GreaterThan(lower_bound=0.0)

property variance

`KL Divergence`

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

Calcular la divergencia de Kullback-Leibler $KL (p | q)$ entre dos distribuciones.

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

Parámetros

pag (Distribución) – A Distribution objeto.
q (Distribución) – A Distribution objeto.

Devoluciones

Un lote de divergencias de forma de KL batch_shape.

Tipo de retorno

Tensor

Eleva

NotImplementedError – Si los tipos de distribución no se han registrado a través de register_kl().

torch.distributions.kl.register_kl(type_p, type_q) [source]

Decorador para registrar una función por pares con kl_divergence(). Uso:

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

La búsqueda devuelve la coincidencia más específica (tipo, tipo) ordenada por subclase. Si la coincidencia es ambigua, un RuntimeWarning es elevado. Por ejemplo, para resolver la situación ambigua:

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

debe registrar una tercera implementación más específica, por ejemplo:

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

Parámetros

type_p (escribe) – Una subclase de Distribution.
type_q (escribe) – Una subclase de Distribution.

`Transforms`

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

Clase abstracta para transformaciones invertables con log det jacobians computable. Se utilizan principalmente en torch.distributions.TransformedDistribution.

El almacenamiento en caché es útil para transformaciones cuyas inversas son caras o numéricamente inestables. Tenga en cuenta que se debe tener cuidado con los valores memorizados, ya que el gráfico de autogrado puede invertirse. Por ejemplo, mientras que lo siguiente funciona con o sin almacenamiento en caché:

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

Sin embargo, lo siguiente generará un error al almacenar en caché debido a la inversión de dependencia:

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

Las clases derivadas deben implementar una o ambas _call() o _inverse(). Clases derivadas que establecen bijective=True también debería implementar log_abs_det_jacobian().

Parámetros

tamaño del caché (En t) – Tamaño de la caché. Si es cero, no se realiza el almacenamiento en caché. Si uno, se almacena en caché el último valor único. Solo se admiten 0 y 1.

Variables

~ Transform.domain (Constraint) – La restricción que representa entradas válidas para esta transformación.
~ Transform.codomain (Constraint) – La restricción que representa salidas válidas para esta transformada que son entradas para la transformada inversa.
~ Transform.bijective (bool) – Si esta transformación es biyectiva. Una transformación t es biyectivo iff t.inv(t(x)) == x y t(t.inv(y)) == y para cada x en el dominio y y en el codominio. Las transformaciones que no son biyectivas deberían al menos mantener las propiedades pseudoinversas más débiles t(t.inv(t(x)) == t(x) y t.inv(t(t.inv(y))) == t.inv(y).
~ Transform.sign (En t o Tensor): para transformaciones univariadas biyectivas, esto debería ser +1 o -1 dependiendo de si la transformación es monótona creciente o decreciente.

property inv: Devuelve la inversa Transform de esta transformación. Esto debería satisfacer t.inv.inv is t.

property sign: Devuelve el signo del determinante del jacobiano, si corresponde. En general, esto solo tiene sentido para las transformaciones biyectivas.

log_abs_det_jacobian(x, y) [source]: Calcula el log det jacobian log |dy/dx| entrada y salida dadas.

forward_shape(shape) [source]: Infiere la forma del cálculo directo, dada la forma de entrada. Predeterminado para preservar la forma.

inverse_shape(shape) [source]: Infiere las formas del cálculo inverso, dada la forma de salida. Predeterminado para preservar la forma.

class torch.distributions.transforms.ComposeTransform(parts, cache_size=0) [source]

Compone múltiples transformaciones en una cadena. Las transformaciones que se componen son responsables del almacenamiento en caché.

Parámetros

partes (lista de Transform) – Una lista de transformaciones para componer.
tamaño del caché (En t) – Tamaño de la caché. Si es cero, no se realiza el almacenamiento en caché. Si hay uno, se almacena en caché el último valor único. Solo se admiten 0 y 1.

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

Envuelva alrededor de otra transformación para tratar reinterpreted_batch_ndims-Muchos extras de la mayoría de las dimensiones correctas como dependientes. Esto no tiene ningún efecto en las transformaciones hacia adelante o hacia atrás, pero suma reinterpreted_batch_ndims-muchas de las dimensiones más a la derecha en log_abs_det_jacobian().

Parámetros

transformación_base (Transform) – Una transformación base.
reinterpreted_batch_ndims (En t): El número de dimensiones extra a la derecha para tratar como dependientes.

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

Unidad de transformación jacobiana para remodelar la parte más a la derecha de un tensor.

Tenga en cuenta que in_shape y out_shape debe tener el mismo número de elementos, al igual que para torch.Tensor.reshape().

Parámetros

en forma (antorcha Tamaño): La forma del evento de entrada.
out_shape (antorcha Tamaño): La forma del evento de salida.

class torch.distributions.transforms.ExpTransform(cache_size=0) [source]: Transformar a través del mapeo $y = exp (x)$ .

class torch.distributions.transforms.PowerTransform(exponent, cache_size=0) [source]: Transformar a través del mapeo $y = x ^ { text {exponente}}$ .

class torch.distributions.transforms.SigmoidTransform(cache_size=0) [source]: Transformar a través del mapeo $y = frac {1} {1 + exp (-x)}$ y $x = text {logit} (y)$ .

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

Transformar a través del mapeo $y = tanh (x)$ .

Es equivalente a ` ComposeTransform([AffineTransform(0., 2.), SigmoidTransform(), AffineTransform(-1., 2.)]) ` Sin embargo, esto podría no ser numéricamente estable, por lo que se recomienda utilizar TanhTransform en lugar de.

Tenga en cuenta que uno debe usar cache_size=1 cuando se trata de NaN/Inf valores.

class torch.distributions.transforms.AbsTransform(cache_size=0) [source]: Transformar a través del mapeo $y = | x |$ .

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

Transformar a través del mapeo afín puntual $y = text {loc} + text {scale} times x$ .

Parámetros

loc (Tensor o flotador) – Parámetro de ubicación.
escala (Tensor o flotador) – Parámetro de escala.
event_dim (En t) – Tamaño opcional de event_shape. Debe ser cero para variables aleatorias univariadas, 1 para distribuciones sobre vectores, 2 para distribuciones sobre matrices, etc.

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

Transforma un vector real sin contracciones $X$ con longitud $D * (D-1) / 2$ en el factor de Cholesky de una matriz de correlación de dimensión D. Este factor de Cholesky es una matriz triangular inferior con diagonales positivas y norma euclidiana unitaria para cada fila. La transformación se procesa de la siguiente manera:

Primero convertimos x en una matriz triangular inferior en orden de filas.
Por cada fila $X_i$ de la parte triangular inferior, aplicamos un firmado versión de clase StickBreakingTransform para transformar $X_i$ en un vector de longitud euclidiana unitaria mediante los siguientes pasos: – Escalas en el intervalo $(-1, 1)$ dominio: $r_i = tanh (X_i)$ . – Se transforma en un dominio sin firmar: $z_i = r_i ^ 2$ . – se aplica $s_i = StickBreakingTransform (z_i)$ . – Se vuelve a transformar en dominio firmado: $y_i = signo (r_i) * sqrt {s_i}$ .

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

Transfórmese del espacio sin restricciones al simplex a través de $y = exp (x)$ luego normalizando.

Esto no es biyectivo y no se puede utilizar para HMC. Sin embargo, esto actúa principalmente por coordenadas (excepto por la normalización final) y, por lo tanto, es apropiado para algoritmos de optimización por coordenadas.

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

Transfórmese del espacio sin restricciones al simplex de una dimensión adicional a través de un proceso de ruptura de palos.

Esta transformada surge como una transformada sigmoidea iterada en una construcción de la Dirichlet distribución: el primer logit se transforma vía sigmoidea a la primera probabilidad y la probabilidad de todo lo demás, y luego el proceso se repite.

Esto es biyectivo y apropiado para su uso en HMC; sin embargo, mezcla las coordenadas y es menos apropiado para la optimización.

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

Transforme de matrices no restringidas a matrices triangulares inferiores con entradas diagonales no negativas.

Esto es útil para parametrizar matrices definidas positivas en términos de su factorización Cholesky.

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

Funtor de transformación que aplica una secuencia de transformaciones tseq componente a cada submatriz en dim de una manera compatible con torch.stack().

Ejemplo::: x = antorcha.apila ([torch.range(1, 10), torch.range(1, 10)], dim = 1) t = StackTransform ([ExpTransform(), identity_transform], dim = 1) y = t (x)

`Constraints`

Se implementan las siguientes restricciones:

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_definite
constraints.positive_integer
constraints.positive
constraints.real_vector
constraints.real
constraints.simplex
constraints.stack
constraints.unit_interval

class torch.distributions.constraints.Constraint [source]

Clase base abstracta para restricciones.

Un objeto de restricción representa una región en la que una variable es válida, por ejemplo, dentro de la cual se puede optimizar una variable.

Variables

~ Constraint.is_discrete (bool) – Si el espacio restringido es discreto. El valor predeterminado es Falso.
~ Constraint.event_dim (En t): Número de dimensiones más a la derecha que juntas definen un evento. los check() El método eliminará todas estas dimensiones al calcular la validez.

check(value) [source]: Devuelve un tensor de bytes de sample_shape + batch_shape indicando si cada evento en valor satisface esta restricción.

torch.distributions.constraints.dependent_property: alias de torch.distributions.constraints._DependentProperty

torch.distributions.constraints.independent: alias de torch.distributions.constraints._IndependentConstraint

torch.distributions.constraints.integer_interval: alias de torch.distributions.constraints._IntegerInterval

torch.distributions.constraints.greater_than: alias de torch.distributions.constraints._GreaterThan

torch.distributions.constraints.greater_than_eq: alias de torch.distributions.constraints._GreaterThanEq

torch.distributions.constraints.less_than: alias de torch.distributions.constraints._LessThan

torch.distributions.constraints.multinomial: alias de torch.distributions.constraints._Multinomial

torch.distributions.constraints.interval: alias de torch.distributions.constraints._Interval

torch.distributions.constraints.half_open_interval: alias de torch.distributions.constraints._HalfOpenInterval

torch.distributions.constraints.cat: alias de torch.distributions.constraints._Cat

torch.distributions.constraints.stack: alias de torch.distributions.constraints._Stack

`Constraint Registry`

PyTorch proporciona dos ConstraintRegistry objetos que enlazan Constraint objetos a Transform objetos. Estos objetos son tanto restricciones de entrada como transformaciones de retorno, pero tienen diferentes garantías de bijetividad.

biject_to(constraint) busca un biyectivo Transform de constraints.real a lo dado constraint. Se garantiza que la transformación devuelta tiene .bijective = True y debería implementar .log_abs_det_jacobian().
transform_to(constraint) busca un no necesariamente biyectivo Transform de constraints.real a lo dado constraint. No se garantiza que la transformación devuelta se implemente .log_abs_det_jacobian().

los transform_to() El registro es útil para realizar una optimización sin restricciones en los parámetros restringidos de las distribuciones de probabilidad, que están indicados por los valores de cada distribución. .arg_constraints dic. Estas transformadas a menudo sobreparametrizan un espacio para evitar la rotación; por lo tanto, son más adecuados para algoritmos de optimización de coordenadas como 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()

los biject_to() El registro es útil para Hamiltonian Monte Carlo, donde las muestras de una distribución de probabilidad con restricciones .support se propagan en un espacio no restringido, y los algoritmos suelen ser invariantes en rotación:

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

Nota

Un ejemplo donde transform_to y biject_to diferir es constraints.simplex: transform_to(constraints.simplex) devuelve un SoftmaxTransform que simplemente exponencializa y normaliza sus entradas; esta es una operación barata y en su mayoría por coordenadas apropiada para algoritmos como SVI. A diferencia de, biject_to(constraints.simplex) devuelve un StickBreakingTransform que biyecta su entrada a un espacio unidimensional menos; esta es una transformación numéricamente estable más cara, pero es necesaria para algoritmos como HMC.

los biject_to y transform_to Los objetos pueden extenderse mediante restricciones definidas por el usuario y transformaciones utilizando su .register() método ya sea como una función en restricciones de singleton:

transform_to.register(my_constraint, my_transform)

o como decorador de restricciones parametrizadas:

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

Puede crear su propio registro creando un nuevo ConstraintRegistry objeto.

class torch.distributions.constraint_registry.ConstraintRegistry [source]

Registro para vincular restricciones a transformaciones.

register(constraint, factory=None) [source]

Registra un Constraint subclase en este registro. Uso:

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

Parámetros

restricción (subclase de Constraint) – Una subclase de Constraint, o un objeto singleton de la clase deseada.
fábrica (invocable): Un invocable que ingresa un objeto de restricción y devuelve un Transform objeto.

¡Haz clic para puntuar esta entrada!

(Votos: 0 Promedio: 0)

Tags : Pytorch torch.distributions /

Función de puntuación

Derivada de trayectoria

Distribución

Familia exponencial

Bernoulli

Beta

Binomio

Categórico

Cauchy

Chi2

ContinuoBernoulli

Dirichlet

Exponencial

FisherSnedecor

Gama

Geométrico

Gumbel

HalfCauchy

HalfNormal

Independiente

Kumaraswamy

LKJCholesky

Laplace

LogNormal

LowRankMultivariateNormal

Ejemplo

Mezcla Misma Familia

Multinomial

Multivariante Normal

Ejemplo

NegativoBinomial

Normal

OneHotCategorical

Pareto

Poisson

RelajadoBernoulli

LogitRelajadoBernoulli

RelajadoOneHotCategorical

StudentT

Distribución transformada

Uniforme

VonMises

Weibull

Ejemplo

KL Divergence

Transforms

Constraints

Constraint Registry

Utiliza Nuestro Buscador

Preguntas Relacionadas:

`KL Divergence`

`Transforms`

`Constraints`

`Constraint Registry`