diff --git a/s4/__init__.py b/s4/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/s4/cauchy.py b/s4/cauchy.py new file mode 100644 index 0000000..044a1a9 --- /dev/null +++ b/s4/cauchy.py @@ -0,0 +1,120 @@ +import torch +from cauchy_mult import ( + cauchy_mult_bwd, + cauchy_mult_fwd, + cauchy_mult_sym_bwd, + cauchy_mult_sym_fwd, +) +from einops import rearrange + + +def cauchy_mult_torch( + v: torch.Tensor, z: torch.Tensor, w: torch.Tensor, symmetric=True +) -> torch.Tensor: + """ + v: (B, N) + z: (L) + w: (B, N) + symmetric: whether to assume that v and w contain complex conjugate pairs, of the form + [v_half, v_half.conj()] and [w_half, w_half.conj()] + """ + if not symmetric: + return ( + rearrange(v, "b n -> b 1 n") + / (rearrange(z, "l -> l 1") - rearrange(w, "b n -> b 1 n")) + ).sum(dim=-1) + else: + N = v.shape[-1] + assert N % 2 == 0 + vv = rearrange(v[:, : N // 2], "b n -> b 1 n") + zz = rearrange(z, "l -> l 1") + ww = rearrange(w[:, : N // 2], "b n -> b 1 n") + return 2 * ( + (zz * vv.real - vv.real * ww.real - vv.imag * ww.imag) + / (zz * zz - 2 * zz * ww.real + ww.abs().square()) + ).sum(dim=-1) + + +def cauchy_mult_keops(v, z, w): + from pykeops.torch import LazyTensor + + v_l = LazyTensor(rearrange(v, "b N -> b 1 N 1")) + z_l = LazyTensor(rearrange(z, "L -> 1 L 1 1")) + w_l = LazyTensor(rearrange(w, "b N -> b 1 N 1")) + sub = z_l - w_l # (b N L 1), for some reason it doesn't display the last dimension + div = v_l / sub + s = div.sum(dim=2, backend="GPU") + return s.squeeze(-1) + + +def _cauchy_mult(v, z, w, symmetric=True): + if not symmetric: + return CauchyMultiply.apply(v, z, w) + else: + return CauchyMultiplySymmetric.apply(v, z, w) + + +def cauchy_mult(v, z, w, symmetric=True): + """Wrap the cuda method to deal with shapes""" + v, w = torch.broadcast_tensors(v, w) + shape = v.shape + # z_shape = z.shape + z = z.squeeze() + assert len(z.shape) == 1 + + v = v.contiguous() + w = w.contiguous() + z = z.contiguous() + + N = v.size(-1) + assert w.size(-1) == N + y = _cauchy_mult(v.view(-1, N), z, w.view(-1, N), symmetric=symmetric) + y = y.view(*shape[:-1], z.size(-1)) + # y = z.new_zeros(*shape[:-1], z.size(-1)) + return y + + +class CauchyMultiply(torch.autograd.Function): + @staticmethod + def forward(ctx, v, z, w): + batch, N = v.shape + # supported_N_values = [1 << log_n for log_n in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]] + supported_N_values = [1 << log_n for log_n in [6]] + L = z.shape[-1] + if not N in supported_N_values: + raise NotImplementedError(f"Only support N values in {supported_N_values}") + if L % 32 != 0: + raise NotImplementedError(f"Only support L values that are multiples of 32") + if not v.is_cuda and z.is_cuda and w.is_cuda: + raise NotImplementedError(f"Only support CUDA tensors") + ctx.save_for_backward(v, z, w) + return cauchy_mult_fwd(v, z, w) + + @staticmethod + def backward(ctx, dout): + v, z, w = ctx.saved_tensors + dv, dw = cauchy_mult_bwd(v, z, w, dout) + return dv, None, dw + + +class CauchyMultiplySymmetric(torch.autograd.Function): + @staticmethod + def forward(ctx, v, z, w): + batch, N = v.shape + supported_N_values = [1 << log_n for log_n in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]] + L = z.shape[-1] + if not N in supported_N_values: + raise NotImplementedError(f"Only support N values in {supported_N_values}") + max_L_value = 32 * 1024 * 64 * 1024 + if L > max_L_value: + raise NotImplementedError(f"Only support L values <= {max_L_value}") + if not v.is_cuda and z.is_cuda and w.is_cuda: + raise NotImplementedError(f"Only support CUDA tensors") + ctx.save_for_backward(v, z, w) + return cauchy_mult_sym_fwd(v, z, w) + + @staticmethod + def backward(ctx, dout): + v, z, w = ctx.saved_tensors + dv, dw = cauchy_mult_sym_bwd(v, z, w, dout) + return dv, None, dw diff --git a/s4/components.py b/s4/components.py new file mode 100644 index 0000000..e8b33c1 --- /dev/null +++ b/s4/components.py @@ -0,0 +1,216 @@ +""" Utility nn components, in particular handling activations, initializations, and normalization layers """ + +import math +from functools import partial + +import torch +import torch.nn as nn +from opt_einsum import contract + + +class modrelu(nn.Module): + def __init__(self, features): + # For now we just support square layers + super(modrelu, self).__init__() + self.features = features + self.b = nn.Parameter(torch.Tensor(self.features)) + self.reset_parameters() + + def reset_parameters(self): + self.b.data.uniform_(-0.01, 0.01) + + def forward(self, inputs): + norm = torch.abs(inputs) + biased_norm = norm + self.b + magnitude = nn.functional.relu(biased_norm) + phase = torch.sign(inputs) + + return phase * magnitude + + +class Modrelu(modrelu): + def reset_parameters(self): + self.b.data.uniform_(-0.01, 0.01) + + +def Activation(activation=None, size=None, dim=-1): + if activation in [None, "id", "identity", "linear"]: + return nn.Identity() + elif activation == "tanh": + return nn.Tanh() + elif activation == "relu": + return nn.ReLU() + elif activation == "gelu": + return nn.GELU() + elif activation in ["swish", "silu"]: + return nn.SiLU() + elif activation == "glu": + return nn.GLU(dim=dim) + elif activation == "sigmoid": + return nn.Sigmoid() + elif activation == "modrelu": + return Modrelu(size) + else: + raise NotImplementedError( + "hidden activation '{}' is not implemented".format(activation) + ) + + +def get_initializer(name, activation=None): + if activation in [None, "id", "identity", "linear", "modrelu"]: + nonlinearity = "linear" + elif activation in ["relu", "tanh", "sigmoid"]: + nonlinearity = activation + elif activation in ["gelu", "swish", "silu"]: + nonlinearity = "relu" # Close to ReLU so approximate with ReLU's gain + else: + raise NotImplementedError( + f"get_initializer: activation {activation} not supported" + ) + + if name == "uniform": + initializer = partial(torch.nn.init.kaiming_uniform_, nonlinearity=nonlinearity) + elif name == "normal": + initializer = partial(torch.nn.init.kaiming_normal_, nonlinearity=nonlinearity) + elif name == "xavier": + initializer = torch.nn.init.xavier_normal_ + elif name == "zero": + initializer = partial(torch.nn.init.constant_, val=0) + elif name == "one": + initializer = partial(torch.nn.init.constant_, val=1) + else: + raise NotImplementedError( + f"get_initializer: initializer type {name} not supported" + ) + + return initializer + + +def LinearActivation( + d_input, + d_output, + bias=True, + zero_bias_init=False, + transposed=False, + initializer=None, + activation=None, + activate=False, # Apply activation as part of this module + weight_norm=False, + **kwargs, +): + """Returns a linear nn.Module with control over axes order, initialization, and activation""" + + # Construct core module + linear_cls = TransposedLinear if transposed else nn.Linear + if activation == "glu": + d_output *= 2 + linear = linear_cls(d_input, d_output, bias=bias, **kwargs) + + # Initialize weight + if initializer is not None: + get_initializer(initializer, activation)(linear.weight) + + # Initialize bias + if bias and zero_bias_init: + nn.init.zeros_(linear.bias) + + # Weight norm + if weight_norm: + linear = nn.utils.weight_norm(linear) + + if activate and activation is not None: + activation = Activation(activation, d_output, dim=-2 if transposed else -1) + linear = nn.Sequential(linear, activation) + return linear + + +class TransposedLinear(nn.Module): + """Linear module on the second-to-last dimension""" + + def __init__(self, d_input, d_output, bias=True): + super().__init__() + + self.weight = nn.Parameter(torch.empty(d_output, d_input)) + nn.init.kaiming_uniform_(self.weight, a=math.sqrt(5)) # nn.Linear default init + # nn.init.kaiming_uniform_(self.weight, nonlinearity='linear') # should be equivalent + + if bias: + self.bias = nn.Parameter(torch.empty(d_output, 1)) + bound = 1 / math.sqrt(d_input) + nn.init.uniform_(self.bias, -bound, bound) + else: + self.bias = 0.0 + + def forward(self, x): + return contract("... u l, v u -> ... v l", x, self.weight) + self.bias + + +class TransposedLN(nn.Module): + """LayerNorm module over second-to-last dimension + + This is slow and a dedicated CUDA/Triton implementation shuld provide substantial end-to-end speedup + """ + + def __init__(self, d, scalar=True): + super().__init__() + self.scalar = scalar + if self.scalar: + self.m = nn.Parameter(torch.zeros(1)) + self.s = nn.Parameter(torch.ones(1)) + else: + self.ln = nn.LayerNorm(d) + + def forward(self, x): + if self.scalar: + s, m = torch.std_mean(x, dim=-2, unbiased=False, keepdim=True) + y = (self.s / s) * (x - m + self.m) + else: + y = self.ln(x.transpose(-1, -2)).transpose(-1, -2) + return y + + +class Normalization(nn.Module): + def __init__( + self, + d, + transposed=False, # Length dimension is -1 or -2 + _name_="layer", + **kwargs, + ): + super().__init__() + self.transposed = transposed + + if _name_ == "layer": + self.channel = True # Normalize over channel dimension + if self.transposed: + self.norm = TransposedLN(d, **kwargs) + else: + self.norm = nn.LayerNorm(d, **kwargs) + elif _name_ == "instance": + self.channel = False + norm_args = {"affine": False, "track_running_stats": False} + norm_args.update(kwargs) + self.norm = nn.InstanceNorm1d( + d, **norm_args + ) # (True, True) performs very poorly + elif _name_ == "batch": + self.channel = False + norm_args = {"affine": True, "track_running_stats": True} + norm_args.update(kwargs) + self.norm = nn.BatchNorm1d(d, **norm_args) + elif _name_ == "none": + self.channel = True + self.norm = nn.Identity() + else: + raise NotImplementedError + + def forward(self, x): + # The cases of LayerNorm / no normalization are automatically handled in all cases + # Instance/Batch Norm work automatically with transposed axes + if self.channel or self.transposed: + return self.norm(x) + else: + x = x.transpose(-1, -2) + x = self.norm(x) + x = x.transpose(-1, -2) + return x diff --git a/s4/hippo.py b/s4/hippo.py new file mode 100644 index 0000000..4b62749 --- /dev/null +++ b/s4/hippo.py @@ -0,0 +1,393 @@ +""" Definitions of A and B matrices for various HiPPO operators. """ + +import numpy as np +import torch +from einops import rearrange, repeat +from opt_einsum import contract +from scipy import special as ss + + +def embed_c2r(A): + A = rearrange(A, "... m n -> ... m () n ()") + A = np.pad(A, ((0, 0), (0, 1), (0, 0), (0, 1))) + np.pad( + A, ((0, 0), (1, 0), (0, 0), (1, 0)) + ) + return rearrange(A, "m x n y -> (m x) (n y)") + + +# TODO take in 'torch' option to return torch instead of numpy, which converts the shape of B from (N, 1) to (N) +# TODO remove tlagt +def transition(measure, N, **measure_args): + """A, B transition matrices for different measures + + measure: the type of measure + legt - Legendre (translated) + legs - Legendre (scaled) + glagt - generalized Laguerre (translated) + lagt, tlagt - previous versions of (tilted) Laguerre with slightly different normalization + """ + # Laguerre (translated) + if measure == "lagt": + b = measure_args.get("beta", 1.0) + A = np.eye(N) / 2 - np.tril(np.ones((N, N))) + B = b * np.ones((N, 1)) + elif measure == "tlagt": + # beta = 1 corresponds to no tilt + b = measure_args.get("beta", 1.0) + A = (1.0 - b) / 2 * np.eye(N) - np.tril(np.ones((N, N))) + B = b * np.ones((N, 1)) + # Generalized Laguerre + # alpha 0, beta small is most stable (limits to the 'lagt' measure) + # alpha 0, beta 1 has transition matrix A = [lower triangular 1] + elif measure == "glagt": + alpha = measure_args.get("alpha", 0.0) + beta = measure_args.get("beta", 0.01) + A = -np.eye(N) * (1 + beta) / 2 - np.tril(np.ones((N, N)), -1) + B = ss.binom(alpha + np.arange(N), np.arange(N))[:, None] + + L = np.exp( + 0.5 * (ss.gammaln(np.arange(N) + alpha + 1) - ss.gammaln(np.arange(N) + 1)) + ) + A = (1.0 / L[:, None]) * A * L[None, :] + B = ( + (1.0 / L[:, None]) + * B + * np.exp(-0.5 * ss.gammaln(1 - alpha)) + * beta ** ((1 - alpha) / 2) + ) + # Legendre (translated) + elif measure == "legt": + Q = np.arange(N, dtype=np.float64) + R = (2 * Q + 1) ** 0.5 + j, i = np.meshgrid(Q, Q) + A = R[:, None] * np.where(i < j, (-1.0) ** (i - j), 1) * R[None, :] + B = R[:, None] + A = -A + + # Halve again for timescale correctness + # A, B = A/2, B/2 + A *= 0.5 + B *= 0.5 + # LMU: equivalent to LegT up to normalization + elif measure == "lmu": + Q = np.arange(N, dtype=np.float64) + R = (2 * Q + 1)[:, None] # / theta + j, i = np.meshgrid(Q, Q) + A = np.where(i < j, -1, (-1.0) ** (i - j + 1)) * R + B = (-1.0) ** Q[:, None] * R + # Legendre (scaled) + elif measure == "legs": + q = np.arange(N, dtype=np.float64) + col, row = np.meshgrid(q, q) + r = 2 * q + 1 + M = -(np.where(row >= col, r, 0) - np.diag(q)) + T = np.sqrt(np.diag(2 * q + 1)) + A = T @ M @ np.linalg.inv(T) + B = np.diag(T)[:, None] + B = ( + B.copy() + ) # Otherwise "UserWarning: given NumPY array is not writeable..." after torch.as_tensor(B) + elif measure == "legsd": + q = np.arange(N, dtype=np.float64) + col, row = np.meshgrid(q, q) + r = 2 * q + 1 + M = -(np.where(row >= col, r, 0) - np.diag(q)) + T = np.sqrt(np.diag(2 * q + 1)) + A = T @ M @ np.linalg.inv(T) + B = np.diag(T)[:, None] + B = ( + B.copy() + ) # Otherwise "UserWarning: given NumPY array is not writeable..." after torch.as_tensor(B) + A += 0.5 * B * B[None, :, 0] + B = B / 2.0 + elif measure == "fourier_old": + freqs = np.arange(N // 2) + d = np.stack([freqs, np.zeros(N // 2)], axis=-1).reshape(-1)[:-1] + A = 2 * np.pi * (np.diag(d, 1) - np.diag(d, -1)) + A = A - embed_c2r(np.ones((N // 2, N // 2))) + B = embed_c2r(np.ones((N // 2, 1)))[..., :1] + elif measure == "fourier_diag": + freqs = np.arange(N // 2) + d = np.stack([freqs, np.zeros(N // 2)], axis=-1).reshape(-1)[:-1] + A = 2 * np.pi * (-np.diag(d, 1) + np.diag(d, -1)) + # A = A - 0.5*embed_c2r(np.ones((N//2, N//2))) + A = A - 0.5 * np.eye(N) + B = embed_c2r(np.ones((N // 2, 1)))[..., :1] + elif measure == "fourier": + freqs = np.arange(N // 2) + d = np.stack([np.zeros(N // 2), freqs], axis=-1).reshape(-1)[1:] + A = np.pi * (-np.diag(d, 1) + np.diag(d, -1)) + B = np.zeros(N) + B[0::2] = 2**0.5 + B[0] = 1 + + # Subtract off rank correction - this corresponds to the other endpoint u(t-1) in this case + A = A - B[:, None] * B[None, :] + B = B[:, None] + elif measure == "fourier_decay": + freqs = np.arange(N // 2) + d = np.stack([np.zeros(N // 2), freqs], axis=-1).reshape(-1)[1:] + A = np.pi * (-np.diag(d, 1) + np.diag(d, -1)) + B = np.zeros(N) + B[0::2] = 2**0.5 + B[0] = 1 + + # Subtract off rank correction - this corresponds to the other endpoint u(t-1) in this case + A = A - 0.5 * B[:, None] * B[None, :] + B = 0.5 * B[:, None] + elif measure == "fourier2": # Double everything: orthonormal on [0, 1] + freqs = 2 * np.arange(N // 2) + d = np.stack([np.zeros(N // 2), freqs], axis=-1).reshape(-1)[1:] + A = np.pi * (-np.diag(d, 1) + np.diag(d, -1)) + B = np.zeros(N) + B[0::2] = 2**0.5 + B[0] = 1 + + # Subtract off rank correction - this corresponds to the other endpoint u(t-1) in this case + A = A - B[:, None] * B[None, :] * 2 + B = B[:, None] * 2 + + elif measure == "random": + A = np.random.randn(N, N) / N + B = np.random.randn(N, 1) + elif measure == "diagonal": + A = -np.diag(np.exp(np.random.randn(N))) + B = np.random.randn(N, 1) + else: + raise NotImplementedError + + return A, B + + +def rank_correction(measure, N, rank=1, dtype=torch.float): + """Return low-rank matrix L such that A + L is normal""" + + if measure == "legs": + assert rank >= 1 + P = torch.sqrt(0.5 + torch.arange(N, dtype=dtype)).unsqueeze(0) # (1 N) + elif measure == "legt": + assert rank >= 2 + P = torch.sqrt(1 + 2 * torch.arange(N, dtype=dtype)) # (N) + P0 = P.clone() + P0[0::2] = 0.0 + P1 = P.clone() + P1[1::2] = 0.0 + P = torch.stack([P0, P1], dim=0) # (2 N) + P *= 2 ** ( + -0.5 + ) # Halve the rank correct just like the original matrix was halved + elif measure == "lagt": + assert rank >= 1 + P = 0.5**0.5 * torch.ones(1, N, dtype=dtype) + elif measure == "fourier_old": + P = torch.ones(N, dtype=dtype) # (N) + P0 = P.clone() + P0[0::2] = 0.0 + P1 = P.clone() + P1[1::2] = 0.0 + P = torch.stack([P0, P1], dim=0) # (2 N) + P = torch.zeros(1, N, dtype=dtype) + elif measure == "fourier": + P = torch.zeros(N) + P[0::2] = 2**0.5 + P[0] = 1 + P = P.unsqueeze(0) + elif measure == "fourier_decay": + P = torch.zeros(N) + P[0::2] = 2**0.5 + P[0] = 1 + P = P.unsqueeze(0) + P = P / 2**0.5 + elif measure == "fourier2": + P = torch.zeros(N) + P[0::2] = 2**0.5 + P[0] = 1 + P = 2**0.5 * P.unsqueeze(0) + elif measure in ["fourier_diag", "legsd"]: + P = torch.zeros(1, N, dtype=dtype) + else: + raise NotImplementedError + + d = P.size(0) + if rank > d: + P = torch.cat([P, torch.zeros(rank - d, N, dtype=dtype)], dim=0) # (rank N) + return P + + +def initial_C(measure, N, dtype=torch.float): + """Return C that captures the other endpoint in the HiPPO approximation""" + + if measure == "legt": + C = (torch.arange(N, dtype=dtype) * 2 + 1) ** 0.5 * (-1) ** torch.arange(N) + elif measure == "fourier_old": + C = torch.ones(N, dtype=dtype) # (N) + elif measure == "fourier": + C = torch.zeros(N) + C[0::2] = 2**0.5 + C[0] = 1 + else: + C = torch.zeros(N, dtype=dtype) # (N) + + return C + + +def nplr(measure, N, rank=1, dtype=torch.float): + """Return w, p, q, V, B such that + (w - p q^*, B) is unitarily equivalent to the original HiPPO A, B by the matrix V + i.e. A = V[w - p q^*]V^*, B = V B + """ + assert dtype == torch.float or torch.cfloat + + A, B = transition(measure, N) + A = torch.as_tensor(A, dtype=dtype) # (N, N) + B = torch.as_tensor(B, dtype=dtype)[:, 0] # (N,) + + P = rank_correction(measure, N, rank=rank, dtype=dtype) # (r N) + AP = A + torch.sum(P.unsqueeze(-2) * P.unsqueeze(-1), dim=-3) + w, V = torch.linalg.eig(AP) # (..., N) (..., N, N) + # V w V^{-1} = A + + # print("check", V @ torch.diag_embed(w) @ V.conj().transpose(-1, -2)) + + # We require AP to be nearly skew-symmetric + _A = AP + AP.transpose(-1, -2) + if ( + err := torch.sum((_A - _A[0, 0] * torch.eye(N)) ** 2) / N + ) > 1e-5: # if not torch.allclose(_A - _A[0,0]*torch.eye(N), torch.zeros(N, N), atol=1e-5): + print("WARNING: HiPPO matrix not skew symmetric", err) + + # Only keep half of each conjugate pair + # w = w[..., 0::2].contiguous() + # V = V[..., 0::2].contiguous() + _, idx = torch.sort(w.imag) + w_sorted = w[idx] + V_sorted = V[:, idx] + + # There is an edge case when eigenvalues can be 0, which requires some machinery to handle + # We use a huge hack here: Assume only one pair is 0, and that it is the first row/column of A (only happens in Fourier case) + V = V_sorted[:, : N // 2] + w = w_sorted[: N // 2] + assert w[-2].abs() > 1e-4, "Only 1 zero eigenvalue allowed in diagonal part of A" + if w[-1].abs() < 1e-4: + V[:, -1] = 0.0 + V[0, -1] = 2**-0.5 + V[1, -1] = 2**-0.5 * 1j + + _AP = V @ torch.diag_embed(w) @ V.conj().transpose(-1, -2) + # assert torch.allclose(2*_AP.real, AP, atol=1e-5) + if (err := torch.sum((2 * _AP.real - AP) ** 2) / N) > 1e-5: + print( + "Warning: Diagonalization of A matrix not numerically precise - error", err + ) + # print("check", V @ torch.diag_embed(w) @ V.conj().transpose(-1, -2)) + + # # Override eigenvectors for 0 eigenvalues, to make them conjugate pairs + # breakpoint() + # rotate = torch.tensor([[1, 1], [1j, -1j]]) / 2**.5 + # # rotate = torch.tensor([[1, -1j], [1, 1j]]) / 2**.5 + # V_rot = (V.view(N, N//2, 2) @ rotate).view(N, N) # rotate every pair of eigenvectors + # V = torch.where(w.repeat(N, 1) == 0, V_rot, V) + + V_inv = V.conj().transpose(-1, -2) + + C = initial_C(measure, N, dtype=dtype) + B = contract("ij, j -> i", V_inv, B.to(V)) # V^* B + C = contract("ij, j -> i", V_inv, C.to(V)) # V^* C + P = contract("ij, ...j -> ...i", V_inv, P.to(V)) # V^* P + + return w, P, B, C, V + + +def random_dplr( + N, + rank=1, + H=1, + dtype=torch.float, + real_scale=1.0, + imag_scale=1.0, + scaling="inverse", + random_real=False, + random_imag=False, + normalize=True, +): + assert dtype == torch.float or torch.double + # batch_shape = (H, N//2) if H is not None else (N//2,) + dtype = torch.cfloat if dtype == torch.float else torch.cdouble + # w = -torch.exp(torch.randn(N//2)) + 1j*torch.randn(N//2) + # w = -torch.exp(torch.randn(N//2)) + 1j*2*torch.tensor(np.pi)*N*torch.rand(N//2) # try larger eigenvalue spread + + pi = torch.tensor(np.pi) + if random_real: + real_part = torch.rand(H, N // 2) + else: + real_part = 0.5 * torch.ones(H, N // 2) + if random_imag: + imag_part = N // 2 * torch.rand(H, N // 2) + else: + imag_part = repeat(torch.arange(N // 2), "n -> h n", h=H) + + real_part = real_scale * real_part + if scaling == "random": + imag_part = torch.randn(H, N // 2) + elif scaling == "linear": + imag_part = pi * imag_part + elif scaling == "inverse": # Based on asymptotics of the default HiPPO matrix + # intercept = torch.log(N//2)/torch.log(2) * 2./3. + # log_imag_part = intercept + 2. * torch.atanh((1+imag_part*2)/N*2-1) + # imag_part = torch.exp(log_imag_part) + # intercept = torch.log(N//2) - .5 + # imag_part = torch.exp(2. * torch.atanh((1+imag_part*2)/N*2-1)) + imag_part = 1 / pi * N * (N / (1 + 2 * imag_part) - 1) + elif scaling == "inverse2": # Based on asymptotics of the default HiPPO matrix + # intercept = torch.log(N//2)/torch.log(2) * 2./3. + # log_imag_part = intercept + 2. * torch.atanh((1+imag_part*2)/N*2-1) + # imag_part = torch.exp(log_imag_part) + # intercept = torch.log(N//2) - .5 + # imag_part = torch.exp(2. * torch.atanh((1+imag_part*2)/N*2-1)) + imag_part = 1 / pi * N * (N / (1 + imag_part) - 1) + elif scaling == "quadratic": + imag_part = 1 / pi * (1 + 2 * imag_part) ** 2 + else: + raise NotImplementedError + imag_part = imag_scale * imag_part + w = -real_part + 1j * imag_part + + # w = -torch.rand(N//2) + 1j*2*torch.tensor(np.pi)*N*torch.rand(N//2) # try larger eigenvalue spread + # w = -1 + torch.arange(N//2) * 1j * 2 * torch.tensor(np.pi) + P = torch.randn(rank, H, N // 2, dtype=dtype) + # p = torch.zeros(rank, N//2, dtype=dtype) + B = torch.randn(H, N // 2, dtype=dtype) + # B = torch.ones(N//2, dtype=dtype) + C = torch.randn(H, N // 2, dtype=dtype) + V = torch.eye(N, dtype=dtype)[..., : N // 2] # Only used in testing + + if normalize: # TODO can normalize the full matrix with rank correction too + norm = ( + -B / w + ) # (H, N) # Result if you integrate the kernel with constant 1 function + zeta = 2 * torch.sum( + torch.abs(norm) ** 2, dim=-1, keepdim=True + ) # Variance with a random C vector + B = B / zeta**0.5 + + return w, P, B, C, V + + +def test_nplr(): + N = 4 + measure = "fourier_decay" + w, P, B, C, V = nplr(measure, N, rank=1) + w = torch.cat([w, w.conj()], dim=-1) + V = torch.cat([V, V.conj()], dim=-1) + B = torch.cat([B, B.conj()], dim=-1) + P = torch.cat([P, P.conj()], dim=-1) + Q = P + # q = torch.cat([q, q.conj()], dim=-1) + A = torch.diag_embed(w) - contract("... r p, ... r q -> ... p q", P, Q.conj()) + + A = contract( + "ij, jk, kl -> ... il", V, A, V.conj().transpose(-1, -2) + ) # Ap^{-1} = V @ w^{-1} @ V^T + B = contract("ij, ... j -> ... i", V, B) + print(A.real) + print(B.real) diff --git a/s4/kernel.py b/s4/kernel.py new file mode 100644 index 0000000..871a835 --- /dev/null +++ b/s4/kernel.py @@ -0,0 +1,1143 @@ +""" Core S4 convolution kernel implementing the 'normal plus low-rank' algorithm. + +The main module is SSKernelNPLR, which stores parameters A, B, C, dt, and calling it creates the SSM convolution kernel bar{K}. + +A much simpler version SSKernelSlow is included for illustration purposes: it has the same output, but uses the naive algorithm which is much slower. This module is meant for testing and exposition, to understand what the State Space Kernel actually does. + +HiPPOSSKernel specializes the SSKernels to specific instantiations of HiPPO matrices. +""" + + +import logging +import math + +import numpy as np +import torch +import torch.nn as nn +from einops import rearrange, repeat +from opt_einsum import contract, contract_expression + +import hippo as hippo +from krylov import krylov, power +from logger import get_logger + + +log = get_logger(__name__) + +try: + from cauchy import cauchy_mult + + has_cauchy_extension = True + log.info("CUDA extension for cauchy multiplication found.") +except ImportError: + log.warn( + "CUDA extension for cauchy multiplication not found. Install by going to extensions/cauchy/ and running `python setup.py install`. This should speed up end-to-end training by 10-50%" + ) + has_cauchy_extension = False + +try: + import pykeops + + from pykeops_cauchy import cauchy_conj + + has_pykeops = True + log.info("Pykeops installation found.") +except ImportError: + has_pykeops = False + from pykeops_cauchy import cauchy_slow + + if not has_cauchy_extension: + log.error( + "Falling back on slow Cauchy kernel. Install at least one of pykeops or the CUDA extension for efficiency." + ) + + +_isnan = lambda x: torch.isnan(x).any() +_isinf = lambda x: torch.isinf(x).any() + +_conj = lambda x: torch.cat([x, x.conj()], dim=-1) +_c2r = torch.view_as_real +_r2c = torch.view_as_complex + +if tuple(map(int, torch.__version__.split(".")[:2])) >= (1, 10): + _resolve_conj = lambda x: x.conj().resolve_conj() +else: + _resolve_conj = lambda x: x.conj() + + +def bilinear(dt, A, B=None): + """ + dt: (...) timescales + A: (... N N) + B: (... N) + """ + N = A.shape[-1] + I = torch.eye(N).to(A) + A_backwards = I - dt[:, None, None] / 2 * A + A_forwards = I + dt[:, None, None] / 2 * A + + if B is None: + dB = None + else: + dB = dt[..., None] * torch.linalg.solve(A_backwards, B.unsqueeze(-1)).squeeze( + -1 + ) # (... N) + + dA = torch.linalg.solve(A_backwards, A_forwards) # (... N N) + return dA, dB + + +class OptimModule(nn.Module): + """Interface for Module that allows registering buffers/parameters with configurable optimizer hyperparameters""" + + def register(self, name, tensor, trainable=False, lr=None, wd=None): + """Utility method: register a tensor as a buffer or trainable parameter""" + + if trainable: + self.register_parameter(name, nn.Parameter(tensor)) + else: + self.register_buffer(name, tensor) + + optim = {} + if trainable and lr is not None: + optim["lr"] = lr + if trainable and wd is not None: + optim["weight_decay"] = wd + if len(optim) > 0: + setattr(getattr(self, name), "_optim", optim) + + +class SSKernelNPLR(OptimModule): + """Stores a representation of and computes the SSKernel function K_L(A^dt, B^dt, C) corresponding to a discretized state space, where A is Normal + Low Rank (NPLR) + + The class name stands for 'State-Space SSKernel for Normal Plus Low-Rank'. + The parameters of this function are as follows. + + A: (... N N) the state matrix + B: (... N) input matrix + C: (... N) output matrix + dt: (...) timescales / discretization step size + p, q: (... P N) low-rank correction to A, such that Ap=A+pq^T is a normal matrix + + The forward pass of this Module returns: + (... L) that represents represents FFT SSKernel_L(A^dt, B^dt, C) + + """ + + @torch.no_grad() + def _setup_C(self, L): + """Construct C~ from C + + Two modes are supported: go directly to length L if self.L is 1, or length is doubled + """ + + if self.L.item() == 0: + if self.verbose: + log.info(f"S4: Initializing kernel to length {L}") + double_length = False + elif L > self.L.item(): # 2*int(self.L) == L: + if self.verbose: + log.info( + f"S4: Doubling length from L = {self.L.item()} to {2*self.L.item()}" + ) + double_length = True + L = self.L.item() # Convenience for the math below + else: + return + + C = _r2c(self.C) + dA, _ = self._setup_state() + dA_L = power(L, dA) + # Multiply C by I - dA_L + C_ = _conj(C) + prod = contract("h m n, c h n -> c h m", dA_L.transpose(-1, -2), C_) + if double_length: + prod = -prod # Multiply by I + dA_L instead + C_ = C_ - prod + C_ = C_[..., : self.N] # Take conjugate pairs again + self.C.copy_(_c2r(C_)) + + self.L = 2 * self.L if double_length else self.L + L # Preserve type/device + + def _omega(self, L, dtype, device, cache=True): + """Calculate (and cache) FFT nodes and their "unprocessed" version with the bilinear transform + This should be called everytime the internal length self.L changes""" + + # Use cached if available + if cache and hasattr(self, "omega") and self.omega.size(-1) == L // 2 + 1: + return self.omega.to(device), self.z.to(device) + + omega = torch.tensor( + np.exp(-2j * np.pi / (L)), dtype=dtype, device=device + ) # \omega_{2L} + omega = omega ** torch.arange(0, L // 2 + 1, device=device) + z = 2 * (1 - omega) / (1 + omega) + + # Cache if necessary + if cache: + self.omega = omega + self.z = z + return omega, z + + def __init__( + self, + w, + P, + B, + C, + log_dt, + L=None, # starting/maximum length of kernel + trainable=None, + lr=None, + lr_dt=None, + verbose=False, + keops=False, + fast_gate=False, + quadrature=None, + ): + """ + L: Maximum length; this module computes an SSM kernel of length L + w: (n_ssm, N) + p: (r, n_ssm, N) low-rank correction to A + A represented by diag(w) - pq^* + + B: (n_ssm, N) + dt: (H) timescale per feature + C: (C, H, N) system is 1-D to c-D (channels) + + trainable: toggle which of the parameters is trainable + lr: add hook to set lr of hippo parameters specially (everything besides C) + + Note: tensor shape N here denotes half the true state size, because of conjugate symmetry + """ + + super().__init__() + self.verbose = verbose + self.keops = keops + self.fast_gate = fast_gate + + # Rank of low-rank correction + self.rank = P.shape[-3] + assert w.size(-1) == P.size(-1) == B.size(-1) == C.size(-1) + self.H = log_dt.size(-1) + self.N = w.size(-1) + + # Check different SSM inits + assert w.size(-2) == P.size(-2) == B.size(-2) # Number of copies + assert self.H % w.size(0) == 0 + self.n_ssm = w.size(0) + self.copies = self.H // w.size(0) + if lr_dt is None: + lr_dt = lr + + # Broadcast everything to correct shapes + C = C.expand(torch.broadcast_shapes(C.shape, (1, self.H, self.N))) # (H, C, N) + B = B.unsqueeze(0) # (1, 1, N) + + # Register parameters + self.C = nn.Parameter(_c2r(_resolve_conj(C))) + train = False + if trainable is None: + trainable = {} + if trainable == False: + trainable = {} + if trainable == True: + trainable, train = {}, True + self.register("log_dt", log_dt, trainable.get("dt", train), lr_dt, 0.0) + self.register("B", B, trainable.get("B", train), lr, 0.0) + self.register("P", P, trainable.get("P", train), lr, 0.0) + log_w_real = torch.log( + -w.real + 1e-3 + ) # Some of the HiPPO methods have real part 0 + w_imag = w.imag + self.register("log_w_real", log_w_real, trainable.get("A", 0), lr, 0.0) + self.register("w_imag", w_imag, trainable.get("A", train), lr, 0.0) + + self.l_max = L + self.register_buffer("L", torch.tensor(0)) # Internal length + + self.quadrature = quadrature + + def _w(self): + # Get the internal w (diagonal) parameter + w_real = -torch.exp(self.log_w_real) + w_imag = self.w_imag + w = w_real + 1j * w_imag + return w + + def forward(self, state=None, rate=1.0, L=None): + """ + state: (..., s, N) extra tensor that augments B + rate: sampling rate factor + + returns: (..., c+s, L) + """ + + # Initialize C~ if necessary (done in forward pass so it's on the correct device) + if self.L.item() == 0 and self.l_max is not None and self.l_max > 0: + self._setup_C(self.l_max) + + # Handle sampling rate logic + # The idea is that this kernel's length (in continuous units) is self.L, while we are asked to provide a kernel of length L at (relative) sampling rate rate + # If either are not passed in, assume we're not asked to change the scale of our kernel + assert not (rate is None and L is None) + if rate is None: + rate = self.L.item() / L + if L is None: + L = round(self.L.item() / rate) + + # Increase the internal length if needed + continuous_L = round(rate * L) + while continuous_L > self.L.item(): + self._setup_C(continuous_L) + discrete_L = round(self.L.item() / rate) + + if self.fast_gate: + dt = torch.exp(torch.sinh(self.log_dt)) * rate + else: + dt = torch.exp(self.log_dt) * rate + B = self.B + C = _r2c(self.C) + P = self.P + Q = P.conj() + w = self._w() + + # Get FFT nodes of right length + omega, z = self._omega( + discrete_L, dtype=w.dtype, device=w.device, cache=(rate == 1.0) + ) + + # Broadcast parameters to same hidden features H + B = repeat(B, "1 t n -> 1 (v t) n", v=self.copies) + P = repeat(P, "r t n -> r (v t) n", v=self.copies) + Q = repeat(Q, "r t n -> r (v t) n", v=self.copies) + w = repeat(w, "t n -> (v t) n", v=self.copies) + + # Augment B + if state is not None: + # Have to "unbilinear" the state to put it into the same "type" as B + # Compute 1/dt * (I + dt/2 A) @ state + + # Can do this without expanding (maybe minor speedup using conj symmetry in theory), but it's easier to read this way + s = _conj(state) if state.size(-1) == self.N else state # (B H N) + sA = s * _conj(w) - contract( # (B H N) + "bhm, rhm, rhn -> bhn", s, _conj(Q), _conj(P) + ) + s = s / dt.unsqueeze(-1) + sA / 2 + s = s[..., : self.N] + + B = torch.cat([s, B], dim=-3) # (s+1, H, N) + + # Incorporate dt into A + w = w * dt.unsqueeze(-1) # (H N) + + # Stack B and p, C and q for convenient batching + B = torch.cat([B, P], dim=-3) # (s+1+r, H, N) + C = torch.cat([C, Q], dim=-3) # (c+r, H, N) + + # Incorporate B and C batch dimensions + v = B.unsqueeze(-3) * C.unsqueeze(-4) # (s+1+r, c+r, H, N) + # w = w[None, None, ...] # (1, 1, H, N) + # z = z[None, None, None, ...] # (1, 1, 1, L) + + # Calculate resolvent at omega + if has_cauchy_extension and z.dtype == torch.cfloat and not self.keops: + r = cauchy_mult(v, z, w, symmetric=True) + elif has_pykeops: + r = cauchy_conj(v, z, w) + else: + r = cauchy_slow(v, z, w) + r = r * dt[None, None, :, None] # (S+1+R, C+R, H, L) + + # Low-rank Woodbury correction + if self.rank == 1: + k_f = r[:-1, :-1, :, :] - r[:-1, -1:, :, :] * r[-1:, :-1, :, :] / ( + 1 + r[-1:, -1:, :, :] + ) + elif self.rank == 2: + r00 = r[: -self.rank, : -self.rank, :, :] + r01 = r[: -self.rank, -self.rank :, :, :] + r10 = r[-self.rank :, : -self.rank, :, :] + r11 = r[-self.rank :, -self.rank :, :, :] + det = (1 + r11[:1, :1, :, :]) * (1 + r11[1:, 1:, :, :]) - r11[ + :1, 1:, :, : + ] * r11[1:, :1, :, :] + s = ( + r01[:, :1, :, :] * (1 + r11[1:, 1:, :, :]) * r10[:1, :, :, :] + + r01[:, 1:, :, :] * (1 + r11[:1, :1, :, :]) * r10[1:, :, :, :] + - r01[:, :1, :, :] * (r11[:1, 1:, :, :]) * r10[1:, :, :, :] + - r01[:, 1:, :, :] * (r11[1:, :1, :, :]) * r10[:1, :, :, :] + ) + s = s / det + k_f = r00 - s + else: + r00 = r[: -self.rank, : -self.rank, :, :] + r01 = r[: -self.rank, -self.rank :, :, :] + r10 = r[-self.rank :, : -self.rank, :, :] + r11 = r[-self.rank :, -self.rank :, :, :] + r11 = rearrange(r11, "a b h n -> h n a b") + r11 = torch.linalg.inv(torch.eye(self.rank, device=r.device) + r11) + r11 = rearrange(r11, "h n a b -> a b h n") + k_f = r00 - torch.einsum( + "i j h n, j k h n, k l h n -> i l h n", r01, r11, r10 + ) + + # Final correction for the bilinear transform + k_f = k_f * 2 / (1 + omega) + + # Move from frequency to coefficients + k = torch.fft.irfft(k_f, n=discrete_L) # (S+1, C, H, L) + + # # Truncate to target length + k = k[..., :L] + + if state is not None: + k_state = k[:-1, :, :, :] # (S, C, H, L) + else: + k_state = None + k_B = k[-1, :, :, :] # (C H L) + + if self.quadrature == "trapezoid": + w = torch.ones(*k_B.shape).to(k_B) * dt[None, :, None] + w[..., 0] /= 2.0 + w[..., -1] /= 2 + k_B = k_B * w + elif self.quadrature == "simpson": + w = torch.ones(*k_B.shape).to(k_B) * dt[None, :, None] / 3.0 + w[..., 1:-1:2] *= 4 + w[..., 2:-1:2] *= 2 + k_B = k_B * w + + return k_B, k_state + + @torch.no_grad() + def double_length(self): + # if self.verbose: log.info(f"S4: Doubling length from L = {self.L} to {2*self.L}") + self._setup_C(2 * self.L) + + @torch.no_grad() + def _check(self): + """Check if A, B, C parameters and vanilla SSKernel construction can be recovered""" + + self.setup_step() + + K = krylov(self.L, self.dA, self.dB, self.dC) + + diff = K - self.forward(L=self.L)[0] + print("checking DPLR Kernel construction", torch.sum(diff**2)) + + @torch.no_grad() + def _setup_linear(self): + """Create parameters that allow fast linear stepping of state""" + w = self._w() + B = self.B # (H N) + P = self.P + Q = P.conj() + + # Repeat w shape properly + B = repeat(B, "1 t n -> 1 (v t) n", v=self.copies) + P = repeat(P, "r t n -> r (v t) n", v=self.copies) + Q = repeat(Q, "r t n -> r (v t) n", v=self.copies) + w = repeat(w, "t n -> (v t) n", v=self.copies) + + # Prepare Linear stepping + dt = torch.exp(self.log_dt) + D = (2.0 / dt.unsqueeze(-1) - w).reciprocal() # (H, N) + R = ( + torch.eye(self.rank, dtype=w.dtype, device=w.device) + + 2 * contract("r h n, h n, s h n -> h r s", Q, D, P).real + ) # (H r r) + Q_D = rearrange(Q * D, "r h n -> h r n") + try: + R = torch.linalg.solve(R.to(Q_D), Q_D) # (H r N) + except torch._C._LinAlgError: + R = torch.tensor(np.linalg.solve(R.to(Q_D).cpu(), Q_D.cpu())).to(Q_D) + R = rearrange(R, "h r n -> r h n") + + self.step_params = { + "D": D, # (H N) + "R": R, # (r H N) + "P": P, # (r H N) + "Q": Q, # (r H N) + "B": B, # (1 H N) + "E": 2.0 / dt.unsqueeze(-1) + w, # (H N) + } + + def _step_state_linear(self, u=None, state=None): + """ + Version of the step function that has time O(N) instead of O(N^2) per step, which takes advantage of the DPLR form and bilinear discretization. + + Unfortunately, as currently implemented it's about 2x slower because it calls several sequential operations. Perhaps a fused CUDA kernel implementation would be much faster + + u: (H) input + state: (H, N/2) state with conjugate pairs + Optionally, the state can have last dimension N + Returns: same shape as state + """ + C = _r2c(self.C) # View used for dtype/device + + if u is None: # Special case used to find dA + u = torch.zeros(self.H, dtype=C.dtype, device=C.device) + if state is None: # Special case used to find dB + state = torch.zeros(self.H, self.N, dtype=C.dtype, device=C.device) + + step_params = self.step_params.copy() + if ( + state.size(-1) == self.N + ): # Only store half of the conjugate pairs; should be true by default + # There should be a slightly faster way using conjugate symmetry + contract_fn = lambda p, x, y: contract( + "r h n, r h m, ... h m -> ... h n", _conj(p), _conj(x), _conj(y) + )[ + ..., : self.N + ] # inner outer product + else: + assert state.size(-1) == 2 * self.N + step_params = {k: _conj(v) for k, v in step_params.items()} + # TODO worth setting up a contract_expression in default_state if we want to use this at inference time for stepping + contract_fn = lambda p, x, y: contract( + "r h n, r h m, ... h m -> ... h n", p, x, y + ) # inner outer product + D = step_params["D"] # (H N) + E = step_params["E"] # (H N) + R = step_params["R"] # (r H N) + P = step_params["P"] # (r H N) + Q = step_params["Q"] # (r H N) + B = step_params["B"] # (1 H N) + + new_state = E * state - contract_fn(P, Q, state) # (B H N) + new_state = new_state + 2.0 * B * u.unsqueeze(-1) # (B H N) + new_state = D * (new_state - contract_fn(P, R, new_state)) + + return new_state + + def _setup_state(self): + """Construct dA and dB for discretized state equation""" + + # Construct dA and dB by using the stepping + self._setup_linear() + C = _r2c(self.C) # Just returns a view that we use for finding dtype/device + + state = torch.eye(2 * self.N, dtype=C.dtype, device=C.device).unsqueeze( + -2 + ) # (N 1 N) + dA = self._step_state_linear(state=state) + dA = rearrange(dA, "n h m -> h m n") + # self.dA = dA # (H N N) + + u = C.new_ones(self.H) + dB = self._step_state_linear(u=u) + dB = _conj(dB) + dB = rearrange(dB, "1 h n -> h n") # (H N) + return dA, dB + + def _step_state(self, u, state): + """Must be called after self.default_state() is used to construct an initial state!""" + next_state = self.state_contraction(self.dA, state) + self.input_contraction( + self.dB, u + ) + return next_state + + def setup_step(self, mode="dense"): + """Set up dA, dB, dC discretized parameters for stepping""" + self.dA, self.dB = self._setup_state() + + # Calculate original C + dA_L = power(self.L, self.dA) + I = torch.eye(self.dA.size(-1)).to(dA_L) + C = _conj(_r2c(self.C)) # (H C N) + + dC = torch.linalg.solve( + I - dA_L.transpose(-1, -2), + C.unsqueeze(-1), + ).squeeze(-1) + self.dC = dC + + # Do special preprocessing for different step modes + + self._step_mode = mode + if mode == "linear": + # Linear case: special step function for the state, we need to handle output + # use conjugate symmetry by default, which affects the output projection + self.dC = 2 * self.dC[:, :, : self.N] + elif mode == "diagonal": + # Eigendecomposition of the A matrix + L, V = torch.linalg.eig(self.dA) + V_inv = torch.linalg.inv(V) + # Check that the eigendedecomposition is correct + if self.verbose: + print( + "Diagonalization error:", + torch.dist(V @ torch.diag_embed(L) @ V_inv, self.dA), + ) + + # Change the parameterization to diagonalize + self.dA = L + self.dB = contract("h n m, h m -> h n", V_inv, self.dB) + self.dC = contract("h n m, c h n -> c h m", V, self.dC) + + elif mode == "dense": + pass + else: + raise NotImplementedError( + "NPLR Kernel step mode must be {'dense' | 'linear' | 'diagonal'}" + ) + + def default_state(self, *batch_shape): + C = _r2c(self.C) + N = C.size(-1) + H = C.size(-2) + + # Cache the tensor contractions we will later do, for efficiency + # These are put in this function because they depend on the batch size + if self._step_mode != "linear": + N *= 2 + + if self._step_mode == "diagonal": + self.state_contraction = contract_expression( + "h n, ... h n -> ... h n", + (H, N), + batch_shape + (H, N), + ) + else: + # Dense (quadratic) case: expand all terms + self.state_contraction = contract_expression( + "h m n, ... h n -> ... h m", + (H, N, N), + batch_shape + (H, N), + ) + + self.input_contraction = contract_expression( + "h n, ... h -> ... h n", + (H, N), # self.dB.shape + batch_shape + (H,), + ) + + self.output_contraction = contract_expression( + "c h n, ... h n -> ... c h", + (C.shape[0], H, N), # self.dC.shape + batch_shape + (H, N), + ) + + state = torch.zeros(*batch_shape, H, N, dtype=C.dtype, device=C.device) + return state + + def step(self, u, state): + """Must have called self.setup_step() and created state with self.default_state() before calling this""" + + if self._step_mode == "linear": + new_state = self._step_state_linear(u, state) + else: + new_state = self._step_state(u, state) + y = self.output_contraction(self.dC, new_state) + return y, new_state + + +class SSKernelSlow(OptimModule): + """Slow version of SSKernel function for illustration and benchmarking. + + - Caches discretized matrices A^(dt), B^(dt) + - Computes K_L(A^dt, B^dt, C) + + Usage: + ``` + krylov = SSKernelSlow(L, A, B, C, log_dt)() + ``` + Result is expected to be equal to SSKernelNPLR(L, w, P, B, C, log_dt, P)() if A = w - PP^* + """ + + def __init__(self, A, B, C, log_dt, L=None, trainable=None, lr=None): + super().__init__() + self.L = L + self.N = A.size(-1) + self.H = log_dt.size(-1) + + C = C.expand(torch.broadcast_shapes(C.shape, (1, self.H, self.N))) # (C, H, N) + + # Register parameters + train = False + if trainable is None: + trainable = {} + if trainable == False: + trainable = {} + if trainable == True: + trainable, train = {}, True + self.register("log_dt", log_dt, trainable.get("dt", train), lr) + self.register("A", A, trainable.get("A", train), lr) + self.register("B", B, trainable.get("B", train), lr) + # NOTE leaving in complex form for convenience, which means it currently won't work with DDP and might have incorrect param count + # This class shouldn't be used for anything other than testing and simple ablations, so this is fine + # self.register("C", C.conj().resolve_conj(), True, None, wd=None) + self.C = nn.Parameter(_resolve_conj(C)) + + # Cache if nothing is trained + self.trainable = ( + trainable.get("dt", train) + or trainable.get("A", train) + or trainable.get("B", train) + ) + self.K = None # Compute in forward pass since that ensures correct device + + def forward(self, state=None, rate=1.0, L=None): + if L is None: + L = self.L + # This class shouldn't support the more advanced sampling and variable length functionalities, since it's just for testing + # But the code from NPLR could be pasted here if desired + assert rate == 1.0 and L is not None + + if self.trainable: + dA, dB = bilinear(torch.exp(self.log_dt), self.A, self.B) + k = krylov(L, dA, dB, self.C) # (H L) + else: + if self.K is None: + dA, dB = bilinear(torch.exp(self.log_dt), self.A, self.B) + self.K = krylov(L, dA, dB) # (H N L) + k = contract("hnl,chn->chl", self.K[..., :L], self.C) + + if state is not None: + state = state.to(self.dA) + state = contract("... n m, ... m -> ... n", self.dA, state) + k_state = krylov(L, self.dA, state.unsqueeze(-3), self.C) + else: + k_state = None + return k, k_state + # return k.to(torch.float) + + def default_state(self, *batch_shape): + state = torch.zeros( + *batch_shape, self.H, self.N, dtype=self.C.dtype, device=self.C.device + ) + return state + + def _setup_state(self): + self.dA, self.dB = bilinear(torch.exp(self.log_dt), self.A, self.B) + + def setup_step(self): + self._setup_state() + self.dC = self.C + + def step(self, u, state): + next_state = contract("h m n, b h n -> b h m", self.dA, state) + contract( + "h n, b h -> b h n", self.dB, u + ) + y = contract("c h n, b h n -> b c h", self.dC, next_state) + return y, next_state + + +class SSKernelDiag(OptimModule): + """Version using (complex) diagonal state matrix. Main difference is this uses the ZOH instead of Bilinear transform. Note that it is slower and less memory efficient than the NPLR kernel because of lack of kernel support.""" + + def __init__( + self, + w, + C, + log_dt, + L=None, + disc="bilinear", + trainable=None, + lr=None, + quadrature=None, + ): + + super().__init__() + self.L = L + self.disc = disc + + # Rank of low-rank correction + assert w.size(-1) == C.size(-1) + self.H = log_dt.size(-1) + self.N = w.size(-1) + assert self.H % w.size(0) == 0 + self.copies = self.H // w.size(0) + + # Broadcast everything to correct shapes + C = C.expand(torch.broadcast_shapes(C.shape, (1, self.H, self.N))) # (H, C, N) + + # Register parameters + # C is a regular parameter, not part of state + self.C = nn.Parameter(_c2r(_resolve_conj(C))) + train = False + if trainable is None: + trainable = {} + if trainable == False: + trainable = {} + if trainable == True: + trainable, train = {}, True + self.register("log_dt", log_dt, trainable.get("dt", train), lr, 0.0) + + if self.disc in ["bilinear", "zoh", "foh"]: + log_w_real = torch.log( + -w.real + 1e-3 + ) # Some of the HiPPO methods have real part 0 + w_imag = w.imag + self.register("log_w_real", log_w_real, trainable.get("A", 0), lr, 0.0) + self.register("w_imag", w_imag, trainable.get("A", train), lr, 0.0) + elif self.disc == "dss": + self.register("w", _c2r(w), trainable.get("A", train), lr, 0.0) + else: + raise NotImplementedError + + self.quadrature = quadrature + + def _w(self): + # Get the internal w (diagonal) parameter + if self.disc != "dss": + w_real = -torch.exp(self.log_w_real) + w_imag = self.w_imag + w = w_real + 1j * w_imag + else: + w = _r2c(self.w) # (..., N) + w = repeat(w, "t n -> (v t) n", v=self.copies) # (H N) + return w + + def forward(self, state=None, rate=1.0, L=None): + """ + state: (..., s, N) extra tensor that augments B + rate: sampling rate factor + + returns: (..., c+s, L) + """ + # Handle sampling rate logic + # The idea is that this kernel's length (in continuous units) is self.L, while we are asked to provide a kernel of length L at (relative) sampling rate rate + # If either are not passed in, assume we're not asked to change the scale of our kernel + assert not (rate is None and L is None) + if rate is None: + rate = self.L / L + if L is None: + L = round(self.L / rate) + + dt = torch.exp(self.log_dt) * rate # (H) + C = _r2c(self.C) # (C H N) + w = self._w() # (H N) + + # Incorporate dt into A + dtA = w * dt.unsqueeze(-1) # (H N) + + if self.disc == "zoh": + # Power up + K = dtA.unsqueeze(-1) * torch.arange(L, device=w.device) # (H N L) + C = C * (torch.exp(dtA) - 1.0) / w + K = contract("chn, hnl -> chl", C, torch.exp(K)) + K = 2 * K.real + elif self.disc == "foh": + # Power up + K = dtA.unsqueeze(-1) * torch.arange(L, device=w.device) # (H N L) + K_exp = torch.exp(K) + C = C / (dt.unsqueeze(-1) * w**2) + exp_dA = torch.exp(dtA) + C_0 = -(exp_dA - 1.0 - dtA * exp_dA) * C # kernel for conv with u_k + C_1 = (exp_dA - 1.0 - dtA) * C # kernel for conv with u_{k+1} + K_0 = contract("chn, hnl -> chl", C_0, K_exp) + K_1 = contract("chn, hnl -> chl", C_1, K_exp) + K_0 = 2 * K_0.real + K_1 = 2 * K_1.real + K = K_1 + K[..., -1] = 0.0 + K[..., 1:] += K_0[..., :-1] + elif self.disc == "bilinear": + dA = (1.0 + dtA / 2) / (1.0 - dtA / 2) + K = dA.unsqueeze(-1) ** torch.arange(L, device=w.device) # (H N L) + C = C * (1.0 - dtA / 2).reciprocal() * dt.unsqueeze(-1) # or * dtA / w + K = contract("chn, hnl -> chl", C, K) + K = 2 * K.real + else: + # Implementation from DSS meant for case when real eigenvalues can be positive + P = dtA.unsqueeze(-1) * torch.arange(L, device=C.device) # [H N L] + w_gt_0 = w.real > 0 # [N] + if w_gt_0.any(): + with torch.no_grad(): + P_max = dtA * (w_gt_0 * (L - 1)) # [H N] + P = P - P_max.unsqueeze(-1) # [H N L] + S = P.exp() # [H N L] + + dtA_neg = dtA * (1 - 2 * w_gt_0) # [H N] + # S.sum(-1) == den / num + num = dtA_neg.exp() - 1 # [H N] + den = (dtA_neg * L).exp() - 1 # [H N] + + # Inline reciprocal function for DSS logic + x = den * w + x_conj = _resolve_conj(x) + r = x_conj / (x * x_conj + 1e-7) + + C = C * num * r # [C H N] + K = contract("chn,hnl->chl", C, S).float() + + if self.quadrature == "trapezoid": + w = torch.ones(*K.shape).to(K) * dt[None, :, None] + w[..., 0] /= 2.0 + w[..., -1] /= 2 + K = K * w + elif self.quadrature == "simpson": + w = torch.ones(*K.shape).to(K) * dt[None, :, None] / 3.0 + w[..., 1:-1:2] *= 4 + w[..., 2:-1:2] *= 2 + K = K * w + + return K, None + + def setup_step(self): + dt = torch.exp(self.log_dt) # (H) + C = _r2c(self.C) # (C H N) + w = self._w() # (H N) + + # Incorporate dt into A + dtA = w * dt.unsqueeze(-1) # (H N) + if self.disc == "zoh": + self.dA = torch.exp(dtA) # (H N) + self.dC = C * (torch.exp(dtA) - 1.0) / w # (C H N) + elif self.disc == "bilinear": + self.dA = (1.0 + dtA / 2) / (1.0 - dtA / 2) + self.dC = ( + C * (1.0 - dtA / 2).reciprocal() * dt.unsqueeze(-1) + ) # or * dtA / w + self.dB = self.dC.new_ones(self.H, self.N) # (H N) + + # if self.disc == 'zoh': + # # Power up + # K = dtA.unsqueeze(-1) * torch.arange(L, device=w.device) # (H N L) + # C = C * (torch.exp(dtA)-1.) / w + # K = contract('chn, hnl -> chl', C, torch.exp(K)) + # K = 2*K.real + # elif self.disc == 'bilinear': + # dA = (1. + dtA/2) / (1. - dtA/2) + # K = dA.unsqueeze(-1) ** torch.arange(L, device=w.device) # (H N L) + # C = C * (1. - dtA/2).reciprocal() * dt.unsqueeze(-1) # or * dtA / w + # K = contract('chn, hnl -> chl', C, K) + # K = 2*K.real + + def default_state(self, *batch_shape): + C = _r2c(self.C) + state = torch.zeros( + *batch_shape, self.H, self.N, dtype=C.dtype, device=C.device + ) + return state + + def step(self, u, state): + next_state = contract("h n, b h n -> b h n", self.dA, state) + contract( + "h n, b h -> b h n", self.dB, u + ) + y = contract("c h n, b h n -> b c h", self.dC, next_state) + return 2 * y.real, next_state + + # @staticmethod + # def reciprocal(x, epsilon=1e-7, clamp=False): + # """ returns 1 / x, with bounded norm """ + # x_conj = x.conj() + # norm_sq = (x*x_conj).real.clamp(epsilon) if clamp else (x*x_conj + epsilon) + # return x_conj / norm_sq + + +class HippoSSKernel(nn.Module): + """Wrapper around SSKernel that generates A, B, C, dt according to HiPPO arguments. + + The SSKernel is expected to support the interface + forward() + default_state() + setup_step() + step() + """ + + def __init__( + self, + H, + N=64, + L=None, + measure="legs", + rank=1, + channels=1, # 1-dim to C-dim map; can think of C as having separate "heads" + dt_min=0.001, + dt_max=0.1, + deterministic=False, + trainable=None, # Dictionary of options to train various HiPPO parameters + lr=None, # Hook to set LR of hippo parameters differently + lr_dt=None, + mode="nplr", # 'slow' for complex naive version, 'real' for real naive version + n_ssm=1, # Copies of the ODE parameters A and B. Must divide H + precision=1, # 1 (single) or 2 (double) for the kernel + resample=False, # If given inputs of different lengths, adjust the sampling rate. Note that L should always be provided in this case, as it assumes that L is the true underlying length of the continuous signal + verbose=False, + fast_gate=False, + diag_tilt=0.0, + rank_weight=1.0, + measure_args={}, + **kernel_args, + ): + super().__init__() + self.N = N + self.H = H + assert not ( + resample and L is None + ), "Cannot have sampling rate adjustment and no base length passed in" + self.precision = precision + dtype = torch.double if self.precision == 2 else torch.float + cdtype = torch.cfloat if dtype == torch.float else torch.cdouble + self.rate = None if resample else 1.0 + self.channels = channels + self.n_ssm = n_ssm + + # Generate dt + log_dt = torch.rand(self.H, dtype=dtype) * ( + math.log(dt_max) - math.log(dt_min) + ) + math.log(dt_min) + + if fast_gate: + log_dt = torch.asinh(log_dt) + + # Compute the preprocessed representation + if mode == "real": # For testing and ablation purposes + # Generate A, B + A, B = hippo.transition(measure, self.N) + A = torch.as_tensor(A, dtype=dtype) + B = torch.as_tensor(B, dtype=dtype)[:, 0] + + # Generate C + C = torch.randn(channels, self.H, self.N, dtype=dtype) + + self.kernel = SSKernelSlow( + A, + B, + C, + log_dt, + L=L, + trainable=trainable, + lr=lr, + ) + else: + # Generate low rank correction p for the measure + if measure == "random": + w, P, B, C, _ = hippo.random_dplr( + self.N, rank=rank, H=n_ssm, dtype=dtype, **measure_args + ) + elif measure == "hippo": + w0, P0, B0, C0, _ = hippo.nplr("legs", self.N, rank, dtype=dtype) + w1, P1, B1, C1, _ = hippo.nplr("fourier", self.N, rank, dtype=dtype) + w = torch.stack([w0, w1], dim=0) + P = torch.stack([P0, P1], dim=1) + B = torch.stack([B0, B1], dim=0) + C = torch.stack([C0, C1], dim=0) + else: + w, P, B, C, _ = hippo.nplr(measure, self.N, rank, dtype=dtype) + w = w.unsqueeze(0) # (s N), s is num SSM copies + P = P.unsqueeze(1) # (r s N) + B = B.unsqueeze(0) # (s N) + C = C.unsqueeze(0) # (H N) + + # Handle extra options + w = w - diag_tilt + P = P * rank_weight + + # Broadcast C to have H channels + if deterministic: + C = repeat(C, "t n -> c (v t) n", c=channels, v=self.H // C.size(0)) + else: + C = torch.randn(channels, self.H, self.N // 2, dtype=cdtype) + + # Broadcast other parameters to have n_ssm copies + assert ( + self.n_ssm % B.size(-2) == 0 + and self.n_ssm % P.size(-2) == 0 + and self.n_ssm % w.size(-2) == 0 + ) + # Broadcast tensors to n_ssm copies + # These will be the parameters, so make sure tensors are materialized and contiguous + B = ( + repeat(B, "t n -> (v t) n", v=self.n_ssm // B.size(-2)) + .clone() + .contiguous() + ) + P = ( + repeat(P, "r t n -> r (v t) n", v=self.n_ssm // P.size(-2)) + .clone() + .contiguous() + ) + w = ( + repeat(w, "t n -> (v t) n", v=self.n_ssm // w.size(-2)) + .clone() + .contiguous() + ) + + if mode == "nplr": + self.kernel = SSKernelNPLR( + w, + P, + B, + C, + log_dt, + L=L, + trainable=trainable, + lr=lr, + lr_dt=lr_dt, + verbose=verbose, + fast_gate=fast_gate, + **kernel_args, + ) + elif mode == "diag": + C = C * repeat(B, "t n -> (v t) n", v=H // self.n_ssm) + self.kernel = SSKernelDiag( + w, + C, + log_dt, + L=L, + trainable=trainable, + lr=lr, + **kernel_args, + ) + elif mode == "slow": # Testing only + A = torch.diag_embed(_conj(w)) - contract( + "... r p, ... r q -> ... p q", _conj(P), _conj(P).conj() + ) + self.kernel = SSKernelSlow( + A, + _conj(B), + _conj(C), + log_dt, + L=L, + trainable=trainable, + lr=lr, + ) + else: + raise NotImplementedError(f"{mode=} is not valid") + + def forward(self, state=None, L=None): + k, k_state = self.kernel(state=state, rate=self.rate, L=L) + k_state = None if k_state is None else k_state.float() + return k.float(), k_state + + @torch.no_grad() + def forward_state(self, u, state): + """Forward the state through a sequence, i.e. computes the state after passing chunk through SSM + + state: (..., H, N) + u: (..., H, L) + + Returns: (..., H, N) + """ + + self.kernel._setup_state() + dA, dB = self.kernel.dA, self.kernel.dB # (H N N) (H N) + + conj = state.size(-1) != dA.size(-1) + if conj: + state = _conj(state) + + v = contract( + "h n, ... h l -> ... h n l", dB, u.flip(-1) + ) # dB.unsqueeze(-1) * u.flip(-1).unsqueeze(-2) + AL, v = power(u.size(-1), dA, v) + next_state = contract("... m n, ... n -> ... m", AL, state) + next_state = next_state + v + + if conj: + next_state = next_state[..., : next_state.size(-1) // 2] + return next_state + + def setup_step(self): + self.kernel.setup_step() + + def step(self, u, state, **kwargs): + u, state = self.kernel.step(u, state, **kwargs) + return u.float(), state + + def default_state(self, *args, **kwargs): + return self.kernel.default_state(*args, **kwargs) diff --git a/s4/krylov.py b/s4/krylov.py new file mode 100644 index 0000000..7575d84 --- /dev/null +++ b/s4/krylov.py @@ -0,0 +1,214 @@ +""" Compute a Krylov function efficiently. (S3 renames the Krylov function to a "state space kernel") + +A : (N, N) +b : (N,) +c : (N,) +Return: [c^T A^i b for i in [L]] +""" + + +import torch +import torch.nn.functional as F +from einops import rearrange + +from toeplitz import causal_convolution + + +def krylov_sequential(L, A, b, c=None): + """Constant matrix A + + A : (..., N, N) + b : (..., N) + c : (..., N) + + Returns + if c: + x : (..., L) + x[i, l] = c[i] @ A^l @ b[i] + + else: + x : (..., N, L) + x[i, l] = A^l @ b[i] + """ + + # Check which of dim b and c is smaller to save memory + if c is not None and c.numel() < b.numel(): + return krylov_sequential(L, A.transpose(-1, -2), c, b) + + b_ = b + x = [] + for _ in range(L): + if c is not None: + x_ = torch.sum( + c * b_, dim=-1 + ) # (...) # could be faster with matmul or einsum? + else: + x_ = b_ + x.append(x_) + b_ = (A @ b_.unsqueeze(-1)).squeeze(-1) + + x = torch.stack(x, dim=-1) + return x + + +def krylov(L, A, b, c=None, return_power=False): + """ + Compute the Krylov matrix (b, Ab, A^2b, ...) using the squaring trick. + + If return_power=True, return A^{L-1} as well + """ + # TODO There is an edge case if L=1 where output doesn't get broadcasted, which might be an issue if caller is expecting broadcasting semantics... can deal with it if it arises + + x = b.unsqueeze(-1) # (..., N, 1) + A_ = A + + AL = None + if return_power: + AL = torch.eye(A.shape[-1], dtype=A.dtype, device=A.device) + _L = L - 1 + + done = L == 1 + # loop invariant: _L represents how many indices left to compute + while not done: + if return_power: + if _L % 2 == 1: + AL = A_ @ AL + _L //= 2 + + # Save memory on last iteration + l = x.shape[-1] + if L - l <= l: + done = True + _x = x[..., : L - l] + else: + _x = x + + _x = A_ @ _x + x = torch.cat( + [x, _x], dim=-1 + ) # there might be a more efficient way of ordering axes + if not done: + A_ = A_ @ A_ + + assert x.shape[-1] == L + + if c is not None: + x = torch.einsum("...nl, ...n -> ...l", x, c) + x = x.contiguous() # WOW!! + if return_power: + return x, AL + else: + return x + + +def power(L, A, v=None): + """Compute A^L and the scan sum_i A^i v_i + + A: (..., N, N) + v: (..., N, L) + """ + + I = torch.eye(A.shape[-1]).to(A) # , dtype=A.dtype, device=A.device) + + powers = [A] + l = 1 + while True: + if L % 2 == 1: + I = powers[-1] @ I + L //= 2 + if L == 0: + break + l *= 2 + powers.append(powers[-1] @ powers[-1]) + + if v is None: + return I + + # Invariants: + # powers[-1] := A^l + # l := largest po2 at most L + + # Note that an alternative divide and conquer to compute the reduction is possible and can be embedded into the above loop without caching intermediate powers of A + # We do this reverse divide-and-conquer for efficiency reasons: + # 1) it involves fewer padding steps for non-po2 L + # 2) it involves more contiguous arrays + + # Take care of edge case for non-po2 arrays + # Note that this initial step is a no-op for the case of power of 2 (l == L) + k = v.size(-1) - l + v_ = powers.pop() @ v[..., l:] + v = v[..., :l] + v[..., :k] = v[..., :k] + v_ + + # Handle reduction for power of 2 + while v.size(-1) > 1: + v = rearrange(v, "... (z l) -> ... z l", z=2) + v = v[..., 0, :] + powers.pop() @ v[..., 1, :] + return I, v.squeeze(-1) + + +def krylov_toeplitz(L, A, b, c=None): + """Specializes to lower triangular Toeplitz matrix A represented by its diagonals + + A : (..., N) + b : (..., N) + c : (..., N) + + Returns + x : (..., N, L) + x[i, l] = A^l @ b[i] + """ + x = b.unsqueeze(0) # (1, ..., N) + A_ = A + while x.shape[0] < L: + xx = causal_convolution(A_, x) + x = torch.cat( + [x, xx], dim=0 + ) # there might be a more efficient way of ordering axes + A_ = causal_convolution(A_, A_) + x = x[:L, ...] # (L, ..., N) + if c is not None: + x = torch.einsum("l...n, ...n -> ...l", x, c) + else: + x = rearrange(x, "l ... n -> ... n l") + x = x.contiguous() + return x + + +def krylov_toeplitz_(L, A, b, c=None): + """Padded version of krylov_toeplitz that saves some fft's + + TODO currently not faster than original version, not sure why + """ + N = A.shape[-1] + + x = b.unsqueeze(0) # (1, ..., N) + x = F.pad(x, (0, N)) + A = F.pad(A, (0, N)) + done = L == 1 + while not done: + l = x.shape[0] + # Save memory on last iteration + if L - l <= l: + done = True + _x = x[: L - l] + else: + _x = x + Af = torch.fft.rfft(A, n=2 * N, dim=-1) + xf = torch.fft.rfft(_x, n=2 * N, dim=-1) + xf_ = Af * xf + x_ = torch.fft.irfft(xf_, n=2 * N, dim=-1) + x_[..., N:] = 0 + x = torch.cat( + [x, x_], dim=0 + ) # there might be a more efficient way of ordering axes + if not done: + A = torch.fft.irfft(Af * Af, n=2 * N, dim=-1) + A[..., N:] = 0 + x = x[:L, ..., :N] # (L, ..., N) + if c is not None: + x = torch.einsum("l...n, ...n -> ...l", x, c) + else: + x = rearrange(x, "l ... n -> ... n l") + x = x.contiguous() + return x diff --git a/s4/logger.py b/s4/logger.py new file mode 100644 index 0000000..12eae43 --- /dev/null +++ b/s4/logger.py @@ -0,0 +1,25 @@ +import logging + +from pytorch_lightning.utilities import rank_zero_only + + +def get_logger(name=__name__, level=logging.INFO) -> logging.Logger: + """Initializes multi-GPU-friendly python logger.""" + + logger = logging.getLogger(name) + logger.setLevel(level) + + # this ensures all logging levels get marked with the rank zero decorator + # otherwise logs would get multiplied for each GPU process in multi-GPU setup + for level in ( + "debug", + "info", + "warning", + "error", + "exception", + "fatal", + "critical", + ): + setattr(logger, level, rank_zero_only(getattr(logger, level))) + + return logger diff --git a/s4/pykeops_cauchy.py b/s4/pykeops_cauchy.py new file mode 100644 index 0000000..5984a38 --- /dev/null +++ b/s4/pykeops_cauchy.py @@ -0,0 +1,237 @@ +""" pykeops implementations of the core Cauchy kernel used in the S3 algorithm. +""" + + +import torch +from einops import rearrange +from pykeops.torch import Genred, LazyTensor + + +_conj = lambda x: torch.cat([x, x.conj()], dim=-1) + + +def _broadcast_dims(*tensors): + max_dim = max([len(tensor.shape) for tensor in tensors]) + tensors = [ + tensor.view((1,) * (max_dim - len(tensor.shape)) + tensor.shape) + for tensor in tensors + ] + return tensors + + +def _c2r(x): + return torch.view_as_real(x) + + +def _r2c(x): + return torch.view_as_complex(x) + + +def cauchy_slow(v, z, w, conj=True): + """ + v: (..., N) + z: (..., L) + w: (..., N) + returns: (..., L) \sum v/(z-w) + """ + if conj: + v = _conj(v) + w = _conj(w) + cauchy_matrix = v.unsqueeze(-1) / (z.unsqueeze(-2) - w.unsqueeze(-1)) # (... N L) + return torch.sum(cauchy_matrix, dim=-2) + + +def cauchy_lazy(v, z, w, conj=True): + if conj: + v = _conj(v) + w = _conj(w) + v, z, w = _broadcast_dims(v, z, w) + v_l = LazyTensor(rearrange(v, "... N -> ... N 1 1")) + w_l = LazyTensor(rearrange(w, "... N -> ... N 1 1")) + z_l = LazyTensor(rearrange(z, "... L -> ... 1 L 1")) + sub = z_l - w_l # (b N L 1), for some reason it doesn't display the last dimension + div = v_l / sub + s = div.sum(dim=len(v_l.shape) - 2) + return s.squeeze(-1) + + +def cauchy(v, z, w, conj=False): + expr = "ComplexDivide(v, z-w)" + cauchy_mult = Genred( + expr, + [ + "v = Vj(2)", + "z = Vi(2)", + "w = Vj(2)", + ], + reduction_op="Sum", + axis=1, + ) + + if conj: + v = _conj(v) + w = _conj(w) + v, z, w = _broadcast_dims(v, z, w) + v = _c2r(v) + z = _c2r(z) + w = _c2r(w) + + r = cauchy_mult(v, z, w, backend="GPU") + return _r2c(r) + + +def cauchy_real(v, z, w): + expr = "v / (z - w)" + cauchy_mult = Genred( + expr, + [ + "v = Vj(1)", + "z = Vi(1)", + "w = Vj(1)", + ], + reduction_op="Sum", + axis=1, + ) + v, z, w = _broadcast_dims(v, z, w) + v = v.unsqueeze(-1) + z = z.unsqueeze(-1) + w = w.unsqueeze(-1) + + r = cauchy_mult(v, z, w, backend="GPU") + return r + + +def cauchy_conj(v, z, w, num=2, denom=2): + if num == 1: + expr_num = "z * ComplexReal(v) - Real2Complex(ComplexReal(v)*ComplexReal(w) + ComplexImag(v)*ComplexImag(w))" + elif num == 2: + expr_num = "z * ComplexReal(v) - Real2Complex(Sum(v * w))" + else: + raise NotImplementedError + + if denom == 1: + expr_denom = "ComplexMult(z-Real2Complex(ComplexReal(w)), z-Real2Complex(ComplexReal(w))) + Real2Complex(Square(ComplexImag(w)))" + elif denom == 2: + expr_denom = "ComplexMult(z-w, z-Conj(w))" + else: + raise NotImplementedError + + cauchy_mult = Genred( + f"ComplexDivide({expr_num}, {expr_denom})", + [ + "v = Vj(2)", + "z = Vi(2)", + "w = Vj(2)", + ], + reduction_op="Sum", + axis=1, + ) + + v, z, w = _broadcast_dims(v, z, w) + v = _c2r(v) + z = _c2r(z) + w = _c2r(w) + + r = 2 * cauchy_mult(v, z, w, backend="GPU") + return _r2c(r) + + +def cauchy_conj_components(v, z, w): + """Assumes z is pure imaginary (as in S4 with bilinear)""" + + expr_num = "Imag2Complex(zi*vr) - Real2Complex(vr*wr + vi*wi)" + expr_denom = ( + "Real2Complex(Square(wr)+Square(wi)-Square(zi)) - Imag2Complex(IntCst(2)*zi*wr)" + ) + cauchy_mult = Genred( + f"ComplexDivide({expr_num}, {expr_denom})", + [ + "vr = Vj(1)", + "vi = Vj(1)", + "wr = Vj(1)", + "wi = Vj(1)", + "zi = Vi(1)", + ], + reduction_op="Sum", + axis=1, + ) + + v, z, w = _broadcast_dims(v, z, w) + v = v.unsqueeze(-1) + z = z.unsqueeze(-1) + w = w.unsqueeze(-1) + + v_r, v_i = v.real.contiguous(), v.imag.contiguous() + w_r, w_i = w.real.contiguous(), w.imag.contiguous() + z_i = z.imag.contiguous() + + r = 2 * cauchy_mult(v_r, v_i, w_r, w_i, z_i, backend="GPU") + return _r2c(r) + + +def cauchy_conj_components_lazy(v, z, w, type=1): + v, z, w = _broadcast_dims(v, z, w) + + v_r, v_i = v.real.contiguous(), v.imag.contiguous() + w_r, w_i = w.real.contiguous(), w.imag.contiguous() + z_i = z.imag.contiguous() + + v_r = LazyTensor(rearrange(v_r, "... N -> ... 1 N 1")) + v_i = LazyTensor(rearrange(v_i, "... N -> ... 1 N 1")) + w_r = LazyTensor(rearrange(w_r, "... N -> ... 1 N 1")) + w_i = LazyTensor(rearrange(w_i, "... N -> ... 1 N 1")) + z_i = LazyTensor(rearrange(z_i, "... L -> ... L 1 1")) + + if type == 1: + num = -v_r * w_r - v_i * w_i + 1j * z_i * v_r + denom = w_r**2 + w_i**2 - z_i**2 - 2j * w_r * z_i + else: + # z = torch.complex(-w_r, z_i) # Not supported + z = -w_r + 1j * z_i + num = v_r * z - v_i * w_i + denom = z * z + w_i**2 # z**2 is bugged for complex + + r = num / denom + r = 2 * r.sum(dim=len(z_i.shape) - 1) + return r.squeeze(-1) + + +def cauchy_conj2(v, z, w): + expr = "ComplexDivide(v, z-w) + ComplexDivide(Conj(v), z-Conj(w))" + # expr = 'ComplexDivide(v, z-w)' + cauchy_mult = Genred( + expr, + [ + "v = Vj(2)", + "z = Vi(2)", + "w = Vj(2)", + ], + reduction_op="Sum", + axis=1, + ) + + v, z, w = _broadcast_dims(v, z, w) + if complex: + v = _c2r(v) + z = _c2r(z) + w = _c2r(w) + + r = cauchy_mult(v, z, w, backend="GPU") + return _r2c(r) + + +def trigger_compilation(): + """Small function to trigger the compilation of a pykeops kernel + + Used in scenarios where we must manually control compilation, e.g. the multi-gpu case (https://github.com/getkeops/keops/issues/168)""" + B = 2 + N = 4 + L = 16 + + w = torch.randn(B, N // 2, dtype=torch.cfloat, device="cuda") + v = torch.randn(B, N // 2, dtype=torch.cfloat, device="cuda") + z = torch.randn(B, L, dtype=torch.cfloat, device="cuda") + w.requires_grad = True + v.requires_grad = True + + cauchy_conj(v, z, w) diff --git a/s4/s4.ipynb b/s4/s4.ipynb new file mode 100644 index 0000000..c4bd5c0 --- /dev/null +++ b/s4/s4.ipynb @@ -0,0 +1,1438 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "c4c1a6b2", + "metadata": {}, + "outputs": [], + "source": [ + "# !pip install -U gluonts pytorch-lightning torch" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f61debcc", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "64e16862", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/.env/pytorch/lib/python3.8/site-packages/apex/pyprof/__init__.py:5: FutureWarning: pyprof will be removed by the end of June, 2022\n", + " warnings.warn(\"pyprof will be removed by the end of June, 2022\", FutureWarning)\n", + "WARNING:root:Pytorch pre-release version 1.12.0a0+git31d03c2 - assuming intent to test it\n" + ] + } + ], + "source": [ + "from typing import List, Optional, Iterable, Dict, Any, Tuple\n", + "from itertools import islice\n", + "import queue\n", + "\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "import tqdm.auto as tqdm\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.utils.data import DataLoader\n", + "from torch.optim.lr_scheduler import _LRScheduler, MultiplicativeLR\n", + "from torch.optim import Optimizer\n", + "\n", + "import pytorch_lightning as pl\n", + "from pytorch_lightning.loggers import CSVLogger\n", + "\n", + "from gluonts.core.component import validated\n", + "from gluonts.dataset.common import Dataset\n", + "from gluonts.dataset.field_names import FieldName\n", + "from gluonts.itertools import Cyclic, PseudoShuffled, IterableSlice\n", + "from gluonts.time_feature import (\n", + " TimeFeature,\n", + " time_features_from_frequency_str,\n", + ")\n", + "from gluonts.torch.modules.loss import DistributionLoss, NegativeLogLikelihood\n", + "from gluonts.transform import (\n", + " Transformation,\n", + " Chain,\n", + " RemoveFields,\n", + " SetField,\n", + " AsNumpyArray,\n", + " AddObservedValuesIndicator,\n", + " AddTimeFeatures,\n", + " AddAgeFeature,\n", + " VstackFeatures,\n", + " InstanceSplitter,\n", + " ValidationSplitSampler,\n", + " TestSplitSampler,\n", + " ExpectedNumInstanceSampler,\n", + " SelectFields,\n", + ")\n", + "from gluonts.torch.util import (\n", + " IterableDataset,\n", + ")\n", + "from gluonts.evaluation import make_evaluation_predictions, Evaluator\n", + "from gluonts.torch.model.estimator import PyTorchLightningEstimator\n", + "from gluonts.torch.model.predictor import PyTorchPredictor\n", + "from gluonts.torch.distributions.distribution_output import (\n", + " DistributionOutput,\n", + " StudentTOutput,\n", + ")\n", + "from gluonts.torch.util import weighted_average\n", + "from gluonts.torch.modules.scaler import MeanScaler, NOPScaler\n", + "from gluonts.torch.modules.feature import FeatureEmbedder\n", + "from gluonts.time_feature import get_lags_for_frequency\n", + "from gluonts.dataset.repository.datasets import get_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c1fbb026", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:kernel:CUDA extension for cauchy multiplication found.\n", + "INFO:kernel:Pykeops installation found.\n" + ] + } + ], + "source": [ + "from s4 import S4" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6ddc78b9", + "metadata": {}, + "outputs": [], + "source": [ + "class S4Model(nn.Module):\n", + " def __init__(\n", + " self,\n", + " freq: str,\n", + " \n", + " context_length: int,\n", + " prediction_length: int,\n", + " \n", + " num_feat_dynamic_real: int,\n", + " num_feat_static_real: int,\n", + " \n", + " num_feat_static_cat: int,\n", + " cardinality: List[int],\n", + " embedding_dimension: Optional[List[int]] = None,\n", + " \n", + " input_size: int = 1, # univariate input\n", + " \n", + " # S4 inputs\n", + " d_state: int = 64,\n", + " nhead: int = 1, # channels: can be interpreted as a number of \"heads\"\n", + " num_layers: int = 1, # Number of layers\n", + " dropout_rate: float = 0.2,\n", + " prenorm: bool = False, # Prenorm\n", + " activation: str = \"gelu\", # activation in between SS and FF\n", + " postact: str = \"glu\", # activation after FF\n", + " measure: str = \"fourier\",\n", + " trainable: Optional[Dict[str, bool]] = None,\n", + " \n", + " distr_output: DistributionOutput = StudentTOutput(),\n", + " lags_seq: Optional[List[int]] = None,\n", + " scaling: bool = True,\n", + " num_parallel_samples: int = 100,\n", + " ) -> None:\n", + " super().__init__()\n", + " self.context_length = context_length\n", + " self.prediction_length = prediction_length\n", + " self.distr_output = distr_output\n", + " self.target_shape = distr_output.event_shape\n", + " self.num_feat_dynamic_real = num_feat_dynamic_real\n", + " self.num_feat_static_cat = num_feat_static_cat\n", + " self.num_feat_static_real = num_feat_static_real\n", + " self.embedding_dimension = (\n", + " embedding_dimension\n", + " if embedding_dimension is not None or cardinality is None\n", + " else [min(50, (cat + 1) // 2) for cat in cardinality]\n", + " )\n", + " self.lags_seq = lags_seq or get_lags_for_frequency(freq_str=freq)\n", + " self.num_parallel_samples = num_parallel_samples\n", + " \n", + " self.embedder = FeatureEmbedder(\n", + " cardinalities=cardinality,\n", + " embedding_dims=self.embedding_dimension,\n", + " )\n", + " if scaling:\n", + " self.scaler = MeanScaler(dim=1, keepdim=True)\n", + " else:\n", + " self.scaler = NOPScaler(dim=1, keepdim=True)\n", + " \n", + " self.lagged_s4 = LaggedS4(\n", + " input_size=input_size,\n", + " features_size=self._number_of_features,\n", + " lags_seq=[lag - 1 for lag in self.lags_seq],\n", + " \n", + " # S4 inputs\n", + " d_state=d_state,\n", + " channels=nhead,\n", + " prenorm=prenorm,\n", + " activation=activation,\n", + " postact=postact,\n", + " num_layers=num_layers,\n", + " dropout=dropout_rate,\n", + " #l_max=self._past_length + self.prediction_length,\n", + " measure=measure,\n", + " trainable=trainable,\n", + " )\n", + " \n", + " self.param_proj = distr_output.get_args_proj(input_size*len(self.lags_seq) + self._number_of_features)\n", + "\n", + "\n", + " @property\n", + " def _number_of_features(self) -> int:\n", + " return (\n", + " sum(self.embedding_dimension)\n", + " + self.num_feat_dynamic_real\n", + " + self.num_feat_static_real\n", + " + 1 # the log(scale)\n", + " )\n", + " \n", + " @property\n", + " def _past_length(self) -> int:\n", + " return self.context_length + max(self.lags_seq)\n", + "\n", + " def unroll_lagged_s4(\n", + " self,\n", + " feat_static_cat: torch.Tensor,\n", + " feat_static_real: torch.Tensor,\n", + " past_time_feat: torch.Tensor,\n", + " past_target: torch.Tensor,\n", + " past_observed_values: torch.Tensor,\n", + " future_time_feat: Optional[torch.Tensor] = None,\n", + " future_target: Optional[torch.Tensor] = None,\n", + " state: Optional[torch.Tensor] = None,\n", + " ) -> Tuple[\n", + " Tuple[torch.Tensor, ...],\n", + " torch.Tensor,\n", + " torch.Tensor,\n", + " torch.Tensor,\n", + " Tuple[torch.Tensor, torch.Tensor],\n", + " ]:\n", + " context = past_target[:, -self.context_length :]\n", + " observed_context = past_observed_values[:, -self.context_length :]\n", + " _, scale = self.scaler(context, observed_context)\n", + "\n", + " prior_input = past_target[:, : -self.context_length] / scale\n", + " inputs = (\n", + " torch.cat((context, future_target[:, :-1]), dim=1) / scale\n", + " if future_target is not None\n", + " else context / scale\n", + " )\n", + "\n", + " unroll_length = (\n", + " self.context_length\n", + " if future_target is None\n", + " else self.context_length + future_target.shape[1] - 1\n", + " )\n", + " assert inputs.shape[1] == unroll_length\n", + "\n", + " embedded_cat = self.embedder(feat_static_cat)\n", + " static_feat = torch.cat(\n", + " (embedded_cat, feat_static_real, scale.log()),\n", + " dim=1,\n", + " )\n", + " expanded_static_feat = static_feat.unsqueeze(1).expand(\n", + " -1, unroll_length, -1\n", + " )\n", + "\n", + " time_feat = (\n", + " torch.cat(\n", + " (\n", + " past_time_feat[:, -self.context_length + 1 :, ...],\n", + " future_time_feat,\n", + " ),\n", + " dim=1,\n", + " )\n", + " if future_time_feat is not None\n", + " else past_time_feat[:, -self.context_length + 1 :, ...]\n", + " )\n", + "\n", + " features = torch.cat((expanded_static_feat, time_feat), dim=-1)\n", + "\n", + " output, new_state = self.lagged_s4(prior_input, inputs, features, state)\n", + "\n", + " params = self.param_proj(output)\n", + " return params, scale, output, static_feat, new_state\n", + "\n", + " @torch.jit.ignore\n", + " def output_distribution(\n", + " self, params, scale=None, trailing_n=None\n", + " ) -> torch.distributions.Distribution:\n", + " sliced_params = params\n", + " if trailing_n is not None:\n", + " sliced_params = [p[:, -trailing_n:] for p in params]\n", + " return self.distr_output.distribution(sliced_params, scale=scale)\n", + "\n", + " # prediction\n", + " def forward(\n", + " self,\n", + " feat_static_cat: torch.Tensor,\n", + " feat_static_real: torch.Tensor,\n", + " past_time_feat: torch.Tensor,\n", + " past_target: torch.Tensor,\n", + " past_observed_values: torch.Tensor,\n", + " future_time_feat: torch.Tensor,\n", + " num_parallel_samples: Optional[int] = None,\n", + " ) -> torch.Tensor:\n", + " if num_parallel_samples is None:\n", + " num_parallel_samples = self.num_parallel_samples\n", + " \n", + " for layer in self.lagged_s4.s4_layers:\n", + " layer.kernel.kernel.setup_step()\n", + " default_state = layer.kernel.default_state(*past_target.shape[:1])\n", + " \n", + " params, scale, _, static_feat, state = self.unroll_lagged_s4(\n", + " feat_static_cat,\n", + " feat_static_real,\n", + " past_time_feat,\n", + " past_target,\n", + " past_observed_values,\n", + " future_time_feat[:, :1],\n", + " state=default_state,\n", + " )\n", + "\n", + " repeated_scale = scale.repeat_interleave(\n", + " repeats=num_parallel_samples, dim=0\n", + " )\n", + " \n", + " repeated_static_feat = static_feat.repeat_interleave(\n", + " repeats=num_parallel_samples, dim=0\n", + " ).unsqueeze(dim=1)\n", + " \n", + " repeated_past_target = (\n", + " past_target.repeat_interleave(\n", + " repeats=num_parallel_samples, dim=0\n", + " )\n", + " / repeated_scale\n", + " )\n", + " \n", + " repeated_time_feat = future_time_feat.repeat_interleave(\n", + " repeats=num_parallel_samples, dim=0\n", + " )\n", + " \n", + " repeated_state = state.repeat_interleave(repeats=num_parallel_samples, dim=0)\n", + " \n", + " repeated_params = [\n", + " s.repeat_interleave(repeats=num_parallel_samples, dim=0)\n", + " for s in params\n", + " ]\n", + " \n", + " distr = self.output_distribution(\n", + " repeated_params, trailing_n=1, scale=repeated_scale\n", + " )\n", + " next_sample = distr.sample()\n", + " future_samples = [next_sample]\n", + " \n", + " for k in range(1, self.prediction_length):\n", + " scaled_next_sample = next_sample / repeated_scale\n", + " next_features = torch.cat(\n", + " (repeated_static_feat, repeated_time_feat[:, k : k + 1]),\n", + " dim=-1,\n", + " )\n", + "\n", + " output, repeated_state = self.lagged_s4(\n", + " repeated_past_target,\n", + " scaled_next_sample,\n", + " next_features,\n", + " repeated_state,\n", + " step=True,\n", + " )\n", + "\n", + " repeated_past_target = torch.cat(\n", + " (repeated_past_target, scaled_next_sample), dim=1\n", + " )\n", + "\n", + " params = self.param_proj(output)\n", + " \n", + " # hack: sometimes the params ie. output has nans\n", + " # replace nans with means of the params...\n", + " # params = [p.nan_to_num(nan=p.nanmean(0).item()) for p in params]\n", + " \n", + " distr = self.output_distribution(params, scale=repeated_scale)\n", + " next_sample = distr.sample()\n", + " future_samples.append(next_sample)\n", + "\n", + " future_samples_concat = torch.cat(future_samples, dim=1)\n", + "\n", + " return future_samples_concat.reshape(\n", + " (-1, self.num_parallel_samples, self.prediction_length)\n", + " + self.target_shape,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "725eb743", + "metadata": {}, + "outputs": [], + "source": [ + "class LaggedS4(nn.Module):\n", + " def __init__(\n", + " self,\n", + " input_size: int,\n", + " features_size: int,\n", + " lags_seq: List[int],\n", + " \n", + " #s4 inputs\n", + " d_state: int = 64,\n", + " channels: int = 1, # channels: can be interpreted as a number of \"heads\"\n", + " num_layers: int = 1, # Number of layers\n", + " l_max: int = 1, # max length or 1\n", + " dropout: float = 0.2,\n", + " prenorm: bool = False, # Prenorm flag\n", + " activation: str = \"gelu\", # activation in between SS and FF\n", + " postact: str = \"glu\", # activation after FF\n", + " measure: str = \"fourier\",\n", + " trainable: Optional[Dict[str, bool]] = None,\n", + " ) -> None:\n", + " super().__init__()\n", + " self.input_size = input_size\n", + " self.features_size = features_size\n", + " self.lags_seq = lags_seq\n", + " \n", + " d_model = input_size * len(self.lags_seq) + features_size\n", + " self.prenorm = prenorm\n", + " \n", + " self.s4_layers = nn.ModuleList()\n", + " self.norms = nn.ModuleList()\n", + " self.dropouts = nn.ModuleList()\n", + " for _ in range(num_layers):\n", + " self.s4_layers.append(\n", + " S4(\n", + " d_model=d_model,\n", + " d_state=d_state,\n", + " l_max=l_max,\n", + " channels=channels,\n", + " activation=activation,\n", + " dropout=dropout,\n", + " transposed=False, #[B, T, F]\n", + " postact=postact,\n", + " measure=measure,\n", + " trainable=trainable,\n", + " )\n", + " )\n", + " self.norms.append(nn.LayerNorm(d_model))\n", + " self.dropouts.append(nn.Dropout2d(dropout))\n", + "\n", + " def get_lagged_subsequences(\n", + " self,\n", + " sequence: torch.Tensor,\n", + " subsequences_length: int,\n", + " ) -> torch.Tensor:\n", + " \"\"\"\n", + " Returns lagged subsequences of a given sequence.\n", + " Parameters\n", + " ----------\n", + " sequence : Tensor\n", + " the sequence from which lagged subsequences should be extracted.\n", + " Shape: (N, T, C).\n", + " subsequences_length : int\n", + " length of the subsequences to be extracted.\n", + " Returns\n", + " --------\n", + " lagged : Tensor\n", + " a tensor of shape (N, S, C, I), where S = subsequences_length and\n", + " I = len(indices), containing lagged subsequences. Specifically,\n", + " lagged[i, j, :, k] = sequence[i, -indices[k]-S+j, :].\n", + " \"\"\"\n", + " sequence_length = sequence.shape[1]\n", + " indices = self.lags_seq\n", + "\n", + " assert max(indices) + subsequences_length <= sequence_length, (\n", + " f\"lags cannot go further than history length, found lag {max(indices)} \"\n", + " f\"while history length is only {sequence_length}\"\n", + " )\n", + "\n", + " lagged_values = []\n", + " for lag_index in indices:\n", + " begin_index = -lag_index - subsequences_length\n", + " end_index = -lag_index if lag_index > 0 else None\n", + " lagged_values.append(sequence[:, begin_index:end_index, ...])\n", + " return torch.stack(lagged_values, dim=-1)\n", + "\n", + " def _check_shapes(\n", + " self,\n", + " prior_input: torch.Tensor,\n", + " input: torch.Tensor,\n", + " features: Optional[torch.Tensor],\n", + " ) -> None:\n", + " assert len(prior_input.shape) == len(input.shape)\n", + " assert (\n", + " len(prior_input.shape) == 2 and self.input_size == 1\n", + " ) or prior_input.shape[2] == self.input_size\n", + " assert (len(input.shape) == 2 and self.input_size == 1) or input.shape[\n", + " -1\n", + " ] == self.input_size\n", + " assert (\n", + " features is None or features.shape[2] == self.features_size\n", + " ), f\"{features.shape[2]}, expected {self.features_size}\"\n", + "\n", + " def forward(\n", + " self,\n", + " prior_input: torch.Tensor,\n", + " inputs: torch.Tensor,\n", + " features: Optional[torch.Tensor] = None,\n", + " state: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,\n", + " step: bool = False,\n", + " ) -> Tuple[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:\n", + " self._check_shapes(prior_input, inputs, features)\n", + "\n", + " sequence = torch.cat((prior_input, inputs), dim=1)\n", + " lagged_sequence = self.get_lagged_subsequences(\n", + " sequence=sequence,\n", + " subsequences_length=inputs.shape[1],\n", + " )\n", + "\n", + " lags_shape = lagged_sequence.shape\n", + " reshaped_lagged_sequence = lagged_sequence.reshape(\n", + " lags_shape[0], lags_shape[1], -1\n", + " )\n", + "\n", + " if features is None:\n", + " s4_input = reshaped_lagged_sequence\n", + " else:\n", + " s4_input = torch.cat((reshaped_lagged_sequence, features), dim=-1)\n", + "\n", + " x = s4_input\n", + " for layer, norm, dropout in zip(self.s4_layers, self.norms, self.dropouts):\n", + " z = x\n", + " if self.prenorm:\n", + " # Prenorm\n", + " z = norm(z)\n", + " \n", + " if step:\n", + " z, state = layer.step(z.squeeze(), state)\n", + " z = z.unsqueeze(1)\n", + " else:\n", + " # Apply S4 block\n", + " z, state = layer(z, state)\n", + " \n", + " # Dropout on the output of the S4 block\n", + " z = dropout(z)\n", + "\n", + " # Residual connection\n", + " x = z + x\n", + "\n", + " if not self.prenorm:\n", + " # Postnorm\n", + " x = norm(x)\n", + "\n", + " return x, state" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d16da5e8", + "metadata": {}, + "outputs": [], + "source": [ + "class S4LightningModule(pl.LightningModule):\n", + " def __init__(\n", + " self,\n", + " model: S4Model,\n", + " loss: DistributionLoss = NegativeLogLikelihood(),\n", + " lr: float = 1e-3,\n", + " weight_decay: float = 1e-8,\n", + " ) -> None:\n", + " super().__init__()\n", + " self.save_hyperparameters()\n", + " self.model = model\n", + " self.loss = loss\n", + " self.lr = lr\n", + " self.weight_decay = weight_decay\n", + "\n", + " def _compute_loss(self, batch):\n", + " feat_static_cat = batch[\"feat_static_cat\"]\n", + " feat_static_real = batch[\"feat_static_real\"]\n", + " past_time_feat = batch[\"past_time_feat\"]\n", + " past_target = batch[\"past_target\"]\n", + " future_time_feat = batch[\"future_time_feat\"]\n", + " future_target = batch[\"future_target\"]\n", + " past_observed_values = batch[\"past_observed_values\"]\n", + " future_observed_values = batch[\"future_observed_values\"]\n", + "\n", + " params, scale, _, _, _ = self.model.unroll_lagged_s4(\n", + " feat_static_cat,\n", + " feat_static_real,\n", + " past_time_feat,\n", + " past_target,\n", + " past_observed_values,\n", + " future_time_feat,\n", + " future_target,\n", + " )\n", + " distr = self.model.output_distribution(params, scale)\n", + "\n", + " context_target = past_target[:, -self.model.context_length + 1 :]\n", + " target = torch.cat(\n", + " (context_target, future_target),\n", + " dim=1,\n", + " )\n", + " loss_values = self.loss(distr, target)\n", + "\n", + " context_observed = past_observed_values[\n", + " :, -self.model.context_length + 1 :\n", + " ]\n", + " observed_values = torch.cat(\n", + " (context_observed, future_observed_values), dim=1\n", + " )\n", + "\n", + " if len(self.model.target_shape) == 0:\n", + " loss_weights = observed_values\n", + " else:\n", + " loss_weights, _ = observed_values.min(dim=-1, keepdim=False)\n", + "\n", + " return weighted_average(loss_values, weights=loss_weights)\n", + "\n", + " def training_step(self, batch, batch_idx: int): # type: ignore\n", + " \"\"\"Execute training step\"\"\"\n", + " train_loss = self._compute_loss(batch)\n", + " self.log(\n", + " \"train_loss\",\n", + " train_loss,\n", + " on_epoch=True,\n", + " on_step=False,\n", + " prog_bar=True,\n", + " )\n", + " return train_loss\n", + "\n", + " def validation_step(self, batch, batch_idx: int): # type: ignore\n", + " \"\"\"Execute validation step\"\"\"\n", + " val_loss = self._compute_loss(batch)\n", + " self.log(\n", + " \"val_loss\", val_loss, on_epoch=True, on_step=False, prog_bar=True\n", + " )\n", + " return val_loss\n", + "\n", + " def configure_optimizers(self):\n", + " \"\"\"Returns the optimizer to use\"\"\"\n", + " return torch.optim.Adam(\n", + " self.model.parameters(),\n", + " lr=self.lr,\n", + " weight_decay=self.weight_decay,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8247e81d", + "metadata": {}, + "outputs": [], + "source": [ + "PREDICTION_INPUT_NAMES = [\n", + " \"feat_static_cat\",\n", + " \"feat_static_real\",\n", + " \"past_time_feat\",\n", + " \"past_target\",\n", + " \"past_observed_values\",\n", + " \"future_time_feat\",\n", + "]\n", + "\n", + "TRAINING_INPUT_NAMES = PREDICTION_INPUT_NAMES + [\n", + " \"future_target\",\n", + " \"future_observed_values\",\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "71ee8e4a", + "metadata": {}, + "outputs": [], + "source": [ + "class S4Estimator(PyTorchLightningEstimator):\n", + " def __init__(\n", + " self,\n", + " freq: str,\n", + " prediction_length: int,\n", + " context_length: Optional[int] = None,\n", + "\n", + " d_state: int = 64,\n", + " num_layers: int = 2,\n", + " nhead: int = 2,\n", + " prenorm: bool = False,\n", + " activation: str = \"gelu\",\n", + " postact: str = \"glu\",\n", + " dropout_rate: float = 0.1,\n", + " measure: str = \"fourier\",\n", + " trainable: Optional[Dict[str, bool]] = None,\n", + " \n", + " num_feat_dynamic_real: int = 0,\n", + " num_feat_static_cat: int = 0,\n", + " num_feat_static_real: int = 0,\n", + " cardinality: Optional[List[int]] = None,\n", + " embedding_dimension: Optional[List[int]] = None,\n", + " distr_output: DistributionOutput = StudentTOutput(),\n", + " loss: DistributionLoss = NegativeLogLikelihood(),\n", + " scaling: bool = True,\n", + " lags_seq: Optional[List[int]] = None,\n", + " time_features: Optional[List[TimeFeature]] = None,\n", + " num_parallel_samples: int = 100,\n", + " batch_size: int = 32,\n", + " num_batches_per_epoch: int = 50,\n", + " trainer_kwargs: Optional[Dict[str, Any]] = None,\n", + " ) -> None:\n", + " default_trainer_kwargs = {\n", + " \"max_epochs\": 100,\n", + " #\"gradient_clip_val\": 10.0,\n", + " }\n", + " if trainer_kwargs is not None:\n", + " default_trainer_kwargs.update(trainer_kwargs)\n", + " super().__init__(trainer_kwargs=default_trainer_kwargs)\n", + "\n", + " self.freq = freq\n", + " self.context_length = (\n", + " context_length if context_length is not None else prediction_length\n", + " )\n", + " self.prediction_length = prediction_length\n", + " self.distr_output = distr_output\n", + " self.loss = loss\n", + " \n", + " self.d_state = d_state\n", + " self.num_layers = num_layers\n", + " self.nhead = nhead\n", + " self.activation = activation\n", + " self.prenorm = prenorm\n", + " self.postact = postact\n", + " self.measure = measure\n", + " self.trainable = trainable\n", + " \n", + " self.dropout_rate = dropout_rate\n", + " self.num_feat_dynamic_real = num_feat_dynamic_real\n", + " self.num_feat_static_cat = num_feat_static_cat\n", + " self.num_feat_static_real = num_feat_static_real\n", + " self.cardinality = (\n", + " cardinality if cardinality and num_feat_static_cat > 0 else [1]\n", + " )\n", + " self.embedding_dimension = embedding_dimension\n", + " self.scaling = scaling\n", + " self.lags_seq = lags_seq\n", + " self.time_features = (\n", + " time_features\n", + " if time_features is not None\n", + " else time_features_from_frequency_str(self.freq)\n", + " )\n", + "\n", + " self.num_parallel_samples = num_parallel_samples\n", + " self.batch_size = batch_size\n", + " self.num_batches_per_epoch = num_batches_per_epoch\n", + "\n", + " self.train_sampler = ExpectedNumInstanceSampler(\n", + " num_instances=1.0, min_future=prediction_length\n", + " )\n", + " self.validation_sampler = ValidationSplitSampler(\n", + " min_future=prediction_length\n", + " )\n", + "\n", + " def create_transformation(self) -> Transformation:\n", + " remove_field_names = []\n", + " if self.num_feat_static_real == 0:\n", + " remove_field_names.append(FieldName.FEAT_STATIC_REAL)\n", + " if self.num_feat_dynamic_real == 0:\n", + " remove_field_names.append(FieldName.FEAT_DYNAMIC_REAL)\n", + "\n", + " return Chain(\n", + " [RemoveFields(field_names=remove_field_names)]\n", + " + (\n", + " [SetField(output_field=FieldName.FEAT_STATIC_CAT, value=[0])]\n", + " if not self.num_feat_static_cat > 0\n", + " else []\n", + " )\n", + " + (\n", + " [\n", + " SetField(\n", + " output_field=FieldName.FEAT_STATIC_REAL, value=[0.0]\n", + " )\n", + " ]\n", + " if not self.num_feat_static_real > 0\n", + " else []\n", + " )\n", + " + [\n", + " AsNumpyArray(\n", + " field=FieldName.FEAT_STATIC_CAT,\n", + " expected_ndim=1,\n", + " dtype=int,\n", + " ),\n", + " AsNumpyArray(\n", + " field=FieldName.FEAT_STATIC_REAL,\n", + " expected_ndim=1,\n", + " ),\n", + " AsNumpyArray(\n", + " field=FieldName.TARGET,\n", + " # in the following line, we add 1 for the time dimension\n", + " expected_ndim=1 + len(self.distr_output.event_shape),\n", + " ),\n", + " AddObservedValuesIndicator(\n", + " target_field=FieldName.TARGET,\n", + " output_field=FieldName.OBSERVED_VALUES,\n", + " ),\n", + " AddTimeFeatures(\n", + " start_field=FieldName.START,\n", + " target_field=FieldName.TARGET,\n", + " output_field=FieldName.FEAT_TIME,\n", + " time_features=self.time_features,\n", + " pred_length=self.prediction_length,\n", + " ),\n", + " AddAgeFeature(\n", + " target_field=FieldName.TARGET,\n", + " output_field=FieldName.FEAT_AGE,\n", + " pred_length=self.prediction_length,\n", + " log_scale=True,\n", + " ),\n", + " VstackFeatures(\n", + " output_field=FieldName.FEAT_TIME,\n", + " input_fields=[FieldName.FEAT_TIME, FieldName.FEAT_AGE]\n", + " + (\n", + " [FieldName.FEAT_DYNAMIC_REAL]\n", + " if self.num_feat_dynamic_real > 0\n", + " else []\n", + " ),\n", + " ),\n", + " ]\n", + " )\n", + "\n", + " def _create_instance_splitter(\n", + " self, module: S4LightningModule, mode: str\n", + " ):\n", + " assert mode in [\"training\", \"validation\", \"test\"]\n", + "\n", + " instance_sampler = {\n", + " \"training\": self.train_sampler,\n", + " \"validation\": self.validation_sampler,\n", + " \"test\": TestSplitSampler(),\n", + " }[mode]\n", + "\n", + " return InstanceSplitter(\n", + " target_field=FieldName.TARGET,\n", + " is_pad_field=FieldName.IS_PAD,\n", + " start_field=FieldName.START,\n", + " forecast_start_field=FieldName.FORECAST_START,\n", + " instance_sampler=instance_sampler,\n", + " past_length=module.model._past_length,\n", + " future_length=self.prediction_length,\n", + " time_series_fields=[\n", + " FieldName.FEAT_TIME,\n", + " FieldName.OBSERVED_VALUES,\n", + " ],\n", + " dummy_value=self.distr_output.value_in_support,\n", + " )\n", + "\n", + " def create_training_data_loader(\n", + " self,\n", + " data: Dataset,\n", + " module: S4LightningModule,\n", + " shuffle_buffer_length: Optional[int] = None,\n", + " **kwargs,\n", + " ) -> Iterable:\n", + " transformation = self._create_instance_splitter(\n", + " module, \"training\"\n", + " ) + SelectFields(TRAINING_INPUT_NAMES)\n", + "\n", + " training_instances = transformation.apply(\n", + " Cyclic(data)\n", + " if shuffle_buffer_length is None\n", + " else PseudoShuffled(\n", + " Cyclic(data), shuffle_buffer_length=shuffle_buffer_length\n", + " )\n", + " )\n", + "\n", + " return IterableSlice(\n", + " iter(\n", + " DataLoader(\n", + " IterableDataset(training_instances),\n", + " batch_size=self.batch_size,\n", + " **kwargs,\n", + " )\n", + " ),\n", + " self.num_batches_per_epoch,\n", + " )\n", + "\n", + " def create_validation_data_loader(\n", + " self,\n", + " data: Dataset,\n", + " module: S4LightningModule,\n", + " **kwargs,\n", + " ) -> Iterable:\n", + " transformation = self._create_instance_splitter(\n", + " module, \"validation\"\n", + " ) + SelectFields(TRAINING_INPUT_NAMES)\n", + "\n", + " validation_instances = transformation.apply(data)\n", + "\n", + " return DataLoader(\n", + " IterableDataset(validation_instances),\n", + " batch_size=self.batch_size,\n", + " **kwargs,\n", + " )\n", + "\n", + " def create_lightning_module(self) -> S4LightningModule:\n", + " model = S4Model(\n", + " freq=self.freq,\n", + " context_length=self.context_length,\n", + " prediction_length=self.prediction_length,\n", + " num_feat_dynamic_real=(\n", + " 1 + self.num_feat_dynamic_real + len(self.time_features)\n", + " ),\n", + " num_feat_static_real=max(1, self.num_feat_static_real),\n", + " num_feat_static_cat=max(1, self.num_feat_static_cat),\n", + " cardinality=self.cardinality,\n", + " embedding_dimension=self.embedding_dimension,\n", + " \n", + " d_state=self.d_state,\n", + " num_layers=self.num_layers,\n", + " nhead=self.nhead,\n", + " activation=self.activation,\n", + " prenorm=self.prenorm,\n", + " postact=self.postact,\n", + " measure=self.measure,\n", + " trainable=self.trainable,\n", + " \n", + " distr_output=self.distr_output,\n", + " dropout_rate=self.dropout_rate,\n", + " lags_seq=self.lags_seq,\n", + " scaling=self.scaling,\n", + " num_parallel_samples=self.num_parallel_samples,\n", + " )\n", + "\n", + " return S4LightningModule(model=model, loss=self.loss)\n", + "\n", + " def create_predictor(\n", + " self,\n", + " transformation: Transformation,\n", + " module: S4LightningModule,\n", + " ) -> PyTorchPredictor:\n", + " prediction_splitter = self._create_instance_splitter(module, \"test\")\n", + "\n", + " return PyTorchPredictor(\n", + " input_transform=transformation + prediction_splitter,\n", + " input_names=PREDICTION_INPUT_NAMES,\n", + " prediction_net=module.model,\n", + " batch_size=self.batch_size,\n", + " freq=self.freq,\n", + " prediction_length=self.prediction_length,\n", + " device=torch.device(\n", + " \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + " ),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e4eda7ef", + "metadata": {}, + "outputs": [], + "source": [ + "dataset = get_dataset(\"electricity\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "63298518", + "metadata": {}, + "outputs": [], + "source": [ + "estimator = S4Estimator(\n", + " freq=dataset.metadata.freq,\n", + " prediction_length=dataset.metadata.prediction_length,\n", + " context_length=100*dataset.metadata.prediction_length,\n", + " measure=\"fourier\",\n", + " \n", + " nhead=1,\n", + " num_layers=3,\n", + " \n", + " batch_size=128,\n", + " num_batches_per_epoch=100,\n", + " trainer_kwargs=dict(max_epochs=10, gpus='1', precision=\"bf16\", logger=CSVLogger(\"logs\", name=\"transformer\")),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7a7d7d5b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/utilities/parsing.py:261: UserWarning: Attribute 'model' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['model'])`.\n", + " rank_zero_warn(\n", + "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/utilities/parsing.py:261: UserWarning: Attribute 'loss' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['loss'])`.\n", + " rank_zero_warn(\n", + "Using bfloat16 Automatic Mixed Precision (AMP)\n", + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/trainer/configuration_validator.py:133: UserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + " rank_zero_warn(\"You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\")\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | model | S4Model | 23.9 K\n", + "1 | loss | NegativeLogLikelihood | 0 \n", + "------------------------------------------------\n", + "23.9 K Trainable params\n", + "0 Non-trainable params\n", + "23.9 K Total params\n", + "0.096 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c6c2ba749fb54bbebe66fbb0fa34f501", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 0, global step 100: 'train_loss' reached 6.80268 (best 6.80268), saving model to 'logs/transformer/version_326/checkpoints/epoch=0-step=100.ckpt' as top 1\n", + "Epoch 1, global step 200: 'train_loss' reached 5.97724 (best 5.97724), saving model to 'logs/transformer/version_326/checkpoints/epoch=1-step=200.ckpt' as top 1\n", + "Epoch 2, global step 300: 'train_loss' reached 5.72596 (best 5.72596), saving model to 'logs/transformer/version_326/checkpoints/epoch=2-step=300.ckpt' as top 1\n", + "Epoch 3, global step 400: 'train_loss' reached 5.54821 (best 5.54821), saving model to 'logs/transformer/version_326/checkpoints/epoch=3-step=400.ckpt' as top 1\n", + "Epoch 4, global step 500: 'train_loss' reached 5.48996 (best 5.48996), saving model to 'logs/transformer/version_326/checkpoints/epoch=4-step=500.ckpt' as top 1\n", + "Epoch 5, global step 600: 'train_loss' reached 5.40020 (best 5.40020), saving model to 'logs/transformer/version_326/checkpoints/epoch=5-step=600.ckpt' as top 1\n", + "Epoch 6, global step 700: 'train_loss' reached 5.36667 (best 5.36667), saving model to 'logs/transformer/version_326/checkpoints/epoch=6-step=700.ckpt' as top 1\n", + "Epoch 7, global step 800: 'train_loss' reached 5.31321 (best 5.31321), saving model to 'logs/transformer/version_326/checkpoints/epoch=7-step=800.ckpt' as top 1\n", + "Epoch 8, global step 900: 'train_loss' reached 5.29075 (best 5.29075), saving model to 'logs/transformer/version_326/checkpoints/epoch=8-step=900.ckpt' as top 1\n", + "Epoch 9, global step 1000: 'train_loss' was not in top 1\n" + ] + } + ], + "source": [ + "predictor = estimator.train(\n", + " training_data=dataset.train,\n", + " num_workers=8,\n", + " shuffle_buffer_length=1024\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "81eae2c6", + "metadata": {}, + "outputs": [], + "source": [ + "forecast_it, ts_it = make_evaluation_predictions(\n", + " dataset=dataset.test,\n", + " predictor=predictor,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "eee452cd", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:326: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:331: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:330: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:365: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:406: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:360: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " assert self._freq_base is None or self._freq_base == start.freq.base, (\n", + "/mnt/scratch/kashif/pytorch-transformer-forecast/krylov.py:118: UserWarning: floor_divide is deprecated, and will be removed in a future version of pytorch. It currently rounds toward 0 (like the 'trunc' function NOT 'floor'). This results in incorrect rounding for negative values.\n", + "To keep the current behavior, use torch.div(a, b, rounding_mode='trunc'), or for actual floor division, use torch.div(a, b, rounding_mode='floor'). (Triggered internally at /mnt/scratch/kashif/pytorch/aten/src/ATen/native/BinaryOps.cpp:576.)\n", + " L //= 2\n", + "/mnt/scratch/kashif/pytorch-transformer-forecast/kernel.py:1140: UserWarning: Casting complex values to real discards the imaginary part (Triggered internally at /mnt/scratch/kashif/pytorch/aten/src/ATen/native/Copy.cpp:240.)\n", + " return u.float(), state\n" + ] + } + ], + "source": [ + "forecasts = list(forecast_it)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "57b85112", + "metadata": {}, + "outputs": [], + "source": [ + "tss = list(ts_it)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "0be971a5", + "metadata": {}, + "outputs": [], + "source": [ + "evaluator = Evaluator()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "c8ea2a4c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Running evaluation: 2247it [00:00, 4590.10it/s]/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/evaluation/_base.py:313: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " date_before_forecast = forecast.index[0] - forecast.index[0].freq\n", + "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pandas/core/construction.py:781: UserWarning: Warning: converting a masked element to nan.\n", + " subarr = np.array(arr, dtype=dtype, copy=copy)\n" + ] + } + ], + "source": [ + "agg_metrics, ts_metrics = evaluator(iter(tss), iter(forecasts))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "943b8b7c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'MSE': 16747109.805273874,\n", + " 'abs_error': 33179613.89278412,\n", + " 'abs_target_sum': 128632956.0,\n", + " 'abs_target_mean': 2385.272140631954,\n", + " 'seasonal_error': 189.49338196116761,\n", + " 'MASE': 3.0259446149950957,\n", + " 'MAPE': 0.3554268814529896,\n", + " 'sMAPE': 0.2830898842278759,\n", + " 'MSIS': 32.65637303286821,\n", + " 'QuantileLoss[0.1]': 26881642.935654998,\n", + " 'Coverage[0.1]': 0.6553182020471741,\n", + " 'QuantileLoss[0.2]': 32171550.764535427,\n", + " 'Coverage[0.2]': 0.7410065272214805,\n", + " 'QuantileLoss[0.3]': 34225308.93104912,\n", + " 'Coverage[0.3]': 0.7942998071502745,\n", + " 'QuantileLoss[0.4]': 34387341.28364634,\n", + " 'Coverage[0.4]': 0.8323134549770064,\n", + " 'QuantileLoss[0.5]': 33179613.401385784,\n", + " 'Coverage[0.5]': 0.8615005192107995,\n", + " 'QuantileLoss[0.6]': 30535314.288769234,\n", + " 'Coverage[0.6]': 0.8851246105919003,\n", + " 'QuantileLoss[0.7]': 26795939.697389804,\n", + " 'Coverage[0.7]': 0.9090268506156357,\n", + " 'QuantileLoss[0.8]': 21610667.198691174,\n", + " 'Coverage[0.8]': 0.9338747960243287,\n", + " 'QuantileLoss[0.9]': 14396474.291173145,\n", + " 'Coverage[0.9]': 0.9592048657469219,\n", + " 'RMSE': 4092.323277219662,\n", + " 'NRMSE': 1.7156630505630448,\n", + " 'ND': 0.2579402271746295,\n", + " 'wQuantileLoss[0.1]': 0.20897943864133076,\n", + " 'wQuantileLoss[0.2]': 0.2501034864233037,\n", + " 'wQuantileLoss[0.3]': 0.2660695205593279,\n", + " 'wQuantileLoss[0.4]': 0.26732916938989054,\n", + " 'wQuantileLoss[0.5]': 0.2579402233544706,\n", + " 'wQuantileLoss[0.6]': 0.23738328993053098,\n", + " 'wQuantileLoss[0.7]': 0.20831317673668173,\n", + " 'wQuantileLoss[0.8]': 0.16800257003105157,\n", + " 'wQuantileLoss[0.9]': 0.11191901934659065,\n", + " 'mean_absolute_QuantileLoss': 28242650.310255006,\n", + " 'mean_wQuantileLoss': 0.21955998826813095,\n", + " 'MAE_Coverage': 0.3412966259539469,\n", + " 'OWA': nan}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agg_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "99c10cdc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20, 15))\n", + "date_formater = mdates.DateFormatter('%b, %d')\n", + "plt.rcParams.update({'font.size': 15})\n", + "\n", + "for idx, (forecast, ts) in islice(enumerate(zip(forecasts, tss)), 9):\n", + " ax = plt.subplot(3, 3, idx+1)\n", + "\n", + " plt.plot(ts[-4 * 20:], label=\"target\", )\n", + " forecast.plot( color='g')\n", + " plt.xticks(rotation=60)\n", + " ax.xaxis.set_major_formatter(date_formater)\n", + "\n", + "plt.gcf().tight_layout()\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c6e9fff", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/s4/s4.py b/s4/s4.py new file mode 100644 index 0000000..daa8e24 --- /dev/null +++ b/s4/s4.py @@ -0,0 +1,218 @@ +import logging + +import opt_einsum as oe +import torch +import torch.nn as nn +import torch.nn.functional as F +from einops import rearrange + +from components import Activation, LinearActivation, Normalization +from kernel import HippoSSKernel + +optimized = True + +if optimized: + contract = oe.contract +else: + contract = torch.einsum + + +class S4(nn.Module): + requires_length = True + + def __init__( + self, + d_model, + d_state=64, + l_max=1, # Maximum length of sequence. Fine if not provided: the kernel will keep doubling in length until longer than sequence. However, this can be marginally slower if the true length is not a power of 2 + channels=1, # maps 1-dim to C-dim + bidirectional=False, + # Arguments for FF + activation="gelu", # activation in between SS and FF + ln=False, # Extra normalization + postact=None, # activation after FF + initializer=None, # initializer on FF + weight_norm=False, # weight normalization on FF + hyper_act=None, # Use a "hypernetwork" multiplication + dropout=0.0, + transposed=True, # axis ordering (B, L, D) or (B, D, L) + verbose=False, + shift=False, + linear=False, + # SSM Kernel arguments + **kernel_args, + ): + """ + d_state: the dimension of the state, also denoted by N + l_max: the maximum sequence length, also denoted by L + if this is not known at model creation, set l_max=1 + channels: can be interpreted as a number of "heads" + bidirectional: bidirectional + dropout: standard dropout argument + transposed: choose backbone axis ordering of (B, L, H) or (B, H, L) [B=batch size, L=sequence length, H=hidden dimension] + + Other options are all experimental and should not need to be configured + """ + + super().__init__() + if verbose: + from logger import get_logger + + log = get_logger(__name__) + log.info(f"Constructing S4 (H, N, L) = ({d_model}, {d_state}, {l_max})") + + self.h = d_model + self.n = d_state + self.bidirectional = bidirectional + self.ln = ln + self.channels = channels + self.transposed = transposed + self.shift = shift + self.linear = linear + + # optional multiplicative modulation GLU-style + # https://arxiv.org/abs/2002.05202 + self.hyper = hyper_act is not None + if self.hyper: + channels *= 2 + self.hyper_activation = Activation(hyper_act) + + self.D = nn.Parameter(torch.randn(channels, self.h)) + + if self.bidirectional: + channels *= 2 + + # SSM Kernel + self.kernel = HippoSSKernel( + self.h, N=self.n, L=l_max, channels=channels, verbose=verbose, **kernel_args + ) + + # Pointwise + if not self.linear: + self.activation = Activation(activation) + dropout_fn = nn.Dropout2d if self.transposed else nn.Dropout + self.dropout = dropout_fn(dropout) if dropout > 0.0 else nn.Identity() + if self.ln: + self.norm = Normalization(self.h * self.channels, transposed=transposed) + else: + self.norm = nn.Identity() + + # position-wise output transform to mix features + if not self.linear: + self.output_linear = LinearActivation( + self.h * self.channels, + self.h, + transposed=self.transposed, + initializer=initializer, + activation=postact, + activate=True, + weight_norm=weight_norm, + ) + + def forward( + self, u, state=None, **kwargs + ): # absorbs return_output and transformer src mask + """ + u: (B H L) if self.transposed else (B L H) + state: (H N) never needed unless you know what you're doing + + Returns: same shape as u + """ + if not self.transposed: + u = u.transpose(-1, -2) + L = u.size(-1) + + # Compute SS Kernel + k, k_state = self.kernel(L=L, state=state) # (C H L) (B C H L) + + # Convolution + if self.bidirectional: + k0, k1 = rearrange(k, "(s c) h l -> s c h l", s=2) + k = F.pad(k0, (0, L)) + F.pad(k1.flip(-1), (L, 0)) + if self.shift: + # Try flip and pad to correct for potential off-by-one + k_f = torch.fft.rfft(F.pad(k.flip(-1), (L, 0)), n=2 * L) # (C H L) + u_f = torch.fft.rfft(F.pad(u.flip(-1), (L, 0)), n=2 * L) # (B H L) + y_f = contract( + "bhl,chl->bchl", u_f, k_f + ) # k_f.unsqueeze(-4) * u_f.unsqueeze(-3) # (B C H L) + y = torch.fft.irfft(y_f, n=2 * L)[..., L:].flip(-1) # (B C H L) + else: + k_f = torch.fft.rfft(k, n=2 * L) # (C H L) + u_f = torch.fft.rfft(u, n=2 * L) # (B H L) + y_f = contract( + "bhl,chl->bchl", u_f, k_f + ) # k_f.unsqueeze(-4) * u_f.unsqueeze(-3) # (B C H L) + y = torch.fft.irfft(y_f, n=2 * L)[..., :L] # (B C H L) + + # Compute D term in state space equation - essentially a skip connection + y = y + contract( + "bhl,ch->bchl", u, self.D + ) # u.unsqueeze(-3) * self.D.unsqueeze(-1) + + # Compute state update + if state is not None: + assert ( + not self.bidirectional + ), "Bidirectional not supported with state forwarding" + y = y + k_state + next_state = self.kernel.forward_state(u, state) + else: + next_state = None + + # Optional hyper-network multiplication + if self.hyper: + y, yh = rearrange(y, "b (s c) h l -> s b c h l", s=2) + y = self.hyper_activation(yh) * y + + # Reshape to flatten channels + y = rearrange(y, "... c h l -> ... (c h) l") + + if not self.linear: + y = self.dropout(self.activation(y)) + + if not self.transposed: + y = y.transpose(-1, -2) + + if not self.linear: + y = self.norm(y) + y = self.output_linear(y) + + return y, next_state + + def setup_step(self): + self.kernel.setup_step() + + def step(self, u, state): + """Step one time step as a recurrent model. Intended to be used during validation. + + u: (B H) + state: (B H N) + Returns: output (B H), state (B H N) + """ + assert not self.training + + y, next_state = self.kernel.step(u, state) # (B C H) + y = y + u.unsqueeze(-2) * self.D + y = rearrange(y, "... c h -> ... (c h)") + y = self.activation(y) + if self.transposed: + y = self.output_linear(y.unsqueeze(-1)).squeeze(-1) + else: + y = self.output_linear(y) + return y, next_state + + def default_state(self, *batch_shape, device=None): + return self.kernel.default_state(*batch_shape) + + @property + def d_state(self): + return self.h * self.n + + @property + def d_output(self): + return self.h + + @property + def state_to_tensor(self): + return lambda state: rearrange("... h n -> ... (h n)", state) diff --git a/s4/toeplitz.py b/s4/toeplitz.py new file mode 100644 index 0000000..4bf4946 --- /dev/null +++ b/s4/toeplitz.py @@ -0,0 +1,300 @@ +""" Utilities for computing convolutions. + +There are 3 equivalent views: + 1. causal convolution + 2. multiplication of (lower) triangular Toeplitz matrices + 3. polynomial multiplication (mod x^N) +""" + +import torch + +# import torch.nn as nn +import torch.nn.functional as F + +# from model.complex import complex_mul +# from pytorch_memlab import profile + + +def construct_toeplitz(v, f=0.0): + """Explicit construction of Krylov matrix [v A @ v A^2 @ v ... A^{n-1} @ v] + where A = Z_f. This uses vectorized indexing and cumprod so it's much + faster than using the Krylov function. + Parameters: + v: the starting vector of size n or (rank, n). + f: real number + Returns: + K: Krylov matrix of size (n, n) or (rank, n, n). + """ + n = v.shape[-1] + a = torch.arange(n, device=v.device) + b = -a + indices = a[:, None] + b[None] + K = v[..., indices] + K[..., indices < 0] *= f + return K + + +def triangular_toeplitz_multiply_(u, v, sum=None): + n = u.shape[-1] + u_expand = F.pad(u, (0, n)) + v_expand = F.pad(v, (0, n)) + u_f = torch.fft.rfft(u_expand, n=2 * n, dim=-1) + v_f = torch.fft.rfft(v_expand, n=2 * n, dim=-1) + uv_f = u_f * v_f + if sum is not None: + uv_f = uv_f.sum(dim=sum) + output = torch.fft.irfft(uv_f, n=2 * n, dim=-1)[..., :n] + return output + + +def triangular_toeplitz_multiply_padded_(u, v): + """Same as triangular_toeplitz_multiply but inputs and output assume to be 0-padded already.""" + n = u.shape[-1] + assert n % 2 == 0 + u_f = torch.fft.rfft(u, n=n, dim=-1) + v_f = torch.fft.rfft(v, n=n, dim=-1) + uv_f = u_f * v_f + output = torch.fft.irfft(uv_f, n=n, dim=-1) + output[..., n:] = 0 + return output + + +class TriangularToeplitzMult(torch.autograd.Function): + @staticmethod + def forward(ctx, u, v): + ctx.save_for_backward(u, v) + return triangular_toeplitz_multiply_(u, v) + + @staticmethod + def backward(ctx, grad): + u, v = ctx.saved_tensors + d_u = triangular_toeplitz_multiply_(grad.flip(-1), v).flip(-1) + d_v = triangular_toeplitz_multiply_(grad.flip(-1), u).flip(-1) + return d_u, d_v + + +class TriangularToeplitzMultFast(torch.autograd.Function): + @staticmethod + def forward(ctx, u, v): + n = u.shape[-1] + u_expand = F.pad(u, (0, n)) + v_expand = F.pad(v, (0, n)) + u_f = torch.fft.rfft(u_expand, n=2 * n, dim=-1) + v_f = torch.fft.rfft(v_expand, n=2 * n, dim=-1) + + ctx.save_for_backward(u_f, v_f) + + uv_f = u_f * v_f + output = torch.fft.irfft(uv_f, n=2 * n, dim=-1)[..., :n] + return output + + @staticmethod + def backward(ctx, grad): + u_f, v_f = ctx.saved_tensors + n = grad.shape[-1] + g_expand = F.pad(grad.flip(-1), (0, n)) + g_f = torch.fft.rfft(g_expand, n=2 * n, dim=-1) + gu_f = g_f * u_f + gv_f = g_f * v_f + d_u = torch.fft.irfft(gv_f, n=2 * n, dim=-1)[..., :n] + d_v = torch.fft.irfft(gu_f, n=2 * n, dim=-1)[..., :n] + d_u = d_u.flip(-1) + d_v = d_v.flip(-1) + return d_u, d_v + + +class TriangularToeplitzMultPadded(torch.autograd.Function): + @staticmethod + def forward(ctx, u, v): + ctx.save_for_backward(u, v) + output = triangular_toeplitz_multiply_(u, v) + return output + + @staticmethod + def backward(ctx, grad): + u, v = ctx.saved_tensors + d_u = triangular_toeplitz_multiply_padded_(grad.flip(-1), v).flip(-1) + d_v = triangular_toeplitz_multiply_padded_(grad.flip(-1), u).flip(-1) + return d_u, d_v + + +class TriangularToeplitzMultPaddedFast(torch.autograd.Function): + """Trade off speed (20-25% faster) for more memory (20-25%)""" + + @staticmethod + def forward(ctx, u, v): + n = u.shape[-1] + u_f = torch.fft.rfft(u, n=n, dim=-1) + v_f = torch.fft.rfft(v, n=n, dim=-1) + + ctx.save_for_backward(u_f, v_f) + + uv_f = u_f * v_f + output = torch.fft.irfft(uv_f, n=n, dim=-1) + output[..., n // 2 :].zero_() + return output + + @staticmethod + def backward(ctx, grad): + u_f, v_f = ctx.saved_tensors + n = grad.shape[-1] + g_expand = F.pad(grad[..., : n // 2].flip(-1), (0, n // 2)) + g_f = torch.fft.rfft(g_expand, n=n, dim=-1) + gu_f = g_f * u_f + gv_f = g_f * v_f + d_u = torch.fft.irfft(gv_f, n=n, dim=-1) + d_v = torch.fft.irfft(gu_f, n=n, dim=-1) + d_u[..., n // 2 :].zero_() + d_v[..., n // 2 :].zero_() + d_u[..., : n // 2] = d_u[..., : n // 2].flip(-1) # TODO + d_v[..., : n // 2] = d_v[..., : n // 2].flip(-1) # TODO + return d_u, d_v + + +# triangular_toeplitz_multiply = triangular_toeplitz_multiply_ +triangular_toeplitz_multiply = TriangularToeplitzMult.apply +triangular_toeplitz_multiply_fast = TriangularToeplitzMultFast.apply +triangular_toeplitz_multiply_padded = TriangularToeplitzMultPadded.apply +triangular_toeplitz_multiply_padded_fast = TriangularToeplitzMultPaddedFast.apply + + +def causal_convolution(u, v, fast=True, pad=False): + if not pad and not fast: + return triangular_toeplitz_multiply(u, v) + if not pad and fast: + return triangular_toeplitz_multiply_fast(u, v) + if pad and not fast: + return triangular_toeplitz_multiply_padded(u, v) + if pad and fast: + return triangular_toeplitz_multiply_padded_fast(u, v) + + +def _fft(x, N): + return torch.fft.rfft(F.pad(x, (0, 2 * N - x.shape[-1])), n=2 * N, dim=-1) + + +def _ifft(x, N): + return torch.fft.irfft(x, n=2 * N, dim=-1)[..., :N] + + +def causal_convolution_inverse(u): + """Invert the causal convolution/polynomial/triangular Toeplitz matrix represented by u. + + This is easiest in the polynomial view: + https://www.csa.iisc.ac.in/~chandan/courses/CNT/notes/lec5.pdf + The idea is that + h = g^{-1} (mod x^m) => 2h - gh^2 = g^{-1} (mod x^{2m}) + + # TODO this can be numerically unstable if input is "poorly conditioned", + # for example if u[0] is magnitudes different from the rest of u + """ + N = u.shape[-1] + v = u[..., :1].reciprocal() + while v.shape[-1] < N: + M = v.shape[-1] + v_f = _fft(v, 2 * M) + u_f = _fft(u[..., : 2 * M], 2 * M) + _v = -_ifft(u_f * v_f**2, 2 * M) + _v[..., :M] = _v[..., :M] + 2 * v + v = _v + # TODO contiguous? + v = v[..., :N] + return v + + +""" Below are experimental functions for improving the stability of LSSL/S3 algorithm. Currently not used anywhere. """ + + +def causal_convolution_inverse_wrong(u, v): + """Solve u * x = v. Initial attempt by inverting the multiplication algorithm, which I think doesn't work.""" + n = u.shape[-1] + u_expand = F.pad(u, (0, n)) + v_expand = F.pad(v, (0, n)) + u_f = torch.fft.rfft(u_expand, n=2 * n, dim=-1) + v_f = torch.fft.rfft(v_expand, n=2 * n, dim=-1) + uv_f = v_f / u_f + x = torch.fft.irfft(uv_f, n=2 * n, dim=-1)[..., :n] + return x + + +def construct_toeplitz_log(v): + n = v.shape[-1] + a = torch.arange(n, device=v.device) + b = -a + indices = a[:, None] + b[None] + K = v[..., indices] + K[..., indices < 0] = -100.0 + return K + + +def _logsumexp(x, dim=-1): + """logsumexp for complex""" + m = torch.max(torch.real(x), dim=dim, keepdim=True)[0] + x = x - m + x = torch.log(torch.sum(torch.exp(x), dim=dim)) + x = x + m.squeeze(dim) + return x + + +def causal_convolution_inverse_log(u, N=-1): + """Invert the causal convolution/polynomial/triangular Toeplitz matrix represented by u. + + This is easiest in the polynomial view: + https://www.csa.iisc.ac.in/~chandan/courses/CNT/notes/lec5.pdf + The idea is that + h = g^{-1} (mod x^m) => 2h - gh^2 = g^{-1} (mod x^{2m}) + + # TODO this can be numerically unstable if input is "poorly conditioned", + # for example if u[0] is magnitudes different from the rest of u + """ + if N < 0: + N = u.shape[-1] + v = -u[..., :1] + while v.shape[-1] < N: + M = v.shape[-1] + _v = F.pad(v, (0, M), value=-100.0) + _v_ = construct_toeplitz_log(_v) + u_ = ( + u[..., : 2 * M] + if u.shape[-1] >= 2 * M + else F.pad(u, (0, 2 * M - u.shape[-1]), value=-100.0) + ) + _u = _logsumexp(_v_ + u_, dim=-1) + _u = _logsumexp(_v_ + _u, dim=-1) + _u = _u + torch.log(-torch.ones_like(_u)) + _v = _v + torch.log(2.0 * torch.ones_like(_u)) + v = _logsumexp(torch.stack([_v, _u], dim=-1), dim=-1) + # TODO contiguous? + v = v[..., :N] + + check = _logsumexp( + construct_toeplitz_log(v) + F.pad(u, (0, N - u.shape[-1]), value=-100.0) + ) + print("check", check, torch.exp(check)) + return v + + +if __name__ == "__main__": + a = torch.tensor([1.0, 2, 3, 4], requires_grad=True) + b = torch.tensor([5.0, 6, 7, 8], requires_grad=True) + a.retain_grad() + b.retain_grad() + x = triangular_toeplitz_multiply_padded(F.pad(a, (0, 4)), F.pad(b, (0, 4)))[:4] + print(x) # [5 16 34 60] + x = x.sum() + x.backward() + print(x, a.grad, b.grad) # [26 18 11 5] [10 6 3 1] + +if __name__ == "__main__": + N = 4 + a = torch.randn(N) + construct_toeplitz(a) + print(a) + b = causal_convolution_inverse(a) + print("inverse", b) + print("check", causal_convolution(a, b)) + i = torch.zeros(N) + i[0] = 1.0 + b = causal_convolution_inverse_wrong(a, i) + print(b) + print(causal_convolution(a, b))