spike-encoding 0.1.0__py3-none-any.whl

spike_encoding/__init__.py

@@ -0,0 +1,2 @@
+from .delta_modulation_converter import DeltaModulationConverter
+from .step_forward_converter import StepForwardConverter

spike_encoding/base_converter.py

@@ -0,0 +1,14 @@
+import torch
+
+class BaseConverter(torch.nn.Module):
+    def __init__(self):
+        super(BaseConverter, self).__init__()
+
+    def encode(self, tensor):
+        raise NotImplementedError
+    
+    def decode(self, spikes: torch.Tensor):
+        raise NotImplementedError
+    
+    def optimize(self, data: torch.Tensor):
+        raise NotImplementedError

spike_encoding/bens_spiker_algorithm.py

@@ -0,0 +1,279 @@
+import torch
+from torch import Tensor
+from torchmetrics import MeanSquaredError
+from scipy.signal import firwin
+import optuna
+from optuna.samplers import TPESampler
+
+from spike_encoding.base_converter import BaseConverter
+
+
+class BensSpikerAlgorithm(BaseConverter):
+    def __init__(
+        self,
+        threshold: torch.Tensor = torch.tensor(
+            [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5], dtype=torch.float
+        ),
+        down_spike: bool = True,
+        min_value=None,
+        max_value=None,
+        scale_factor=None,
+        filter_order: torch.Tensor = torch.tensor(
+            [10, 10, 10, 10, 10, 10, 10], dtype=torch.int
+        ),
+        filter_cutoff: torch.Tensor = torch.tensor(
+            [0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2], dtype=torch.float
+        ),
+    ):
+        super().__init__()
+        if isinstance(threshold, (float, int)):
+            self.threshold = torch.tensor([threshold], dtype=torch.float)
+        elif isinstance(threshold, (list, tuple)):
+            self.threshold = torch.tensor(threshold, dtype=torch.float)
+        elif isinstance(threshold, torch.Tensor):
+            self.threshold = threshold.float()
+        else:
+            raise ValueError(
+                "threshold must be a float, int, list, tuple, or torch.Tensor"
+            )
+        self.down_spike = down_spike
+        self.min_value = min_value
+        self.max_value = max_value
+        self.scale_factor = scale_factor
+        if isinstance(filter_order, int):
+            self.filter_order = torch.tensor([filter_order], dtype=torch.int)
+        elif isinstance(filter_order, (list, tuple)):
+            self.filter_order = torch.tensor(filter_order, dtype=torch.int)
+        elif isinstance(filter_order, torch.Tensor):
+            self.filter_order = filter_order.int()
+        else:
+            raise ValueError("filter_order must be an int, list, tuple or torch.Tensor")
+
+        if isinstance(filter_cutoff, (float, int)):
+            self.filter_cutoff = torch.tensor([filter_cutoff], dtype=torch.float)
+        elif isinstance(filter_cutoff, (list, tuple)):
+            self.filter_cutoff = torch.tensor(filter_cutoff, dtype=torch.float)
+        elif isinstance(filter_cutoff, torch.Tensor):
+            self.filter_cutoff = filter_cutoff.float()
+        else:
+            raise ValueError(
+                "filter_cutoff must be a float, int, list, tuple, or torch.Tensor"
+            )
+
+    def encode(
+        self,
+        signal: torch.Tensor,
+        filter_order: torch.Tensor = torch.tensor([], dtype=torch.int),
+        filter_cutoff: torch.Tensor = torch.tensor([], dtype=torch.float),
+        threshold: torch.Tensor = torch.tensor([], dtype=torch.float),
+        isNormed: bool = False,
+    ):
+        """
+        Encodes a signal into spikes using an FIR filter and a threshold.
+
+        Args:
+            signal (torch.Tensor): The signal to be encoded as a tensor.
+            filter_order (torch.Tensor): possible to give a order, DEFAULT: 100
+            cutoff (torch.Tensor): the cutoff percentage for the FIR-filter. DEFAULT: 0.2
+            threshold (torch.Tensor): The threshold to generate spikes. DEFAULT: 0.5
+
+        Returns:
+            spikes (torch.Tensor): The encoded spikes as a tensor.
+        """
+        signal.squeeze_()
+        signal = torch.atleast_2d(signal)
+        if isNormed:
+            signal_norm = signal
+        else:
+            signal_norm = self.normalize_tensor(signal)
+
+        self.filter_order = (
+            self.filter_order if filter_order.numel() == 0 else filter_order
+        )
+        self.filter_cutoff = (
+            self.filter_cutoff if filter_cutoff.numel() == 0 else filter_cutoff
+        )
+        self.threshold = self.threshold if threshold.numel() == 0 else threshold
+
+        if (
+            len(self.filter_order) < len(signal)
+            or len(self.filter_cutoff) < len(signal)
+            or len(self.threshold) < len(signal)
+        ):
+            raise ValueError(
+                "filter_order, filter_cutoff and threshold must be a tensor of the same length as the input signal."
+            )
+        self.filter_order = self.filter_order[: len(signal)]
+        self.filter_cutoff = self.filter_cutoff[: len(signal)]
+        self.threshold = self.threshold[: len(signal)]
+
+        FIR = self.fir_filter()
+        num_rows, L = signal.shape
+
+        # print(f"Encoding {num_rows} signals with length {L}. filter_order={self.filter_order}, filter_cutoff={self.filter_cutoff}, threshold={self.threshold} \nfir_filter={FIR}")
+
+        spike_trains = torch.zeros(num_rows, L)
+
+        for row in range(num_rows):
+            F = len(FIR[row])
+
+            s = signal_norm[row]
+
+            out = torch.zeros(L)
+            for t in range(1, L):
+                err1 = 0
+                err2 = 0
+
+                for k in range(1, F):
+                    if t + k - 1 < L:
+                        err1 += torch.abs(s[t + k - 1] - FIR[row][k])
+                        err2 += torch.abs(s[t + k - 1])
+
+                if err1 <= err2 - self.threshold[row]:
+                    out[t] = 1
+                    for k in range(1, F):
+                        if t + k - 1 < L:
+                            s[t + k - 1] -= FIR[row][k]
+
+            spike_trains[row] = out
+
+        return spike_trains
+
+    def decode(self, spikes: torch.Tensor):
+
+        spikes.squeeze_()
+        spikes = torch.atleast_2d(spikes)
+
+        FIR = self.fir_filter()
+
+        feature_size = spikes.shape[0]
+        L = spikes.shape[1]
+
+        reconstructed_signals = torch.zeros((feature_size, L))
+
+        for row in range(feature_size):
+            spike_train = spikes[row].clone().detach()
+
+            out = torch.zeros(L)
+            F = len(FIR[row])
+            padding = F // 2
+            padded_input = torch.cat(
+                (torch.zeros(padding), spike_train, torch.zeros(padding))
+            )
+
+            for i in range(padding, L):
+                for j in range(F):
+                    if i + j < L + padding * 2:
+                        out[i] += padded_input[i + j - padding + 1] * FIR[row][j]
+
+            reconstructed_signals[row] = out
+
+        result_vector = []
+        for i in range(feature_size):
+            scaled_signal = (
+                reconstructed_signals[i] / self.scale_factor[i] + self.min_value[i]
+            )
+            result_vector.append(scaled_signal.tolist())
+
+        return result_vector
+
+    def optimize(
+        self,
+        data: torch.Tensor,
+        trials: int = 100,
+        error_function=MeanSquaredError(),
+        plot_history=False,
+    ):
+        """
+        Optimize the threshold and the cutoff persentage of the FIR-Filter of the encoding
+
+        Args:
+        - data (torch.Tensor): The given Signal
+
+        Returns:
+        - self.threshold: best threshold for the Singnal.
+        - self.filter_cutoff: best cutoff for the FIR-filter
+        """
+
+        if data.ndim > 2:
+            raise ValueError(
+                f"{type(self).__name__}.{self.optimize.__name__}() only supports input tensors with dimension <=2, but got dimension {data.ndim}."
+            )
+        data = torch.atleast_2d(data)
+        synth_sig = data  # self.normalize_tensor(data)
+        f_order = torch.zeros(len(synth_sig))
+        f_cutoff = torch.zeros(len(synth_sig))
+        _threshold = torch.zeros(len(synth_sig))
+
+        for i in range(len(synth_sig)):
+
+            def loss_function(trial):
+                filter_order = trial.suggest_int("filter_order", 35, 50)
+                filter_cutoff = trial.suggest_float(
+                    "filter_cutoff", 0.001, 0.25
+                )  # 0 < cutoff < fs/2
+                threshold = trial.suggest_float("threshold", 0.4, 1.1)
+                filter_order_T = torch.tensor([filter_order], dtype=torch.int)
+                filter_cutoff_T = torch.tensor([filter_cutoff], dtype=torch.float)
+                threshold_T = torch.tensor([threshold], dtype=torch.float)
+                encoded_signal = self.encode(
+                    synth_sig[i],
+                    filter_order=filter_order_T,
+                    filter_cutoff=filter_cutoff_T,
+                    threshold=threshold_T,
+                    isNormed=False,
+                )
+                decoded_signal = self.decode(encoded_signal)
+                loss = error_function(Tensor(decoded_signal)[0], data[i])
+
+                return loss
+
+            print(f"Optimizing for signal {i+1}/{len(synth_sig)}:")
+
+            optuna.logging.set_verbosity(optuna.logging.WARNING)  # hide logging
+            study = optuna.create_study(direction="minimize", sampler=TPESampler())
+            study.optimize(loss_function, n_trials=trials, show_progress_bar=True)
+            f_order[i] = study.best_params["filter_order"]
+            f_cutoff[i] = study.best_params["filter_cutoff"]
+            _threshold[i] = study.best_params["threshold"]
+
+            print(
+                f"best_order={f_order[i]}, best_cutoff={f_cutoff[i]}, best_threshold={_threshold[i]}"
+            )
+
+            if plot_history:
+                # Plot the optimization values
+                optuna.visualization.plot_optimization_history(study).show()
+                optuna.visualization.plot_slice(
+                    study, params=["filter_order", "filter_cutoff", "threshold"]
+                ).show()
+
+        self.filter_order = f_order.int()
+        self.filter_cutoff = f_cutoff.float()
+        self.threshold = _threshold.float()
+
+        return self.filter_order, self.filter_cutoff, self.threshold
+
+    def normalize_tensor(self, tensor):
+        """Normalize a tensor to the range between 0 and 1."""
+        self.min_value = torch.min(tensor, dim=1)[0]
+        self.max_value = torch.max(tensor, dim=1)[0]
+        self.scale_factor = 1.0 / (self.max_value - self.min_value)
+
+        normalized_tensor = torch.zeros(tensor.shape)
+        for i in range(len(tensor)):
+            normalized_tensor[i] = self.scale_factor[i] * (
+                tensor[i] - self.min_value[i]
+            )
+        return normalized_tensor
+
+    def fir_filter(self):
+        """set up the FIR-filter coefficents"""
+        filter_coeffs = []
+        for i in range(len(self.filter_order)):
+            fir = firwin(
+                self.filter_order[i].item() + 1, self.filter_cutoff[i].item(), fs=1.0
+            )  # fs=1.0 for normalized frequencies
+            filter_coeffs.append(torch.tensor(fir, dtype=torch.float32))
+
+        return filter_coeffs

spike_encoding/bin_encoder.py

@@ -0,0 +1,80 @@
+from typing import List, Literal, Union
+import numpy as np
+from numpy.typing import NDArray as ndarray
+import numpy.random as rndm
+
+from spike_encoding.base_converter import BaseConverter
+from spike_encoding.gymnasium_bounds_finder import ScalerFactory
+from spike_encoding.encoder_common import poisson, rate
+
+
+def gaussian_response(x, mu, sigma=0.3):
+    return np.exp(-np.power(x - mu, 2.0) / (2 * np.power(sigma, 2.0)))
+
+
+def transform_firing_rates(firing_rates, n_bins, sigma=0.3):
+    # Assuming firing rates are scaled to [0, 1]
+    bin_centers = np.linspace(0, 1, n_bins)
+    transformed_rates = []
+
+    for rate in firing_rates:
+        responses = [gaussian_response(rate, mu, sigma=sigma) for mu in bin_centers]
+        # Normalize the responses to sum to 1
+        normalized_responses = responses / np.sum(responses)
+        transformed_rates += normalized_responses.tolist()
+
+    return np.array(transformed_rates)
+
+
+class BinEncoder(BaseConverter):
+    """
+    This encoder creates spike trains from gymnasium observations. To use it, first install gymnasium https://gymnasium.farama.org/
+
+    Args:
+        seq_length: The number of timesteps in the spike train. E.g. [[1], [0], [1]] has a seq_length of 3
+        scaler: This is important for scaling inputs internally. For example, if your input goes up to 10, the scaler needs to scale instances with value 10 to a firing rate of 1.0
+        spike_train_conversion_method: determines how a firing rate is converted into a spike train. In poisson encoding, a firing rate of 0.1 means there is a 10% chance for any given timestep to be a spike. By chance there could be more or fewer spikes. If instead "deterministic" is chosen, you are guraranteed that 10% of timesteps are spikes
+        max_firing_rate: multiplier for maximum firing rate. typically the maximum is 1.0 (i.e. spikes at every step). You can set this to a lower value like 0.5 so on average you will only get a spike at every other step. This may be important for some R-STDP scenarios, where very high firing rates can impact synaptic tags
+
+
+    Returns:
+        spike train: an array of arrays of spikes.
+    """
+
+    spike_train_conversion_method: Literal["poisson", "deterministic"] = "poisson"
+
+    def __init__(
+        self,
+        seq_length: int,
+        min_values: Union[List[float], ndarray],
+        max_values: Union[List[float], ndarray],
+        spike_train_conversion_method: Literal["poisson", "deterministic"] = "poisson",
+        n_bins=10,
+        max_firing_rate=1.0,
+        sigma=0.1,
+    ):
+        self.sigma = sigma
+        self.seq_length = seq_length if seq_length <= 1 else seq_length
+        scaler_factory = ScalerFactory()
+        self.scaler = scaler_factory.from_known_values(min_values, max_values)
+        self.n_bins = n_bins
+        self.spike_train_conversion_method = spike_train_conversion_method
+        self.max_firing_rate = max_firing_rate
+
+        self.seed = 42
+        rndm.seed(self.seed)
+
+    def encode(self, state: ndarray) -> ndarray:
+        # NOTE this uses batches for scaling and coding, but not for binning
+        p_spikes = self.scaler.transform(np.atleast_2d(state))[0]
+        p_bins = np.atleast_2d(
+            [transform_firing_rates(p_spikes, self.n_bins, self.sigma)]
+        )
+        p_bins *= self.max_firing_rate
+
+        if self.spike_train_conversion_method == "poisson":
+            output = poisson(p_bins, self.seq_length)  # type: ignore
+        else:
+            output = rate(p_bins, self.seq_length)  # type: ignore
+
+        return output

spike_encoding/delta_modulation_converter.py

@@ -0,0 +1,52 @@
+import torch
+from .base_converter import BaseConverter
+
+
+
+class DeltaModulationConverter(BaseConverter):
+    """Encodes a tensor of input values by the difference bewteen two subsequent timesteps, and simulates the spikes that
+    occur when meets threshold.
+
+    Parameters:
+        delta (float): Input with a change greater than the thresold across one timestep will generate a spike, defaults to ``0.1``
+        padding (bool): If ``True``, the first time step will be compared with itself resulting in ``0``'s in spikes. If ``False``, it will be padded with ``0``'s, defaults to ``False``
+        off_spike: If ``True``, spikes for negative changes less than ``-threshold``, defaults to ``False``
+    """
+
+    def __init__(
+        self,
+        delta: float = 0.1,
+        normalized: bool = True,
+        padding: bool = False,
+        off_spike: bool = False,
+    ):
+        super(DeltaModulationConverter, self).__init__()
+        self.delta = delta
+        self.normalized = normalized
+        self.padding = padding
+        self.off_spike = off_spike
+
+    def forward(self, tensor):
+        if tensor.ndimension() < 2:
+            tensor = tensor.unsqueeze(0)
+        cols = torch.split(tensor, 1, 1)
+
+        if not self.normalized:
+            for i in range(tensor.shape[0]):
+                tensor[i] = (tensor[i] - torch.min(tensor[i])) / (torch.max(tensor[i]) - torch.min(tensor[i]))
+
+        if self.padding:
+            data_offset = torch.cat((cols[0], tensor), dim=1)[:, :-1]  # duplicate first time step, remove final step
+        else:
+            data_offset = torch.cat((torch.zeros_like(cols[0]), tensor), dim=1)[:,
+                          :-1]  # add 0's to first step, remove final step
+
+        if not self.off_spike:
+            return torch.stack((torch.ones_like(tensor) * ((tensor - data_offset) >= self.delta), torch.zeros_like(tensor)))
+        else:
+            on_spk = torch.ones_like(tensor) * ((tensor - data_offset) >= self.delta)
+            off_spk = -torch.ones_like(tensor) * ((tensor - data_offset) <= -self.delta)
+            return torch.stack((on_spk, off_spk))
+        
+    def decode(self, spikes: torch.Tensor):
+        raise NotImplementedError

spike_encoding/encoder_common.py

@@ -0,0 +1,31 @@
+from numpy.typing import NDArray as ndarray
+import numpy as np
+import numpy.random as rndm
+
+
+def poisson(spike_probabilities: ndarray, max_t: int) -> ndarray:
+    spikes = (
+        np.asarray(
+            [
+                spike_probabilities > rndm.random(spike_probabilities.shape)
+                for i in range(int(max_t))
+            ]
+        )
+        + 0
+    )
+
+    return spikes
+
+
+def rate(spike_probabilities: ndarray, max_t: int) -> ndarray:
+    spikes = np.zeros((max_t, *spike_probabilities.shape), dtype=int)
+
+    for index in np.ndindex(spike_probabilities.shape):
+        i = spike_probabilities[index]
+        idx = np.array(np.arange(max_t * i, 0, -1) / i, dtype=int) - 1
+        idx = np.clip(idx, 0, max_t - 1)  # Ensure indices are within bounds
+
+        # Use tuple unpacking to set the value at the specified indices
+        spikes[(idx,) + index] = 1
+
+    return spikes

spike_encoding/gymnasium_bounds_finder.py

@@ -0,0 +1,238 @@
+from typing import List, Union
+import gymnasium as gym
+import tqdm
+from joblib import Parallel, delayed
+import joblib
+from sklearn.preprocessing import MinMaxScaler
+from torch import Tensor
+import numpy as np
+import os
+from numpy.typing import NDArray as ndarray
+
+from .rate_step_forward_converter import RateStepForwardConverter as Converter
+
+
+def len_2(arr: ndarray) -> int:
+    return arr.shape[1]
+
+
+def get_runs(env_name: str, num_steps: int, workers: int, print_updates=False) -> list:
+    if print_updates:
+        print("Generating " + str(num_steps) + " random runs...")
+
+    def get_runs() -> list:
+        env = gym.make(env_name)
+        runs = []
+        for i in tqdm.tqdm(range(int(num_steps / workers))):
+            # Get the initial state of the environment
+            states = []
+            state, _ = env.reset()
+            done = False
+            trunc = False
+            while not (done or trunc):
+                states.append(state)
+                action = env.action_space.sample()
+                state, _, done, trunc, _ = env.step(action)
+
+            runs.append(np.array(states).swapaxes(0, 1))
+
+        return runs
+
+    if workers > 1:
+        results = Parallel(n_jobs=-1)(delayed(get_runs)() for i in [()] * workers)
+        runs = []
+        assert results is not None
+        for res in results:
+            runs.extend(res)
+    else:
+        runs = get_runs()
+
+    return runs
+
+
+def save_scaler(path: str, scaler: MinMaxScaler, print_updates=False) -> bool:
+    joblib.dump(scaler, path)
+    if print_updates:
+        print("Saved scaler at " + path)
+    return True
+
+
+def load_presaved_env_data(path: str, print_updates=False) -> MinMaxScaler:
+    scaler = joblib.load(path)
+    if print_updates:
+        print("Loaded scaler at " + path)
+    return scaler
+
+
+def save_treshold(path: str, treshold: Tensor, print_updates=False) -> bool:
+    with open(path, "w") as f:
+        f.write(str(treshold.tolist()))
+
+    if print_updates:
+        print("Saved thresholds at " + path)
+    return True
+
+
+def load_treshold(path: str, print_updates=False) -> Tensor:
+    with open(path, "r") as f:
+        for line in f:
+            th = line
+    threshold = [float(nr) for nr in th.split("[")[1].split("]")[0].split(",")]
+    if print_updates:
+        print("Loaded thresholds at " + path)
+    return Tensor(threshold)
+
+
+def get_path_from_dirs(dirs: list) -> str:
+    path = os.getcwd()
+
+    for dir_name in dirs:
+        path = os.path.join(path, dir_name)
+        if not os.path.exists(path):
+            os.mkdir(path)
+
+    return path
+
+
+class ScalerFactory:
+    workers = 64
+    num_steps = 1000
+
+    def __init__(
+        self,
+        print_updates=False,
+    ):
+        self.print_updates = print_updates
+
+    def has_presaved_env_data(self) -> bool:
+        return os.path.exists(self.scaler_path)
+
+    def from_env(self, env: gym.Env):
+        assert env.spec is not None
+        self.env_path = get_path_from_dirs(["data", "envs", env.spec.id])
+        self.scaler_path = os.path.join(self.env_path, "scaler.save")
+        if not self.has_presaved_env_data():
+            return self.run_env(env)
+        return load_presaved_env_data(self.scaler_path)
+
+    def from_known_values(
+        self, minima: Union[List[float], ndarray], maxima: Union[List[float], ndarray]
+    ):
+        scaler = MinMaxScaler()
+        data = np.concatenate(([minima], [maxima]), axis=0)
+        scaler.fit(data)
+        return scaler
+
+    def run_env(self, env: gym.Env):
+        assert env.spec is not None
+        runs = get_runs(env.spec.id, self.num_steps * 10, workers=self.workers)
+        scaler = self._optimize_scaler(runs)
+        save_scaler(self.scaler_path, scaler)
+        return scaler
+
+    def _optimize_scaler(self, runs: list) -> MinMaxScaler:
+        if self.print_updates:
+            print("Fitting scaler...")
+        # Fit data between 0 and 1
+        concat_runs = np.concatenate(runs, axis=1).swapaxes(0, 1)
+        # Balance upper and lower bounds
+        upper = (
+            np.concatenate([abs(concat_runs.min(axis=0)), concat_runs.max(axis=0)])
+            .reshape(-1, concat_runs.shape[1])
+            .max(axis=0)
+        )
+        lower = -upper
+        concat_runs = np.append(concat_runs, upper.reshape(1, -1), axis=0)
+        concat_runs = np.append(concat_runs, lower.reshape(1, -1), axis=0)
+
+        # absolute values generate spikes from the first time steps
+
+        # Multiplyier for modifying the upper and lower bounds
+        # Needs to be greater than 0
+        # A value between 0 and 1 makes the converter more sensitive, i.e. it will generate more spikes
+        # A value greater then 1 makes the converter less sensitive, i.e. it will generate less spikes
+        max_modifier: int = 1
+        concat_runs = concat_runs * max_modifier
+        scaler = MinMaxScaler().fit(concat_runs)
+
+        return scaler
+
+
+class ConverterFactory:
+    workers = 64
+    num_steps = 1000
+
+    def __init__(self, env: gym.Env, scaler: MinMaxScaler, print_updates=False):
+        self.env = env
+        self.print_updates = print_updates
+        self.scaler = scaler
+        assert env.observation_space.shape is not None
+        self.features = env.observation_space.shape[0]
+        assert env.spec is not None
+        self.env_path = get_path_from_dirs(["data", "envs", env.spec.id])
+        self.enc_path = os.path.join(self.env_path, "th.txt")
+        self.runs = []
+
+    def initialize(self, runs):
+        if len(runs) == 0:
+            assert self.env.spec is not None
+            runs = get_runs(self.env.spec.id, self.num_steps, workers=self.workers)
+        else:
+            runs = runs[: self.num_steps]
+
+        if self.print_updates:
+            print("Initializing encoder...")
+        conv = self._optimize_converter(runs)
+        th = conv.threshold
+        th_numpy = th.detach().numpy()
+        save_treshold(self.enc_path, th_numpy)
+        return conv, th_numpy
+
+    def generate(self):
+        if not self.initialized():
+            return self.initialize(self.runs)
+        else:
+            th = load_treshold(self.enc_path)
+            th_numpy = th.detach().numpy()
+            if self.print_updates:
+                print("Loaded existing encoder initialization at " + self.enc_path)
+            return Converter(self.features, th_numpy), th_numpy
+
+    def initialized(self) -> bool:
+        return os.path.exists(self.enc_path)
+
+    def _optimize_converter(self, runs: list) -> Converter:
+        # Sort runs by length
+        runs.sort(key=len_2)
+
+        if self.print_updates:
+            print("Normalizing data")
+
+        runs = [
+            self.scaler.transform(arr.swapaxes(0, 1)).swapaxes(0, 1) for arr in runs
+        ]
+
+        if self.print_updates:
+            print("Reshaping tensors...")
+
+        # Fill all arrays to the same length and stack along run dimension
+        max_len = runs[-1].shape[1]
+        runs_tensor = Tensor(
+            np.stack(
+                [
+                    np.append(
+                        arr,
+                        np.ones((self.features, max_len - arr.shape[1])) * np.inf,
+                        axis=1,
+                    )
+                    for arr in runs
+                ]
+            )
+        )
+
+        converter = Converter(self.features, np.ones(self.features) * 0.01)
+        if self.print_updates:
+            print("Optimizing converter tresholds...")
+        converter.optimize(runs_tensor)
+
+        return converter