data/examples/RNN/RNN_scripts/modules.py

"""RNN definition of network classes, training functionality."""
import torch.nn as nn
from math import sqrt, floor
import random
import time
import torch
import numpy as np
import matplotlib.pyplot as plt


def gram_schmidt_pt(mat):
    """
    Performs INPLACE Gram-Schmidt
    :param mat:
    :return:
    """
    mat[0] = mat[0] / torch.norm(mat[0])
    for i in range(1, mat.shape[0]):
        mat[i] = mat[i] - (mat[:i].t() @ mat[:i] @ mat[i])
        mat[i] = mat[i] / torch.norm(mat[i])


def loss_mse(output, target, mask):
    """
    Mean squared error loss
    :param output: torch tensor of shape (num_trials, num_timesteps, output_dim)
    :param target: torch tensor of shape (num_trials, num_timesteps, output_dim)
    :param mask: torch tensor of shape (num_trials, num_timesteps, 1)
    :return: float
    """
    # Compute loss for each (trial, timestep) (average accross output dimensions)
    loss_tensor = (mask * (target - output)).pow(2).mean(dim=-1)
    # Account for different number of masked values per trial
    loss_by_trial = loss_tensor.sum(dim=-1) / mask[:, :, 0].sum(dim=-1)
    return loss_by_trial.mean()


def train(
    net,
    _input,
    _target,
    _mask,
    n_epochs,
    random_ic=False,
    lr=1e-2,
    batch_size=32,
    plot_learning_curve=False,
    plot_gradient=False,
    mask_gradients=False,
    clip_gradient=None,
    early_stop=None,
    keep_best=False,
    cuda=False,
    resample=False,
):
    """
    Train a network
    :param net: nn.Module
    :param _input: torch tensor of shape (num_trials, num_timesteps, input_dim)
    :param _target: torch tensor of shape (num_trials, num_timesteps, output_dim)
    :param _mask: torch tensor of shape (num_trials, num_timesteps, 1)
    :param n_epochs: int
    :param lr: float, learning rate
    :param batch_size: int
    :param plot_learning_curve: bool
    :param plot_gradient: bool
    :param mask_gradients: bool, set to True if training the SupportLowRankRNN_withMask for reduced models
    :param clip_gradient: None or float, if not None the value at which gradient norm is clipped
    :param early_stop: None or float, set to target loss value after which to immediately stop if attained
    :param keep_best: bool, if True, model with lower loss from training process will be kept (for this option, the
        network has to implement a method clone())
    :param resample: for SupportLowRankRNNs, set True
    :return: nothing
    """
    print("Training...")
    optimizer = torch.optim.Adam(net.parameters(), lr=lr)
    num_examples = _input.shape[0]
    all_losses = []
    if plot_gradient:
        gradient_norms = []

    # CUDA management
    if cuda:
        if not torch.cuda.is_available():
            print("Warning: CUDA not available on this machine, switching to CPU")
            device = torch.device("cpu")
        else:
            device = torch.device("cuda")
    else:
        device = torch.device("cpu")
    net.to(device=device)
    input = _input.to(device=device)
    target = _target.to(device=device)
    mask = _mask.to(device=device)

    # Initialize setup to keep best network
    with torch.no_grad():
        output, _ = net(input)
        initial_loss = loss_mse(output, target, mask)
        print("initial loss: %.3f" % (initial_loss.item()))
        if keep_best:
            best = net.clone()
            best_loss = initial_loss.item()

    if random_ic:
        print("training with random initial conditions")

    # Training loop
    for epoch in range(n_epochs):
        begin = time.time()
        losses = []  # losses over the whole epoch
        for i in range(num_examples // batch_size):
            optimizer.zero_grad()
            random_batch_idx = random.sample(range(num_examples), batch_size)
            batch = input[random_batch_idx]

            # set initial condition
            if random_ic:
                # norm = net.m.norm(dim=0)
                h0 = torch.rand(net.hidden_size).to(device) * net.hidden_size / 300
                net.h0.data = h0

            output, _ = net(batch)
            loss = loss_mse(output, target[random_batch_idx], mask[random_batch_idx])
            losses.append(loss.item())
            all_losses.append(loss.item())
            loss.backward()
            if mask_gradients:
                net.m.grad = net.m.grad * net.m_mask
                net.n.grad = net.n.grad * net.n_mask
                net.wi.grad = net.wi.grad * net.wi_mask
                net.wo.grad = net.wo.grad * net.wo_mask
                net.unitn.grad = net.unitn.grad * net.unitn_mask
                net.unitm.grad = net.unitm.grad * net.unitm_mask
                net.unitwi.grad = net.unitwi.grad * net.unitwi_mask
            if clip_gradient is not None:
                torch.nn.utils.clip_grad_norm_(net.parameters(), clip_gradient)
            if plot_gradient:
                tot = 0
                for param in [p for p in net.parameters() if p.requires_grad]:
                    tot += (param.grad**2).sum()
                gradient_norms.append(sqrt(tot))
            optimizer.step()
            # These 2 lines important to prevent memory leaks
            loss.detach_()
            output.detach_()
            if resample:
                net.resample_basis()
        if keep_best and np.mean(losses) < best_loss:
            best = net.clone()
            best_loss = np.mean(losses)
            print(
                "epoch %d:  loss=%.3f  (took %.2f s) *"
                % (epoch, np.mean(losses), time.time() - begin)
            )
        else:
            print(
                "epoch %d:  loss=%.3f  (took %.2f s)"
                % (epoch, np.mean(losses), time.time() - begin)
            )
        if early_stop is not None and np.mean(losses) < early_stop:
            break

    if plot_learning_curve:
        plt.plot(all_losses)
        plt.title("Learning curve")
        plt.show()

    if plot_gradient:
        plt.plot(gradient_norms)
        plt.title("Gradient norm")
        plt.show()

    if keep_best:
        net.load_state_dict(best.state_dict())


class FullRankRNN(nn.Module):
    def __init__(
        self,
        input_size,
        hidden_size,
        output_size,
        noise_std,
        alpha=0.2,
        rho=1,
        train_wi=False,
        train_wo=False,
        train_wrec=True,
        train_h0=False,
        wi_init=None,
        wo_init=None,
        wrec_init=None,
        si_init=None,
        so_init=None,
    ):
        """
        :param input_size: int
        :param hidden_size: int
        :param output_size: int
        :param noise_std: float
        :param alpha: float, value of dt/tau
        :param rho: float, std of gaussian distribution for initialization
        :param train_wi: bool
        :param train_wo: bool
        :param train_wrec: bool
        :param train_h0: bool
        :param wi_init: torch tensor of shape (input_dim, hidden_size)
        :param wo_init: torch tensor of shape (hidden_size, output_dim)
        :param wrec_init: torch tensor of shape (hidden_size, hidden_size)
        :param si_init: input scaling, torch tensor of shape (input_dim)
        :param so_init: output scaling, torch tensor of shape (output_dim)
        """
        super(FullRankRNN, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.noise_std = noise_std
        self.alpha = alpha
        self.rho = rho
        self.train_wi = train_wi
        self.train_wo = train_wo
        self.train_wrec = train_wrec
        self.train_h0 = train_h0
        self.non_linearity = torch.tanh

        # Define parameters
        self.wi = nn.Parameter(torch.Tensor(input_size, hidden_size))
        self.si = nn.Parameter(torch.Tensor(input_size))
        if train_wi:
            self.si.requires_grad = False
        else:
            self.wi.requires_grad = False
        self.wrec = nn.Parameter(torch.Tensor(hidden_size, hidden_size))
        if not train_wrec:
            self.wrec.requires_grad = False
        self.wo = nn.Parameter(torch.Tensor(hidden_size, output_size))
        self.so = nn.Parameter(torch.Tensor(output_size))
        if train_wo:
            self.so.requires_grad = False
        if not train_wo:
            self.wo.requires_grad = False
        self.h0 = nn.Parameter(torch.Tensor(hidden_size))
        if not train_h0:
            self.h0.requires_grad = False

        # Initialize parameters
        with torch.no_grad():
            if wi_init is None:
                self.wi.normal_()
            else:
                self.wi.copy_(wi_init)
            if si_init is None:
                self.si.set_(torch.ones_like(self.si))
            else:
                self.si.copy_(si_init)
            if wrec_init is None:
                self.wrec.normal_(std=rho / sqrt(hidden_size))
            else:
                self.wrec.copy_(wrec_init)
            if wo_init is None:
                self.wo.normal_(std=1 / hidden_size)
            else:
                self.wo.copy_(wo_init)
            if so_init is None:
                self.so.set_(torch.ones_like(self.so))
            else:
                self.so.copy_(so_init)
            self.h0.zero_()
        self.wi_full, self.wo_full = [None] * 2
        self._define_proxy_parameters()

    def _define_proxy_parameters(self):
        self.wi_full = (self.wi.t() * self.si).t()
        self.wo_full = self.wo * self.so

    def forward(self, input):
        """
        :param input: tensor of shape (batch_size, #timesteps, input_dimension)
        Important: the 3 dimensions need to be present, even if they are of size 1.
        :return: (output tensor, trajectories tensor of shape (batch_size, #timesteps, #hidden_units))
        """
        batch_size = input.shape[0]
        seq_len = input.shape[1]
        h = self.h0
        r = self.non_linearity(h)
        self._define_proxy_parameters()
        noise = torch.randn(batch_size, seq_len, self.hidden_size, device=self.wrec.device)
        output = torch.zeros(batch_size, seq_len, self.output_size, device=self.wrec.device)
        trajectories = torch.zeros(batch_size, seq_len, self.hidden_size, device=self.wrec.device)

        # simulation loop
        for i in range(seq_len):
            h = (
                h
                + self.noise_std * noise[:, i, :]
                + self.alpha * (-h + r.matmul(self.wrec.t()) + input[:, i, :].matmul(self.wi_full))
            )

            r = self.non_linearity(h)
            output[:, i, :] = r.matmul(self.wo_full)
            trajectories[:, i, :] = h

        return output, trajectories

    def clone(self):
        new_net = FullRankRNN(
            self.input_size,
            self.hidden_size,
            self.output_size,
            self.noise_std,
            self.alpha,
            self.rho,
            self.train_wi,
            self.train_wo,
            self.train_wrec,
            self.train_h0,
            self.wi,
            self.wo,
            self.wrec,
            self.si,
            self.so,
        )
        return new_net


def simulation_loop(model, input):
    batch_size = input.shape[0]
    seq_len = input.shape[1]
    h = model.h0
    r = model.non_linearity(h)

    noise = torch.randn(batch_size, seq_len, model.hidden_size, device=model.m.device)
    output = torch.zeros(batch_size, seq_len, model.output_size, device=model.m.device)
    trajectories = torch.zeros(batch_size, seq_len, model.hidden_size, device=model.m.device)

    for i in range(seq_len):
        h = (
            h
            + model.noise_std * noise[:, i, :]
            + model.alpha
            * (
                -h
                + r.matmul(model.n).matmul(model.m.t()) / model.hidden_size
                + input[:, i, :].matmul(model.wi_full)
            )
        )

        r = model.non_linearity(h)
        output[:, i, :] = r.matmul(model.wo_full) / model.hidden_size
        trajectories[:, i, :] = h

    return output, trajectories


class LowRankRNN(nn.Module):
    """
    This class implements the low-rank RNN. Instead of being parametrized by an NxN connectivity matrix, it is
    parametrized by two Nxr matrices m and n such that the connectivity is m * n^T
    """

    def __init__(
        self,
        input_size,
        hidden_size,
        output_size,
        noise_std,
        alpha,
        rank=1,
        train_wi=False,
        train_wo=False,
        train_wrec=True,
        train_h0=False,
        train_si=True,
        train_so=True,
        wi_init=None,
        wo_init=None,
        m_init=None,
        n_init=None,
        si_init=None,
        so_init=None,
        h0_init=None,
    ):
        """
        :param input_size: int
        :param hidden_size: int
        :param output_size: int
        :param noise_std: float
        :param alpha: float, value of dt/tau
        :param rank: int
        :param train_wi: bool
        :param train_wo: bool
        :param train_wrec: bool
        :param train_h0: bool
        :param train_si: bool
        :param train_so: bool
        :param wi_init: torch tensor of shape (input_dim, hidden_size)
        :param wo_init: torch tensor of shape (hidden_size, output_dim)
        :param m_init: torch tensor of shape (hidden_size, rank)
        :param n_init: torch tensor of shape (hidden_size, rank)
        :param si_init: torch tensor of shape (input_size)
        :param so_init: torch tensor of shape (output_size)
        :param h0_init: torch tensor of shape (hidden_size)
        """
        super(LowRankRNN, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.noise_std = noise_std
        self.alpha = alpha
        self.rank = rank
        self.train_wi = train_wi
        self.train_wo = train_wo
        self.train_wrec = train_wrec
        self.train_h0 = train_h0
        self.train_si = train_si
        self.train_so = train_so
        self.non_linearity = torch.tanh

        # Define parameters
        self.wi = nn.Parameter(torch.Tensor(input_size, hidden_size))
        self.si = nn.Parameter(torch.Tensor(input_size))
        if train_wi:
            self.si.requires_grad = False
        else:
            self.wi.requires_grad = False
        if not train_si:
            self.si.requires_grad = False
        self.m = nn.Parameter(torch.Tensor(hidden_size, rank))
        self.n = nn.Parameter(torch.Tensor(hidden_size, rank))
        if not train_wrec:
            self.m.requires_grad = False
            self.n.requires_grad = False
        self.wo = nn.Parameter(torch.Tensor(hidden_size, output_size))
        self.so = nn.Parameter(torch.Tensor(output_size))
        if train_wo:
            self.so.requires_grad = False
        if not train_wo:
            self.wo.requires_grad = False
        if not train_so:
            self.so.requires_grad = False
        self.h0 = nn.Parameter(torch.Tensor(hidden_size))
        if not train_h0:
            self.h0.requires_grad = False

        # Initialize parameters
        with torch.no_grad():
            if wi_init is None:
                self.wi.normal_()
            else:
                self.wi.copy_(wi_init)
            if si_init is None:
                self.si.set_(torch.ones_like(self.si))
            else:
                self.si.copy_(si_init)
            if m_init is None:
                self.m.normal_()
            else:
                self.m.copy_(m_init)
            if n_init is None:
                self.n.normal_()
            else:
                self.n.copy_(n_init)
            if wo_init is None:
                self.wo.normal_(std=4.0)
            else:
                self.wo.copy_(wo_init)
            if so_init is None:
                self.so.set_(torch.ones_like(self.so))
            else:
                self.so.copy_(so_init)
            if h0_init is None:
                self.h0.zero_()
            else:
                self.h0.copy_(h0_init)
        self.wrec, self.wi_full, self.wo_full = [None] * 3
        self._define_proxy_parameters()

    def _define_proxy_parameters(self):
        self.wrec = None
        self.wi_full = (self.wi.t() * self.si).t()
        self.wo_full = self.wo * self.so

    def forward(self, input):
        """
        :param input: tensor of shape (batch_size, #timesteps, input_dimension)
        Important: the 3 dimensions need to be present, even if they are of size 1.
        :return: (output tensor, trajectories tensor of shape (batch_size, #timesteps, #hidden_units))
        """
        return simulation_loop(self, input)

    def clone(self):
        new_net = LowRankRNN(
            self.input_size,
            self.hidden_size,
            self.output_size,
            self.noise_std,
            self.alpha,
            self.rank,
            self.train_wi,
            self.train_wo,
            self.train_wrec,
            self.train_h0,
            self.train_si,
            self.train_so,
            self.wi,
            self.wo,
            self.m,
            self.n,
            self.si,
            self.so,
        )
        new_net._define_proxy_parameters()
        return new_net

    def load_state_dict(self, state_dict, strict=True):
        """
        override
        """
        if "rec_noise" in state_dict:
            del state_dict["rec_noise"]
        super().load_state_dict(state_dict, strict)
        self._define_proxy_parameters()

    def svd_reparametrization(self):
        """
        Orthogonalize m and n via SVD
        """
        with torch.no_grad():
            structure = (self.m @ self.n.t()).numpy()
            m, s, n = np.linalg.svd(structure, full_matrices=False)
            m, s, n = m[:, : self.rank], s[: self.rank], n[: self.rank, :]
            self.m.set_(torch.from_numpy(m * np.sqrt(s)))
            self.n.set_(torch.from_numpy(n.transpose() * np.sqrt(s)))
            self._define_proxy_parameters()


class SupportLowRankRNN(nn.Module):
    """
    This class implements the mixture-of-gaussians, low-rank RNN. The difference with the low-rank RNN is that
    all vectors are defined as transformation of a gaussian basis of dimensionality b for each population.

    For example the matrix m, instead of having Nxr free parameters, is parametrized by a tensor
    m_weights of shape (r, p, b) (where r is the rank, p is the number of populations). A gaussian basis of
    shape Nxb is sampled, and m is then computed from the basis and the weights, by assigning each neuron to a
    population monotonically.

    The weights defined above correspond to a linear transformation of the gaussian basis (ie the expectancy
    of the final distribution obtained is always zero). Affine transforms can be defined by setting biases.
    """

    def __init__(
        self,
        input_size,
        hidden_size,
        output_size,
        noise_std,
        alpha,
        rank=1,
        n_supports=1,
        weights=None,
        gaussian_basis_dim=None,
        m_weights_init=None,
        n_weights_init=None,
        wi_weights_init=None,
        wo_weights_init=None,
        m_biases_init=None,
        n_biases_init=None,
        wi_biases_init=None,
        train_biases=False,
    ):
        """
        :param input_size: int
        :param hidden_size: int
        :param output_size: int
        :param noise_std: float
        :param alpha: float
        :param rank: int
        :param n_supports: int, number of cell classes used
        :param weights: list, proportion of total population for each cell class (GMM components weights)
        :param gaussian_basis_dim: dimensionality of the gaussian basis on which weights are learned
        :param m_weights_init: torch tensor of shape (rank, n_supports, gaussian_basis_dim)
        :param n_weights_init: torch tensor of shape (rank, n_supports, gaussian_basis_dim)
        :param wi_weights_init: torch tensor of shape (input_size, n_supports, self.gaussian_basis_dim)
        :param wo_weights_init: torch tensor of shape (output_size, n_supports, self.gaussian_basis_dim)
        :param m_biases_init: torch tensor of shape (rank, n_supports)
        :param n_biases_init: torch tensor of shape (rank, n_supports)
        :param wi_biases_init: torch tensor of shape (input_size, n_supports)
        :param train_biases: bool
        """
        super(SupportLowRankRNN, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.noise_std = noise_std
        self.alpha = alpha
        self.rank = rank
        self.n_supports = n_supports
        self.gaussian_basis_dim = (
            2 * rank + input_size if gaussian_basis_dim is None else gaussian_basis_dim
        )
        self.non_linearity = torch.tanh

        self.gaussian_basis = nn.Parameter(
            torch.randn((self.gaussian_basis_dim, hidden_size)), requires_grad=False
        )
        self.supports = nn.Parameter(torch.zeros((n_supports, hidden_size)), requires_grad=False)
        if weights is None:
            self.weights = nn.Parameter(torch.tensor([1 / hidden_size]))
            l_support = hidden_size // n_supports
            for i in range(n_supports):
                self.supports[i, l_support * i : l_support * (i + 1)] = 1
            self.weights = [l_support / hidden_size] * n_supports
        else:
            k = 0
            self.weights = nn.Parameter(torch.tensor(weights), requires_grad=False)
            for i in range(n_supports):
                self.supports[i, k : k + floor(weights[i] * hidden_size)] = 1
                k += floor(weights[i] * hidden_size)

        # Define parameters
        self.wi_weights = nn.Parameter(
            torch.Tensor(input_size, n_supports, self.gaussian_basis_dim)
        )
        self.m_weights = nn.Parameter(torch.Tensor(rank, n_supports, self.gaussian_basis_dim))
        self.n_weights = nn.Parameter(torch.Tensor(rank, n_supports, self.gaussian_basis_dim))
        self.wo_weights = nn.Parameter(
            torch.Tensor(output_size, n_supports, self.gaussian_basis_dim)
        )
        self.wi_biases = nn.Parameter(
            torch.Tensor(input_size, n_supports), requires_grad=train_biases
        )
        self.m_biases = nn.Parameter(torch.Tensor(rank, n_supports), requires_grad=train_biases)
        self.n_biases = nn.Parameter(torch.Tensor(rank, n_supports), requires_grad=train_biases)
        self.h0_weights = nn.Parameter(torch.Tensor(n_supports, self.gaussian_basis_dim))
        self.h0_weights.requires_grad = False

        # Initialize parameters
        with torch.no_grad():
            if wi_weights_init is not None:
                self.wi_weights.copy_(wi_weights_init)
            else:
                self.wi_weights.normal_()
            if m_weights_init is not None:
                self.m_weights.copy_(m_weights_init)
            else:
                self.m_weights.normal_(std=1 / sqrt(hidden_size))
            if n_weights_init is not None:
                self.n_weights.copy_(n_weights_init)
            else:
                self.n_weights.normal_(std=1 / sqrt(hidden_size))
            if wo_weights_init is not None:
                self.wo_weights.copy_(wo_weights_init)
            else:
                self.wo_weights.normal_(std=1 / hidden_size)
            if wi_biases_init is not None:
                self.wi_biases.copy_(wi_biases_init)
            else:
                self.wi_biases.zero_()
            if m_biases_init is not None:
                self.m_biases.copy_(m_biases_init)
            else:
                self.m_biases.zero_()
            if n_biases_init is not None:
                self.n_biases.copy_(n_biases_init)
            else:
                self.n_biases.zero_()
            self.h0_weights.zero_()
        self.wi, self.m, self.n, self.wo, self.h0, self.wi_full, self.wo_full = [None] * 7
        self._define_proxy_parameters()

    def _define_proxy_parameters(self):
        self.wi = (
            torch.sum((self.wi_weights @ self.gaussian_basis) * self.supports, dim=(1,))
            + self.wi_biases @ self.supports
        )
        self.wi_full = self.wi
        self.m = (
            torch.sum((self.m_weights @ self.gaussian_basis) * self.supports, dim=(1,)).t()
            + (self.m_biases @ self.supports).t()
        )
        self.n = (
            torch.sum((self.n_weights @ self.gaussian_basis) * self.supports, dim=(1,)).t()
            + (self.n_biases @ self.supports).t()
        )
        self.wo = torch.sum((self.wo_weights @ self.gaussian_basis) * self.supports, dim=(1,)).t()
        self.wo_full = self.wo
        self.h0 = torch.sum((self.h0_weights @ self.gaussian_basis) * self.supports, dim=(0,))

    def forward(self, input):
        return simulation_loop(self, input)

    def clone(self):
        new_net = SupportLowRankRNN(
            self.input_size,
            self.hidden_size,
            self.output_size,
            self.noise_std,
            self.alpha,
            self.rank,
            self.n_supports,
            self.weights.tolist(),
            self.gaussian_basis_dim,
            self.m_weights,
            self.n_weights,
            self.wi_weights,
            self.wo_weights,
            self.m_biases,
            self.n_biases,
            self.wi_biases,
        )
        new_net.gaussian_basis.copy_(self.gaussian_basis)
        new_net._define_proxy_parameters()
        return new_net

    def load_state_dict(self, state_dict, strict=True):
        """
        override to recompute w_rec on loading
        """
        super().load_state_dict(state_dict, strict)
        self._define_proxy_parameters()

    def resample_basis(self):
        self.gaussian_basis.normal_()
        self._define_proxy_parameters()


class SupportLowRankRNN_withMask(nn.Module):
    """
    This network has been defined to train an arbitrary subset of the parameters offered by the SupportLowRankRNN
    by adding a mask.
    """

    def __init__(
        self,
        input_size,
        hidden_size,
        output_size,
        noise_std,
        alpha,
        rank=1,
        n_supports=1,
        gaussian_basis_dim=None,
        initial_m=None,
        initial_n=None,
        initial_unitm=None,
        initial_unitn=None,
        initial_wi=None,
        initial_unitwi=None,
        initial_wo=None,
        initial_h0=None,
        initial_unith0=None,
        initial_bias=None,
        train_h0=False,
        train_bias=False,
        initial_wi_mask=None,
        initial_wo_mask=None,
        initial_m_mask=None,
        initial_n_mask=None,
    ):
        super(SupportLowRankRNN_withMask, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.noise_std = noise_std
        self.alpha = alpha
        self.rank = rank
        self.n_supports = n_supports
        self.gaussian_basis_dim = (
            2 * rank + input_size if gaussian_basis_dim is None else gaussian_basis_dim
        )
        self.non_linearity = torch.tanh

        self.gaussian_basis = nn.Parameter(
            torch.randn((self.gaussian_basis_dim, hidden_size)), requires_grad=False
        )
        self.unit_vector = nn.Parameter(torch.ones((1, hidden_size)), requires_grad=False)
        self.supports = nn.Parameter(torch.zeros((n_supports, hidden_size)), requires_grad=False)
        l_support = hidden_size // n_supports
        for i in range(n_supports):
            self.supports[i, l_support * i : l_support * (i + 1)] = 1

        # Define parameters
        self.wi = nn.Parameter(torch.Tensor(input_size, n_supports, self.gaussian_basis_dim))
        self.unitwi = nn.Parameter(torch.Tensor(input_size, n_supports, 1))
        self.m = nn.Parameter(torch.Tensor(rank, n_supports, self.gaussian_basis_dim))
        self.n = nn.Parameter(torch.Tensor(rank, n_supports, self.gaussian_basis_dim))
        self.unitm = nn.Parameter(torch.Tensor(rank, n_supports, 1))
        self.unitn = nn.Parameter(torch.Tensor(rank, n_supports, 1))
        self.wo = nn.Parameter(torch.Tensor(output_size, n_supports, self.gaussian_basis_dim))
        self.h0 = nn.Parameter(torch.Tensor(n_supports, self.gaussian_basis_dim))
        self.unith0 = nn.Parameter(torch.Tensor(n_supports, 1))
        self.bias = nn.Parameter(torch.Tensor(n_supports, 1))

        self.wi_mask = nn.Parameter(
            torch.Tensor(input_size, n_supports, self.gaussian_basis_dim), requires_grad=False
        )
        self.unitwi_mask = nn.Parameter(
            torch.Tensor(input_size, n_supports, 1), requires_grad=False
        )
        self.m_mask = nn.Parameter(
            torch.Tensor(rank, n_supports, self.gaussian_basis_dim), requires_grad=False
        )
        self.n_mask = nn.Parameter(
            torch.Tensor(rank, n_supports, self.gaussian_basis_dim), requires_grad=False
        )
        self.unitm_mask = nn.Parameter(torch.Tensor(rank, n_supports, 1), requires_grad=False)
        self.unitn_mask = nn.Parameter(torch.Tensor(rank, n_supports, 1), requires_grad=False)
        self.wo_mask = nn.Parameter(
            torch.Tensor(output_size, n_supports, self.gaussian_basis_dim), requires_grad=False
        )
        self.h0_mask = nn.Parameter(
            torch.Tensor(n_supports, self.gaussian_basis_dim), requires_grad=False
        )
        self.unith0_mask = nn.Parameter(torch.Tensor(n_supports, 1), requires_grad=False)
        self.bias_mask = nn.Parameter(torch.Tensor(n_supports, 1), requires_grad=False)

        if not train_h0:
            self.h0.requires_grad = False
            self.unith0.requires_grad = False
        if not train_bias:
            self.bias.requires_grad = False

        # Initialize parameters
        with torch.no_grad():
            if initial_wi is not None:
                self.wi.copy_(initial_wi)
                if initial_wi_mask is not None:
                    maskc = initial_wi_mask
                else:
                    maskc = torch.where(
                        initial_wi != 0, torch.ones_like(initial_wi), torch.zeros_like(initial_wi)
                    )
                self.wi_mask.copy_(maskc)
            else:
                self.wi.zero_()
                self.wi_mask.zero_()
            if initial_unitwi is not None:
                self.unitwi.copy_(initial_unitwi)
                maskc = torch.where(
                    initial_unitwi != 0,
                    torch.ones_like(initial_unitwi),
                    torch.zeros_like(initial_unitwi),
                )
                self.unitwi_mask.copy_(maskc)
            else:
                self.unitwi.zero_()
                self.unitwi_mask.zero_()
            if initial_m is not None:
                self.m.copy_(initial_m)
                if initial_m_mask is not None:
                    maskc = initial_m_mask
                else:
                    maskc = torch.where(
                        initial_m != 0, torch.ones_like(initial_m), torch.zeros_like(initial_m)
                    )
                self.m_mask.copy_(maskc)
            else:
                self.m.zero_()
                self.m_mask.zero_()
            if initial_n is not None:
                self.n.copy_(initial_n)
                if initial_n_mask is not None:
                    maskc = initial_n_mask
                else:
                    maskc = torch.where(
                        initial_n != 0, torch.ones_like(initial_n), torch.zeros_like(initial_n)
                    )
                self.n_mask.copy_(maskc)
            else:
                self.n.zero_()
                self.n_mask.zero_()
            if initial_unitm is not None:
                self.unitm.copy_(initial_unitm)
                maskc = torch.where(
                    initial_unitm != 0,
                    torch.ones_like(initial_unitm),
                    torch.zeros_like(initial_unitm),
                )
                self.unitm_mask.copy_(maskc)
            else:
                self.unitm.zero_()
                self.unitm_mask.zero_()
            if initial_unitn is not None:
                self.unitn.copy_(initial_unitn)
                maskc = torch.where(
                    initial_unitn != 0,
                    torch.ones_like(initial_unitn),
                    torch.zeros_like(initial_unitn),
                )
                self.unitn_mask.copy_(maskc)
            else:
                self.unitn.zero_()
                self.unitn_mask.zero_()
            if initial_wo is not None:
                self.wo.copy_(initial_wo)
                if initial_wo_mask is not None:
                    maskc = initial_wo_mask
                else:
                    maskc = torch.where(
                        initial_wo != 0, torch.ones_like(initial_wo), torch.zeros_like(initial_wo)
                    )
                self.wo_mask.copy_(maskc)
            else:
                self.wo.zero_()
                self.wo_mask.zero_()
            if initial_h0 is not None:
                self.h0.copy_(initial_h0)
                maskc = torch.where(
                    initial_h0 != 0, torch.ones_like(initial_h0), torch.zeros_like(initial_h0)
                )
                self.h0_mask.copy_(maskc)
            else:
                self.h0.zero_()
                self.h0_mask.zero_()
            if initial_unith0 is not None:
                self.unith0.copy_(initial_unith0)
                maskc = torch.where(
                    initial_unith0 != 0,
                    torch.ones_like(initial_unith0),
                    torch.zeros_like(initial_unith0),
                )
                self.unith0_mask.copy_(maskc)
            else:
                self.unith0.zero_()
                self.unith0_mask.zero_()
            if initial_bias is not None:
                self.bias.copy_(initial_bias)
                maskc = torch.where(
                    initial_bias != 0, torch.ones_like(initial_bias), torch.zeros_like(initial_bias)
                )
                self.bias_mask.copy_(maskc)
            else:
                self.bias.zero_()
                self.bias_mask.zero_()

        (
            self.wi_full,
            self.m_rec,
            self.n_rec,
            self.wo_full,
            self.w_rec,
            self.h0_full,
            self.bias_full,
        ) = [None] * 7
        self.define_proxy_parameters()

    def define_proxy_parameters(self):
        self.wi_full = torch.sum(
            (self.wi @ self.gaussian_basis) * self.supports, dim=(1,)
        ) + torch.sum((self.unitwi @ self.unit_vector) * self.supports, dim=(1,))
        self.m_rec = (
            torch.sum((self.m @ self.gaussian_basis) * self.supports, dim=(1,)).t()
            + torch.sum((self.unitm @ self.unit_vector) * self.supports, dim=(1,)).t()
        )
        self.n_rec = (
            torch.sum((self.n @ self.gaussian_basis) * self.supports, dim=(1,)).t()
            + torch.sum((self.unitn @ self.unit_vector) * self.supports, dim=(1,)).t()
        )
        self.wo_full = torch.sum((self.wo @ self.gaussian_basis) * self.supports, dim=(1,)).t()
        self.w_rec = self.m_rec.matmul(self.n_rec.t())
        self.h0_full = torch.sum(
            (self.h0 @ self.gaussian_basis) * self.supports, dim=(0,)
        ) + torch.sum((self.unith0 @ self.unit_vector) * self.supports, dim=(0,))
        self.bias_full = torch.sum((self.bias @ self.unit_vector) * self.supports, dim=(0,))

    def forward(self, input):
        batch_size = input.shape[0]
        seq_len = input.shape[1]
        self.define_proxy_parameters()
        h = self.h0_full
        r = self.non_linearity(h)
        noise = torch.randn(batch_size, seq_len, self.hidden_size, device=self.m_rec.device)
        output = torch.zeros(batch_size, seq_len, self.output_size, device=self.m_rec.device)
        trajectories = torch.zeros(batch_size, seq_len, self.hidden_size, device=self.m_rec.device)

        # simulation loop
        for i in range(seq_len):
            h = (
                h
                + self.bias_full
                + self.noise_std * noise[:, i, :]
                + self.alpha * (-h + r.matmul(self.w_rec.t()) + input[:, i, :].matmul(self.wi_full))
            )

            r = self.non_linearity(h)
            output[:, i, :] = r.matmul(self.wo_full)
            trajectories[:, i, :] = h

        return output, trajectories

    def clone(self):
        new_net = SupportLowRankRNN_withMask(
            self.input_size,
            self.hidden_size,
            self.output_size,
            self.noise_std,
            self.alpha,
            self.rank,
            self.n_supports,
            self.gaussian_basis_dim,
            self.m,
            self.n,
            self.unitm,
            self.unitn,
            self.wi,
            self.unitwi,
            self.wo,
            self.h0,
            self.unith0,
            self.bias,
        )
        new_net.gaussian_basis.copy_(self.gaussian_basis)
        new_net.define_proxy_parameters()
        return new_net

    def load_state_dict(self, state_dict, strict=True):
        """
        override to recompute w_rec on loading
        """
        super().load_state_dict(state_dict, strict)
        self.define_proxy_parameters()

    def resample_basis(self):
        self.gaussian_basis.normal_()
        self.define_proxy_parameters()

    def orthogonalize_basis(self):
        for i in range(self.n_supports):
            gaussian_chunk = self.gaussian_basis[:, self.supports[i] == 1].view(
                self.gaussian_basis_dim, -1
            )
            gram_schmidt_pt(gaussian_chunk)
            self.gaussian_basis[:, self.supports[i] == 1] = gaussian_chunk
        self.gaussian_basis *= sqrt(self.hidden_size // self.n_supports)
        self.define_proxy_parameters()


def simulation_loop(model, input):
    batch_size = input.shape[0]
    seq_len = input.shape[1]
    h = model.h0
    r = model.non_linearity(h)

    noise = torch.randn(batch_size, seq_len, model.hidden_size, device=model.m.device)
    output = torch.zeros(batch_size, seq_len, model.output_size, device=model.m.device)
    trajectories = torch.zeros(batch_size, seq_len, model.hidden_size, device=model.m.device)

    for i in range(seq_len):
        h = (
            h
            + model.noise_std * noise[:, i, :]
            + model.alpha
            * (
                -h
                + r.matmul(model.n).matmul(model.m.t()) / model.hidden_size
                + input[:, i, :].matmul(model.wi_full)
            )
        )

        r = model.non_linearity(h)
        output[:, i, :] = r.matmul(model.wo_full) / model.hidden_size
        trajectories[:, i, :] = h

    return output, trajectories


class OptimizedLowRankRNN(nn.Module):
    """
    LowRankRNN class with a different definition of scalings (see caption of SI Fig. about the 3-population Ctx net)
    """

    def __init__(
        self,
        input_size,
        hidden_size,
        output_size,
        noise_std,
        alpha,
        rho=0.0,
        rank=1,
        train_wi=False,
        train_wo=False,
        train_wrec=True,
        train_h0=False,
        train_si=True,
        train_so=True,
        wi_init=None,
        wo_init=None,
        m_init=None,
        n_init=None,
        si_init=None,
        so_init=None,
        h0_init=None,
    ):
        """
        :param input_size: int
        :param hidden_size: int
        :param output_size: int
        :param noise_std: float
        :param alpha: float
        :param rho: float, std of quenched noise matrix
        :param rank: int
        :param train_wi: bool
        :param train_wo: bool
        :param train_wrec: bool
        :param train_h0: bool
        :param train_si: bool (can't be True if train_wi is already True)
        :param train_so: bool (can't be True if train_wo is already True)
        :param wi_init: torch tensor of shape (input_dim, hidden_size)
        :param wo_init: torch tensor of shape (hidden_size, output_dim)
        :param m_init: torch tensor of shape (hidden_size, rank)
        :param n_init: torch tensor of shape (hidden_size, rank)
        :param si_init: input scaling, torch tensor of shape (input_dim)
        :param so_init: output scaling, torch tensor of shape (output_dim)
        :param h0_init: torch tensor of shape (hidden_size)
        """
        super(OptimizedLowRankRNN, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.noise_std = noise_std
        self.alpha = alpha
        self.rho = rho
        self.rank = rank
        self.train_wi = train_wi
        self.train_wo = train_wo
        self.train_wrec = train_wrec
        self.train_h0 = train_h0
        self.train_si = train_si
        self.train_so = train_so
        self.non_linearity = torch.tanh

        # Define parameters
        self.wi = nn.Parameter(torch.Tensor(input_size, hidden_size))
        self.si = nn.Parameter(torch.Tensor(input_size))
        if train_wi:
            self.si.requires_grad = False
        else:
            self.wi.requires_grad = False
        if not train_si:
            self.si.requires_grad = False
        self.m = nn.Parameter(torch.Tensor(hidden_size, rank))
        self.n = nn.Parameter(torch.Tensor(hidden_size, rank))
        if not train_wrec:
            self.m.requires_grad = False
            self.n.requires_grad = False
        self.wo = nn.Parameter(torch.Tensor(hidden_size, output_size))
        self.so = nn.Parameter(torch.Tensor(output_size))
        if train_wo:
            self.so.requires_grad = False
        else:
            self.wo.requires_grad = False
        if not train_so:
            self.so.requires_grad = False
        self.h0 = nn.Parameter(torch.Tensor(hidden_size))
        if not train_h0:
            self.h0.requires_grad = False

        # Initialize parameters
        with torch.no_grad():
            if wi_init is None:
                self.wi.normal_()
            else:
                self.wi.copy_(wi_init)
            if si_init is None:
                self.si.set_(torch.ones_like(self.si))
            else:
                self.si.copy_(si_init)
            if m_init is None:
                self.m.normal_(std=1 / sqrt(hidden_size))
            else:
                self.m.copy_(m_init)
            if n_init is None:
                self.n.normal_(std=1 / sqrt(hidden_size))
            else:
                self.n.copy_(n_init)
            if wo_init is None:
                self.wo.normal_(std=2 / hidden_size)
            else:
                self.wo.copy_(wo_init)
            if so_init is None:
                self.so.set_(torch.ones_like(self.so))
            else:
                self.so.copy_(so_init)
            if h0_init is None:
                self.h0.zero_()
            else:
                self.h0.copy_(h0_init)
        self.wrec, self.wi_full, self.wo_full = [None] * 3
        self.define_proxy_parameters()

    def define_proxy_parameters(self):
        self.wi_full = (self.wi.t() * self.si).t()
        self.wo_full = self.wo * self.so

    def forward(self, input):
        """
        :param input: tensor of shape (batch_size, #timesteps, input_dimension)
        Important: the 3 dimensions need to be present, even if they are of size 1.
        :return: (output tensor, trajectories tensor of shape (batch_size, #timesteps, #hidden_units))
        """
        batch_size = input.shape[0]
        seq_len = input.shape[1]
        h = self.h0
        r = self.non_linearity(h)
        self.define_proxy_parameters()
        noise = torch.randn(batch_size, seq_len, self.hidden_size, device=self.m.device)
        output = torch.zeros(batch_size, seq_len, self.output_size, device=self.m.device)
        trajectories = torch.zeros(batch_size, seq_len + 1, self.hidden_size, device=self.m.device)
        trajectories[:, 0, :] = h

        # simulation loop
        for i in range(seq_len):
            h = (
                h
                + self.noise_std * noise[:, i, :]
                + self.alpha
                * (-h + r.matmul(self.n).matmul(self.m.t()) + input[:, i, :].matmul(self.wi_full))
            )

            r = self.non_linearity(h)
            output[:, i, :] = r.matmul(self.wo_full)
            trajectories[:, i + 1, :] = h

        return output, trajectories

    def clone(self):
        new_net = OptimizedLowRankRNN(
            self.input_size,
            self.hidden_size,
            self.output_size,
            self.noise_std,
            self.alpha,
            self.rho,
            self.rank,
            self.train_wi,
            self.train_wo,
            self.train_wrec,
            self.train_h0,
            self.train_si,
            self.train_so,
            self.wi,
            self.wo,
            self.m,
            self.n,
            self.si,
            self.so,
        )
        new_net.define_proxy_parameters()
        return new_net

    def resample_connectivity_noise(self):
        self.define_proxy_parameters()

    def load_state_dict(self, state_dict, strict=True):
        """
        override to recompute w_rec on loading
        """
        super().load_state_dict(state_dict, strict)
        self.define_proxy_parameters()

    def svd_reparametrization(self):
        """
        Orthogonalize m and n via SVD
        """
        with torch.no_grad():
            structure = (self.m @ self.n.t()).numpy()
            m, s, n = np.linalg.svd(structure, full_matrices=False)
            m, s, n = m[:, : self.rank], s[: self.rank], n[: self.rank, :]
            self.m.set_(torch.from_numpy(m * np.sqrt(s)))
            self.n.set_(torch.from_numpy(n.transpose() * np.sqrt(s)))
            self.define_proxy_parameters()