| import torch |
| from torch import Tensor |
| from jaxtyping import Float |
| from typing import Optional |
| from math import exp, log, pi |
|
|
|
|
| class DiagonalGaussian: |
| std_inverval: tuple[float, float] |
| var_interval: tuple[float, float] |
| logvar_interval: tuple[float, float] |
| mean: Float[Tensor, "*batch"] |
| _logvar: Float[Tensor, "*#batch"] | None = None |
| _std: Float[Tensor, "*#batch"] | None = None |
| _var: Float[Tensor, "*#batch"] | None = None |
|
|
| def __init__( |
| self, |
| mean: Float[Tensor, "*batch"], |
| std: Float[Tensor, "*#batch"] | None = None, |
| var: Float[Tensor, "*#batch"] | None = None, |
| logvar: Float[Tensor, "*#batch"] | None = None, |
| logvar_interval: tuple[float, float] = (-30.0, 20.0), |
| ): |
| assert sum(map(lambda x: int(x is not None), (std, var, logvar))) <= 1 |
| self.std_inverval = tuple(exp(0.5 * i) for i in logvar_interval) |
| self.var_interval = tuple(exp(i) for i in logvar_interval) |
| self.logvar_interval = logvar_interval |
| self.mean = mean |
| if std is not None: |
| self.std = std |
| if var is not None: |
| self.var = var |
| if logvar is not None: |
| self.logvar = logvar |
|
|
| @property |
| def std(self) -> Float[Tensor, "*batch"]: |
| if self._std is None: |
| if self._var is not None: |
| self._std = torch.sqrt(self._var) |
| elif self._logvar is not None: |
| self._std = torch.exp(0.5 * self._logvar) |
| else: |
| return torch.zeros((1,), device=self.device, dtype=self.dtype).expand_as(self.mean) |
| return self._std |
|
|
| @std.setter |
| def std(self, val: Float[Tensor, "*batch"] | None) -> None: |
| self._std = val if val is None else torch.clamp(val, *self.std_inverval) |
| self._var = self._logvar = None |
|
|
| @property |
| def var(self) -> Float[Tensor, "*batch"]: |
| if self._var is None: |
| if self._std is not None: |
| self._var = self._std**2 |
| elif self._logvar is not None: |
| self._var = torch.exp(self._logvar) |
| else: |
| return torch.zeros((1,), device=self.device, dtype=self.dtype).expand_as(self.mean) |
| return self._var |
|
|
| @var.setter |
| def var(self, val: Float[Tensor, "*batch"]) -> None: |
| self._var = val if val is None else torch.clamp(val, *self.var_interval) |
| self._std = self._logvar = None |
|
|
| @property |
| def logvar(self) -> Float[Tensor, "*batch"]: |
| if self._logvar is None: |
| if self._var is not None: |
| self._logvar = torch.log(self._var) |
| elif self._std is not None: |
| self._logvar = 2 * torch.log(self._std) |
| else: |
| raise RuntimeError("Tried accessing logvar of Gaussian with zero variance") |
| return self._logvar |
|
|
| @logvar.setter |
| def logvar(self, val: Float[Tensor, "*batch"]) -> None: |
| self._logvar = val if val is None else torch.clamp(val, *self.logvar_interval) |
| self._std = self._var = None |
|
|
| @property |
| def device(self) -> torch.device: |
| return self.mean.device |
|
|
| @property |
| def dtype(self) -> torch.dtype: |
| return self.mean.dtype |
|
|
| def mean_detach_(self) -> None: |
| self.mean = self.mean.detach() |
|
|
| def std_detach_(self) -> None: |
| if self._std is not None: |
| self._std = self._std.detach() |
| if self._var is not None: |
| self._var = self._var.detach() |
| if self._logvar is not None: |
| self._logvar = self._logvar.detach() |
|
|
| def sample(self, eps: Float[Tensor, "*#batch"] | None = None) -> Float[Tensor, "*batch"]: |
| if eps is None: |
| eps = torch.randn_like(self.mean) |
| return self.mean + self.std * eps |
|
|
| def mode(self) -> Float[Tensor, "*batch"]: |
| return self.mean |
|
|
| def kl(self, other: Optional["DiagonalGaussian"] = None) -> Float[Tensor, "*batch"]: |
| if other is None: |
| return 0.5 * (self.mean**2 + self.var - self.logvar - 1.0) |
| logvar_delta = self.logvar - other.logvar |
| return 0.5 * ((self.mean - other.mean) ** 2 / other.var + torch.exp(logvar_delta) - logvar_delta - 1.0) |
|
|
| def nll(self, sample: Tensor) -> Tensor: |
| return 0.5 * (log(2.0 * pi) + self.logvar + (sample - self.mean) ** 2 / self.var) |
|
|
| @staticmethod |
| def approx_standard_normal_cdf(x): |
| """ |
| A fast approximation of the cumulative distribution function of the standard normal. |
| """ |
| return 0.5 * (1.0 + torch.tanh((2.0 / torch.pi) ** 0.5 * (x + 0.044715 * torch.pow(x, 3)))) |
|
|
| def discretized_log_likelihood( |
| self, |
| sample: Float[Tensor, "*batch"], |
| ) -> Float[Tensor, "*batch"]: |
| """ |
| Compute the log-likelihood of a Gaussian distribution discretizing to a given image. |
| It is assumed that this was uint8 values, rescaled to the range [-1, 1]. |
| Returns a tensor like mean of log probabilities (in nats). |
| """ |
| centered_x = sample - self.mean |
| plus_in = (centered_x + 1.0 / 255.0) / self.std |
| cdf_plus = self.approx_standard_normal_cdf(plus_in) |
| min_in = (centered_x - 1.0 / 255.0) / self.std |
| cdf_min = self.approx_standard_normal_cdf(min_in) |
| log_cdf_plus = torch.log(cdf_plus.clamp(min=1e-12)) |
| log_one_minus_cdf_min = torch.log((1.0 - cdf_min).clamp(min=1e-12)) |
| cdf_delta = cdf_plus - cdf_min |
| log_probs = torch.where( |
| sample < -0.999, |
| log_cdf_plus, |
| torch.where(sample > 0.999, log_one_minus_cdf_min, torch.log(cdf_delta.clamp(min=1e-12))), |
| ) |
| return log_probs |
|
|
