File size: 5,692 Bytes
b910c09 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | 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
|