diff --git a/sigllm/primitives/forecasting/huggingface.py b/sigllm/primitives/forecasting/huggingface.py
index 024e62c..677b17c 100644
--- a/sigllm/primitives/forecasting/huggingface.py
+++ b/sigllm/primitives/forecasting/huggingface.py
@@ -14,6 +14,7 @@
 DEFAULT_PAD_TOKEN = '<pad>'
 
 VALID_NUMBERS = list('0123456789')
+VALID_MULTIVARIATE_SYMBOLS = []
 
 DEFAULT_MODEL = 'mistralai/Mistral-7B-Instruct-v0.2'
 
@@ -53,6 +54,7 @@ def __init__(
         raw=False,
         samples=1,
         padding=0,
+        multivariate_allowed_symbols = [],
     ):
         self.name = name
         self.sep = sep
@@ -62,6 +64,7 @@ def __init__(
         self.raw = raw
         self.samples = samples
         self.padding = padding
+        self.multivariate_allowed_symbols = multivariate_allowed_symbols
 
         self.tokenizer = AutoTokenizer.from_pretrained(self.name, use_fast=False)
 
@@ -85,6 +88,9 @@ def __init__(
             token = self.tokenizer.convert_tokens_to_ids(number)
             valid_tokens.append(token)
 
+        for symbol in self.multivariate_allowed_symbols:
+            valid_tokens.append(self.tokenizer.convert_tokens_to_ids(symbol))
+
         valid_tokens.append(self.tokenizer.convert_tokens_to_ids(self.sep))
         self.invalid_tokens = [
             [i] for i in range(len(self.tokenizer) - 1) if i not in valid_tokens
@@ -116,7 +122,7 @@ def forecast(self, X, **kwargs):
             tokenized_input = self.tokenizer([text], return_tensors='pt').to('cuda')
 
             input_length = tokenized_input['input_ids'].shape[1]
-            average_length = input_length / len(text.split(','))
+            average_length = input_length / len(text.split(self.sep))
             max_tokens = (average_length + self.padding) * self.steps
 
             generate_ids = self.model.generate(
diff --git a/sigllm/primitives/formatting/__init__.py b/sigllm/primitives/formatting/__init__.py
new file mode 100644
index 0000000..1fa9933
--- /dev/null
+++ b/sigllm/primitives/formatting/__init__.py
@@ -0,0 +1,21 @@
+"""Multivariate formatting methods for time series data."""
+
+from sigllm.primitives.formatting.multivariate_formatting import MultivariateFormattingMethod
+from sigllm.primitives.formatting.json_format import JSONFormat
+from sigllm.primitives.formatting.univariate_control import UnivariateControl
+from sigllm.primitives.formatting.persistence_control import PersistenceControl
+from sigllm.primitives.formatting.value_concatenation import ValueConcatenation
+from sigllm.primitives.formatting.value_interleave import ValueInterleave
+from sigllm.primitives.formatting.digit_interleave import DigitInterleave
+
+__all__ = [
+    'MultivariateFormattingMethod',
+    'JSONFormat',
+    'UnivariateControl',
+    'PersistenceControl',
+    'ValueConcatenation',
+    'ValueInterleave',
+    'DigitInterleave',
+]
+
+
diff --git a/sigllm/primitives/formatting/digit_interleave.py b/sigllm/primitives/formatting/digit_interleave.py
new file mode 100644
index 0000000..d7b1806
--- /dev/null
+++ b/sigllm/primitives/formatting/digit_interleave.py
@@ -0,0 +1,72 @@
+from .multivariate_formatting import MultivariateFormattingMethod
+import numpy as np
+
+
+class DigitInterleave(MultivariateFormattingMethod):
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__("digit_interleave", verbose=verbose, **kwargs)
+
+
+    def format_as_string(self, data: np.ndarray, digits_per_timestamp = 3, separator = ",") -> str:     
+        max_digits = max(len(str(abs(int(v)))) for window in data for ts in window for v in ts)
+        width_used = max(digits_per_timestamp, max_digits)
+        self.metadata['width_used'] = width_used
+
+        def interleave_digits(timestamp):
+            str_values = [str(int(val)) for val in timestamp]
+            padded_values = [s.zfill(width_used) for s in str_values]
+            result_str = ''
+            for digit_pos in range(width_used):
+                for padded_val in padded_values:
+                    result_str += padded_val[digit_pos]
+
+            return result_str
+
+        result = [
+            separator.join(interleave_digits(timestamp) for timestamp in window) + separator
+            for window in data
+        ]
+        return result
+
+
+    def format_as_integer(self, data: list[str], separator = ",", trunc = None, digits_per_timestamp = 3) -> np.ndarray:
+        width_used = self.metadata['width_used']
+
+        def deinterleave_timestamp(interleaved_str):
+            """Convert interleaved digits back to original values"""
+            total_digits = len(interleaved_str)
+            num_values = total_digits // width_used
+
+            values = []
+            for value_idx in range(num_values):
+                value_digits = []
+                for digit_pos in range(width_used):
+                    pos = digit_pos * num_values + value_idx
+                    if pos < total_digits:
+                        value_digits.append(interleaved_str[pos])
+
+                if value_digits:
+                    values.append(int(''.join(value_digits)))
+
+            return np.array(values)[:trunc] if trunc else np.array(values)
+
+        result = np.array([
+            [
+                deinterleave_timestamp(timestamp)
+                for sample in entry
+                for timestamp in sample.lstrip(separator).rstrip(separator).split(separator)[:trunc]
+                if timestamp.strip()
+            ]
+            for entry in data
+        ], dtype=object)
+        return result
+
+
+
+if __name__ == "__main__":
+    method = DigitInterleave(digits_per_timestamp=3)
+    method.test_multivariate_formatting_validity(verbose=False)
+    errs, y_hat, y = method.run_pipeline(return_y_hat=True)
+    print(errs)
+    print(y_hat)
+    print(y)
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/json_format.py b/sigllm/primitives/formatting/json_format.py
new file mode 100644
index 0000000..1855a02
--- /dev/null
+++ b/sigllm/primitives/formatting/json_format.py
@@ -0,0 +1,99 @@
+from .multivariate_formatting import MultivariateFormattingMethod
+import numpy as np
+import re
+
+class JSONFormat(MultivariateFormattingMethod):
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__("json_format", verbose=verbose, **kwargs)
+
+    def format_as_string(self, data: np.ndarray, separator = ",") -> str:
+        def window_to_json(data):
+            rows = []
+            for row in data:
+                parts = [f"d{i}:{val}" for i, val in enumerate(row)]
+                rows.append(",".join(parts))
+            return ",".join(rows)
+        
+        out = [window_to_json(window) for window in data]
+        return out
+
+    def format_as_integer(self, data, trunc=None, steps_ahead=None):
+        """
+        Parse model output and extract d0 values for specified steps ahead.
+        
+        Args:
+            data: Model output containing tokens like "d0:1,d1:2,d0:3,d1:4..."
+            trunc: Legacy parameter for truncation (used when steps_ahead is None)
+            steps_ahead: List of step indices to extract (e.g., [1,3,5,10])
+                         If None, uses legacy behavior with trunc parameter.
+        
+        Returns:
+            If steps_ahead is None: np.array of shape (batch, samples) with truncated flat values
+            If steps_ahead is provided: dict mapping step -> np.array of d0 values at that step
+        """
+        if steps_ahead is None:
+            return self._format_as_integer_legacy(data, trunc)
+        
+        results_by_step = {step: [] for step in steps_ahead}
+        
+        for window in data:
+            step_samples = {step: [] for step in steps_ahead}
+            for sample in window:
+                d0_values = self._extract_d0_values(sample)
+                for step in steps_ahead:
+                    idx = step - 1
+                    if idx < len(d0_values):
+                        step_samples[step].append(d0_values[idx])
+                    else:
+                        step_samples[step].append(None)
+            for step in steps_ahead:
+                results_by_step[step].append(step_samples[step])
+        
+        for step in steps_ahead:
+            results_by_step[step] = np.array(results_by_step[step], dtype=object)
+        
+        return results_by_step
+
+    def _extract_d0_values(self, sample):
+        """
+        Extract all d0 values from a sample string in order.
+        For "d0:1,d1:2,d0:3,d1:4", returns [1, 3].
+        """
+        tokens = re.findall(r'd(\d+):(\d+)', sample)
+        d0_values = []
+        for dim_str, val_str in tokens:
+            if dim_str == "0":
+                d0_values.append(int(val_str))
+        return d0_values
+
+    def _format_as_integer_legacy(self, data, trunc=None):
+        """
+        Legacy format_as_integer behavior for backward compatibility.
+        """
+        batch_rows = []
+        for window in data:
+            samples = []
+            for sample in window:
+                tokens = re.findall(r'd\d+:\d+', sample)
+                flat, current = [], []
+                for token in tokens:
+                    key, val = token.split(":")
+                    if key == "d0" and current:
+                        flat.extend(current)
+                        current = []
+                    current.append(int(val))
+                if current:
+                    flat.extend(current)
+                if trunc:
+                    flat = flat[:trunc]
+                samples.append(flat)
+            batch_rows.append(samples)
+        return np.array(batch_rows, dtype=object)
+
+
+
+
+if __name__ == "__main__":
+    method = JSONFormat()
+    method.test_multivariate_formatting_validity(verbose=False)
+    method.run_pipeline(multivariate_allowed_symbols=["d", ":", ","])
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/multivariate_formatting.py b/sigllm/primitives/formatting/multivariate_formatting.py
new file mode 100644
index 0000000..027f489
--- /dev/null
+++ b/sigllm/primitives/formatting/multivariate_formatting.py
@@ -0,0 +1,227 @@
+import numpy as np
+from mlblocks import MLPipeline
+import pandas as pd
+import time
+class MultivariateFormattingMethod:
+    def __init__(self, method_name: str, verbose: bool = False, **kwargs):
+        self.method_name = method_name
+        self.config = kwargs
+        self.metadata = {}
+        self.verbose = verbose
+        
+        if self.method_name != "persistence_control":
+            self.test_multivariate_formatting_validity(verbose=verbose)
+
+
+    def format_as_string(self, data: np.ndarray, **kwargs) -> str:
+        raise NotImplementedError()
+
+
+    def format_as_integer(self, data: str, **kwargs) -> np.ndarray:
+        raise NotImplementedError()
+
+    
+    def normalize_data(self, df: pd.DataFrame) -> pd.DataFrame:
+        ts = df[["timestamp"]]
+        vals = df.drop(columns=["timestamp"])
+        normed = (vals - vals.mean(axis=0)) / vals.std(axis=0)
+        return pd.concat([ts, normed], axis=1)[df.columns] 
+
+
+    @staticmethod
+    def create_test_data(N = 25):
+        x1 = np.linspace(10, 9+N, N) / 100
+        x2 = np.array([i % 2 for i in range(N)])
+        x3 = np.linspace(N+40, 41, N) / 100
+
+        return pd.DataFrame({
+            'timestamp': np.linspace(0, 3600*(N-1), N),
+            'x1': x1,
+            'x2': x2,
+            'x3': x3,
+        })
+
+
+    def run_pipeline(self, data=create_test_data(), 
+                            interval=3600, 
+                            window_size=15, 
+                            verbose=True, 
+                            samples=7, 
+                            normalize=False, 
+                            temp=0.1, 
+                            return_y_hat = False, 
+                            multivariate_allowed_symbols = [],
+                            pipeline_name = 'mistral_detector',
+                            stride = 1,
+                            n_clusters = 2,
+                            strategy = 'scaling',
+                            steps_ahead = None):
+        """
+        Run the forecasting pipeline.
+        """
+        pipeline = MLPipeline(pipeline_name)
+        digits_per_timestamp = self.config.get('digits_per_timestamp', 2)
+        
+        num_dims = len(data.columns) - 1
+        
+        if steps_ahead is not None:
+            max_steps = max(steps_ahead)
+            hf_steps = max_steps * (num_dims + 1) # adding some padding here
+        else:
+            hf_steps = 2
+
+        test_hyperparameters = {
+            "mlstars.custom.timeseries_preprocessing.time_segments_aggregate#1": {
+                "interval": interval
+            },
+            "sigllm.primitives.forecasting.custom.rolling_window_sequences#1": {
+                "target_column": 0,
+                "window_size": window_size,
+                "target_size": max(steps_ahead) if steps_ahead else 1,
+                "step_size": stride,
+            },
+            "sigllm.primitives.forecasting.huggingface.HF#1": {
+                "samples": samples,
+                "temp": temp,
+                "multivariate_allowed_symbols": multivariate_allowed_symbols,
+                "steps": hf_steps,
+            },
+        }
+        
+        if strategy == 'binning':
+            test_hyperparameters["sigllm.primitives.transformation.Float2Scalar#1"] = {
+                "strategy": "binning",
+                "n_clusters": n_clusters,
+            }
+
+        elif strategy == 'scaling':
+            test_hyperparameters["sigllm.primitives.transformation.Float2Scalar#1"] = {
+                "decimal": digits_per_timestamp,
+                "rescale": True,
+            }
+        else:
+            raise ValueError(f"Invalid strategy: {strategy}")
+
+        print("STARTING PIPELINE: ")
+        time.sleep(10)
+
+        pipeline.set_hyperparameters(test_hyperparameters)
+        if normalize:
+            data = self.normalize_data(data)
+        context = pipeline.fit(data, start_=0, output_=3)
+        context['X'] = self.format_as_string(context['X'], **self.config)
+
+        if self.method_name == "persistence_control":
+            context['y_hat'] = context['X']
+            
+        else:
+            context = pipeline.fit(**context, start_=5, output_=5)
+        
+        if verbose:
+            print(f"y_hat example: {context['y_hat'][0][0]}")
+
+        if steps_ahead is not None:
+            return self._process_multi_step_results(
+                context, pipeline, steps_ahead, return_y_hat, verbose
+            )
+
+        context['y_hat'] = self.format_as_integer(context['y_hat'], trunc=1)
+        if verbose:
+            print(f"y_hat example: {context['y_hat'][0][0]}")
+        context = pipeline.fit(**context, start_=7, output_=10)
+
+        errors = np.round(context['errors'], 7)
+
+        if verbose:
+            print(f"y_hat: {context['y_hat']}")
+            print(f"y: {context['y']}")
+            print(f"errors: {errors}")
+
+        if return_y_hat:
+            return errors, context['y_hat'], context['y']
+        else:
+            return errors
+
+    def _process_multi_step_results(self, context, pipeline, steps_ahead, return_y_hat, verbose):
+        """
+        Process results for multi-step-ahead prediction.
+        
+        For multi-step predictions with stride > 1, we skip aggregate_rolling_window
+        since there's no overlap between predictions. Each window gives one prediction
+        per step, indexed sequentially (0, 1, 2, ...) regardless of actual stride.
+        
+        Returns:
+            dict {step : {'errors': [...], 'y_hat': [...], 'y': [...]}}
+        """
+        y_hat_by_step = self.format_as_integer(
+            context['y_hat'], steps_ahead=steps_ahead
+        )
+        
+        results = {}
+        
+        for step in steps_ahead:
+            step_context = context.copy()
+            
+            y_hat_step = y_hat_by_step[step]
+            y_hat_float = np.array([[v if v is not None else np.nan for v in row] for row in y_hat_step], dtype=float)
+            step_context['y_hat'] = np.expand_dims(y_hat_float, axis=-1)
+            step_context = pipeline.fit(**step_context, start_=7, output_=7)
+            # Aggregate across samples using median, then squeeze
+            y_hat_agg = np.nanmedian(step_context['y_hat'], axis=1).squeeze() 
+            
+            # Get ground truth for this step
+            y_for_step = context['y'][:, step - 1] if context['y'].ndim > 1 else context['y']
+            
+            # Compute errors directly (residuals)
+            errors = np.round(y_hat_agg - y_for_step, 7)
+            
+            if verbose:
+                print(f"Step {step} - y_hat shape: {y_hat_agg.shape}, errors shape: {errors.shape}")
+            
+            results[step] = {
+                'errors': errors,
+                'y_hat': y_hat_agg,
+                'y': y_for_step,
+            }
+        
+        if return_y_hat:
+            return results
+        else:
+            return {step: results[step]['errors'] for step in steps_ahead}
+    
+
+    def test_multivariate_formatting_validity(self, data=None, verbose=False):
+        if verbose:
+            print("Testing multivariate formatting method validity")
+
+        if data is None:
+            raw_data = np.array(self.create_test_data())[:, 1:]
+            windowed_data = np.array([raw_data[i:i+15,:] for i in range(0, len(raw_data)-15, 1)])
+            data = (1000 * windowed_data).astype(int)
+            if verbose:
+                print(data.shape)
+
+        string_data = self.format_as_string(data, **self.config)
+        LLM_mock_output = np.array(string_data).reshape(-1, 1)
+        if verbose:
+            print(LLM_mock_output)
+        integer_data = self.format_as_integer(LLM_mock_output, **self.config)
+        if verbose:
+            print(f"Format as string output: {string_data}")
+
+        assert isinstance(string_data, list)
+        assert isinstance(string_data[0], str)
+        assert isinstance(integer_data, np.ndarray)
+
+        if self.method_name == "univariate_control":
+            assert np.all(integer_data.flatten() == data[:, :, 0].flatten())
+        else:
+            assert np.all(integer_data.flatten() == data.flatten())
+
+        if verbose:
+            print("Validation suite passed")
+
+
+if __name__ == "__main__":
+    method = MultivariateFormattingMethod(method_name="test")
+    print(method.normalize_data(method.create_test_data()))
diff --git a/sigllm/primitives/formatting/persistence_control.py b/sigllm/primitives/formatting/persistence_control.py
new file mode 100644
index 0000000..d2e9f66
--- /dev/null
+++ b/sigllm/primitives/formatting/persistence_control.py
@@ -0,0 +1,27 @@
+from .multivariate_formatting import MultivariateFormattingMethod
+import numpy as np
+
+
+class PersistenceControl(MultivariateFormattingMethod):
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__("persistence_control", verbose=verbose, **kwargs)
+
+    def format_as_string(self, data: np.ndarray, separator = ",") -> str:
+        result = []
+        for row in data[:, :, 0]:
+            result.append(separator.join(map(str, row.flatten())))
+        return result
+
+    def format_as_integer(self, data: list[str], separator = ",", trunc = None) -> np.ndarray:
+        result = [
+            [np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[-1:]]
+            for entry in data
+        ]
+        out = np.array(result, dtype=object)
+        return out
+
+
+
+if __name__ == "__main__":
+    method = PersistenceControl()
+    method.run_pipeline(stride=5)
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/univariate_control.py b/sigllm/primitives/formatting/univariate_control.py
new file mode 100644
index 0000000..6694ac1
--- /dev/null
+++ b/sigllm/primitives/formatting/univariate_control.py
@@ -0,0 +1,29 @@
+from .multivariate_formatting import MultivariateFormattingMethod
+import numpy as np
+
+
+class UnivariateControl(MultivariateFormattingMethod):
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__("univariate_control", verbose=verbose, **kwargs)
+
+    def format_as_string(self, data: np.ndarray, separator = ",") -> str:
+        result = []
+        for row in data[:, :, 0]:
+            result.append(separator.join(map(str, row.flatten())))
+        return result
+
+    def format_as_integer(self, data: list[str], separator = ",", trunc = None) -> np.ndarray:
+        result = [
+            [np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[:trunc]
+            for entry in row]
+            for row in data
+        ]
+        out = np.array(result, dtype=object)
+        return out
+
+
+
+if __name__ == "__main__":
+    method = UnivariateControl()
+    method.test_multivariate_formatting_validity(verbose=False)
+    method.run_pipeline()
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/value_concatenation.py b/sigllm/primitives/formatting/value_concatenation.py
new file mode 100644
index 0000000..dbcca2e
--- /dev/null
+++ b/sigllm/primitives/formatting/value_concatenation.py
@@ -0,0 +1,29 @@
+from .multivariate_formatting import MultivariateFormattingMethod
+import numpy as np
+
+
+class ValueConcatenation(MultivariateFormattingMethod):
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__("value_concatenation", verbose=verbose, **kwargs)
+
+    def format_as_string(self, data: np.ndarray, separator = ",") -> str:
+        result = []
+        for row in data:
+            result.append(separator.join(map(str, row.flatten())))
+        return result
+
+    def format_as_integer(self, data: list[str], separator = ",", trunc = None) -> np.ndarray:
+        result = [
+            [np.array([int(x) for x in entry.lstrip(separator).split(separator) if x])[:trunc]
+            for entry in row]
+            for row in data
+        ]
+        out = np.array(result, dtype=object)
+        return out
+
+
+
+if __name__ == "__main__":
+    method = ValueConcatenation()
+    method.test_multivariate_formatting_validity(verbose=False)
+    method.run_pipeline()
\ No newline at end of file
diff --git a/sigllm/primitives/formatting/value_interleave.py b/sigllm/primitives/formatting/value_interleave.py
new file mode 100644
index 0000000..a536d05
--- /dev/null
+++ b/sigllm/primitives/formatting/value_interleave.py
@@ -0,0 +1,45 @@
+from .multivariate_formatting import MultivariateFormattingMethod
+import numpy as np
+
+
+class ValueInterleave(MultivariateFormattingMethod):
+    def __init__(self, verbose: bool = False, **kwargs):
+        super().__init__("value_interleave", verbose=verbose, **kwargs)
+
+
+    def format_as_string(self, data: np.ndarray, digits_per_timestamp = 3, separator = ",") -> str:
+        max_digits = max(len(str(abs(int(v)))) for window in data for ts in window for v in ts)
+        width_used = max(digits_per_timestamp, max_digits)
+        self.metadata['width_used'] = width_used    
+        result = [
+            separator.join(''.join(str(int(val)).zfill(width_used)[:width_used] for val in timestamp)
+            for timestamp in window) + separator
+            for window in data
+        ]
+        return result
+
+    def format_as_integer(self, data: list[str], separator = ",", trunc = None, digits_per_timestamp = 3) -> np.ndarray:
+        width_used = self.metadata['width_used']
+        
+        def parse_timestamp(timestamp):
+            return np.array([int(timestamp[i:i+width_used]) for i in range(0, len(timestamp), width_used)])[:trunc]
+
+        result = np.array([
+            [
+                parse_timestamp(timestamp)
+                for sample in entry
+                for timestamp in sample.lstrip(separator).rstrip(separator).split(separator)[:trunc]
+            ]
+            for entry in data
+        ], dtype=object)
+
+        if result.ndim == 2:
+            result = np.expand_dims(result, axis=-1)
+        return result
+
+
+
+if __name__ == "__main__":
+    method = ValueInterleave(digits_per_timestamp=4)
+    method.test_multivariate_formatting_validity(verbose=False)
+    method.run_pipeline()
\ No newline at end of file
diff --git a/tutorials/pipelines/detector-pipeline.ipynb b/tutorials/pipelines/detector-pipeline.ipynb
index 60fa97a..33df425 100644
--- a/tutorials/pipelines/detector-pipeline.ipynb
+++ b/tutorials/pipelines/detector-pipeline.ipynb
@@ -52,7 +52,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -81,14 +81,25 @@
    "execution_count": 4,
    "id": "a7182e87-367e-4b5e-95b5-f319b4af519a",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# start = 900\n",
-    "# end = start + 200\n",
+    "start = 900\n",
+    "end = start + 200\n",
     "\n",
-    "# data = data.iloc[start: end]\n",
+    "data = data.iloc[start: end]\n",
     "\n",
-    "# plt.plot(data['value']);"
+    "plt.plot(data['value']);"
    ]
   },
   {
@@ -106,18 +117,18 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "93acd20c7f95460786b61d88af29aaef",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Loading checkpoint shards:   0%|          | 0/3 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-09-02 11:00:36.285384: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
+      "2025-09-02 11:00:36.318090: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "2025-09-02 11:00:36.318119: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "2025-09-02 11:00:36.318149: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "2025-09-02 11:00:36.325125: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+      "To enable the following instructions: AVX2 AVX512F FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+      "2025-09-02 11:00:37.000447: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
+      "Loading checkpoint shards: 100%|██████████| 3/3 [00:04<00:00,  1.46s/it]\n"
+     ]
     }
    ],
    "source": [
@@ -135,18 +146,12 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "3988b70e468347a589bd06694bdb7ad1",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "Loading checkpoint shards:   0%|          | 0/3 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards: 100%|██████████| 3/3 [00:02<00:00,  1.00it/s]\n",
+      "Some parameters are on the meta device because they were offloaded to the cpu.\n"
+     ]
     }
    ],
    "source": [
@@ -257,11 +262,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "entry at 1309471201 has value [0.4010481]\n",
-      "entry at 1309474801 has value [0.39271888]\n",
-      "entry at 1309478401 has value [0.30999612]\n",
-      "entry at 1309482001 has value [0.21293855]\n",
-      "entry at 1309485601 has value [0.20580091]\n"
+      "entry at 1312714801 has value [0.58756715]\n",
+      "entry at 1312718401 has value [0.49446836]\n",
+      "entry at 1312722001 has value [0.48571948]\n",
+      "entry at 1312725601 has value [0.34325765]\n",
+      "entry at 1312729201 has value [0.32660771]\n"
      ]
     }
    ],
@@ -279,7 +284,7 @@
     {
      "data": {
       "text/plain": [
-       "(1648, 1)"
+       "(204, 1)"
       ]
      },
      "execution_count": 10,
@@ -379,11 +384,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "entry at 1309471201 has value [40]\n",
-      "entry at 1309474801 has value [39]\n",
-      "entry at 1309478401 has value [30]\n",
-      "entry at 1309482001 has value [21]\n",
-      "entry at 1309485601 has value [20]\n"
+      "entry at 1312714801 has value [55]\n",
+      "entry at 1312718401 has value [45]\n",
+      "entry at 1312722001 has value [44]\n",
+      "entry at 1312725601 has value [30]\n",
+      "entry at 1312729201 has value [29]\n"
      ]
     }
    ],
@@ -401,7 +406,7 @@
     {
      "data": {
       "text/plain": [
-       "0.000385004945833"
+       "0.0360733895514"
       ]
      },
      "execution_count": 14,
@@ -465,10 +470,10 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "X shape = (1508, 140, 1)\n",
-      "y shape = (1508, 1)\n",
-      "X index shape = (1508,)\n",
-      "y index shape = (1508,)\n"
+      "X shape = (64, 140, 1)\n",
+      "y shape = (64, 1)\n",
+      "X index shape = (64,)\n",
+      "y index shape = (64,)\n"
      ]
     }
    ],
@@ -526,7 +531,7 @@
     {
      "data": {
       "text/plain": [
-       "'40,39,30,21,20,25,30,29,53,78,74,73,69,68,51,51,51,41,24,30,27,26,23,26,32,25,21,16,21,30,28,39,58,59,71,78,73,68,72,52,40,34,27,27,34,28,32,25,20,20,17,13,17,27,24,34,67,62,60,59,71,63,56,43,36,30,26,24,24,20,20,23,17,19,16,14,12,16,21,28,47,54,50,53,60,51,52,42,32,34,24,24,21,21,22,25,22,16,17,12,13,17,22,27,44,47,54,66,54,58,42,39,36,32,27,23,21,21,19,24,22,19,13,11,15,20,22,28,47,64,52,57,57,51,40,44,36,35,28,24'"
+       "'The following series is formatted with each time step in parentheses and each dimension separated by a comma: 55,45,44,30,29,25,21,23,14,16,14,12,11,8,5,8,13,12,27,50,39,46,60,51,43,45,40,33,27,33,26,14,19,19,18,13,10,9,8,8,12,14,26,51,40,49,42,44,40,30,12,41,45,26,22,23,22,25,16,14,14,11,8,9,15,21,27,31,48,42,51,41,44,44,55,33,91,62,14,17,29,26,20,17,14,11,10,12,17,25,40,42,54,64,50,61,47,53,44,37,33,0,28,30,36,27,26,23,19,15,10,17,22,21,24,101,51,51,57,54,55,51,45,37,30,24,28,26,21,21,21,21,22,18,12,17,21,24,38,50'"
       ]
      },
      "execution_count": 18,
@@ -572,24 +577,105 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "  0%|          | 0/1508 [00:00<?, ?it/s]2024-09-12 14:17:03.223415: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
-      "2024-09-12 14:17:03.223451: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
-      "2024-09-12 14:17:03.223477: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
-      "2024-09-12 14:17:03.229402: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
-      "To enable the following instructions: AVX2 AVX512F FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
-      "2024-09-12 14:17:03.917982: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
-      "100%|██████████| 1508/1508 [31:20<00:00,  1.25s/it]\n"
+      "  0%|          | 0/64 [00:00<?, ?it/s]"
      ]
     },
     {
-     "data": {
-      "text/plain": [
-       "dict_keys(['index', 'minimum', 'decimal', 'target_index', 'X', 'y', 'y_hat'])"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/64 [00:00<?, ?it/s]\n",
+      "Exception caught producing MLBlock sigllm.primitives.forecasting.huggingface.HF#1\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlpipeline.py\", line 679, in _produce_block\n",
+      "    block_outputs = block.produce(**produce_args)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlblock.py\", line 331, in produce\n",
+      "    return getattr(self.instance, self.produce_method)(**produce_kwargs)\n",
+      "  File \"/home/baranov/projects/sigllm/sigllm/primitives/forecasting/huggingface.py\", line 129, in forecast\n",
+      "    generate_ids = self.model.generate(\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/utils/_contextlib.py\", line 116, in decorate_context\n",
+      "    return func(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/generation/utils.py\", line 2629, in generate\n",
+      "    result = self._sample(\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/generation/utils.py\", line 3610, in _sample\n",
+      "    outputs = self(**model_inputs, return_dict=True)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
+      "    return self._call_impl(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
+      "    return forward_call(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py\", line 175, in new_forward\n",
+      "    output = module._old_forward(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/utils/generic.py\", line 959, in wrapper\n",
+      "    output = func(self, *args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py\", line 434, in forward\n",
+      "    outputs: BaseModelOutputWithPast = self.model(\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
+      "    return self._call_impl(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
+      "    return forward_call(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/utils/generic.py\", line 1083, in wrapper\n",
+      "    outputs = func(self, *args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py\", line 364, in forward\n",
+      "    hidden_states = decoder_layer(\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/modeling_layers.py\", line 94, in __call__\n",
+      "    return super().__call__(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
+      "    return self._call_impl(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
+      "    return forward_call(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py\", line 175, in new_forward\n",
+      "    output = module._old_forward(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py\", line 228, in forward\n",
+      "    hidden_states, _ = self.self_attn(\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1736, in _wrapped_call_impl\n",
+      "    return self._call_impl(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py\", line 1747, in _call_impl\n",
+      "    return forward_call(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py\", line 175, in new_forward\n",
+      "    output = module._old_forward(*args, **kwargs)\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py\", line 167, in forward\n",
+      "    attn_output, attn_weights = attention_interface(\n",
+      "  File \"/home/baranov/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/integrations/sdpa_attention.py\", line 89, in sdpa_attention_forward\n",
+      "    attn_output = torch.nn.functional.scaled_dot_product_attention(\n",
+      "torch.OutOfMemoryError: CUDA out of memory. Tried to allocate 48.00 MiB. GPU 1 has a total capacity of 23.46 GiB of which 43.88 MiB is free. Process 691488 has 13.78 GiB memory in use. Including non-PyTorch memory, this process has 9.61 GiB memory in use. Of the allocated memory 9.39 GiB is allocated by PyTorch, and 30.19 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)\n"
+     ]
+    },
+    {
+     "ename": "OutOfMemoryError",
+     "evalue": "CUDA out of memory. Tried to allocate 48.00 MiB. GPU 1 has a total capacity of 23.46 GiB of which 43.88 MiB is free. Process 691488 has 13.78 GiB memory in use. Including non-PyTorch memory, this process has 9.61 GiB memory in use. Of the allocated memory 9.39 GiB is allocated by PyTorch, and 30.19 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mOutOfMemoryError\u001b[0m                          Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[19], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m step \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m\n\u001b[0;32m----> 2\u001b[0m context \u001b[38;5;241m=\u001b[39m \u001b[43mpipeline\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mcontext\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstart_\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutput_\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      3\u001b[0m context\u001b[38;5;241m.\u001b[39mkeys()\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlpipeline.py:805\u001b[0m, in \u001b[0;36mMLPipeline.fit\u001b[0;34m(self, X, y, output_, start_, debug, **kwargs)\u001b[0m\n\u001b[1;32m    802\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_fit_block(block, block_name, context, debug_info)\n\u001b[1;32m    804\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m fit_pending \u001b[38;5;129;01mor\u001b[39;00m output_blocks:\n\u001b[0;32m--> 805\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_produce_block\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    806\u001b[0m \u001b[43m        \u001b[49m\u001b[43mblock\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mblock_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutput_variables\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moutputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdebug_info\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    808\u001b[0m     \u001b[38;5;66;03m# We already captured the output from this block\u001b[39;00m\n\u001b[1;32m    809\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m block_name \u001b[38;5;129;01min\u001b[39;00m output_blocks:\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlpipeline.py:679\u001b[0m, in \u001b[0;36mMLPipeline._produce_block\u001b[0;34m(self, block, block_name, context, output_variables, outputs, debug_info)\u001b[0m\n\u001b[1;32m    677\u001b[0m memory_before \u001b[38;5;241m=\u001b[39m process\u001b[38;5;241m.\u001b[39mmemory_info()\u001b[38;5;241m.\u001b[39mrss\n\u001b[1;32m    678\u001b[0m start \u001b[38;5;241m=\u001b[39m datetime\u001b[38;5;241m.\u001b[39mutcnow()\n\u001b[0;32m--> 679\u001b[0m block_outputs \u001b[38;5;241m=\u001b[39m \u001b[43mblock\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mproduce\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mproduce_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    680\u001b[0m elapsed \u001b[38;5;241m=\u001b[39m datetime\u001b[38;5;241m.\u001b[39mutcnow() \u001b[38;5;241m-\u001b[39m start\n\u001b[1;32m    681\u001b[0m memory_after \u001b[38;5;241m=\u001b[39m process\u001b[38;5;241m.\u001b[39mmemory_info()\u001b[38;5;241m.\u001b[39mrss\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/mlblocks/mlblock.py:331\u001b[0m, in \u001b[0;36mMLBlock.produce\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m    329\u001b[0m produce_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_get_method_kwargs(produce_kwargs, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mproduce_args)\n\u001b[1;32m    330\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_class:\n\u001b[0;32m--> 331\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minstance\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mproduce_method\u001b[49m\u001b[43m)\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mproduce_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    333\u001b[0m produce_kwargs\u001b[38;5;241m.\u001b[39mupdate(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_hyperparameters())\n\u001b[1;32m    334\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprimitive(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mproduce_kwargs)\n",
+      "File \u001b[0;32m~/projects/sigllm/sigllm/primitives/forecasting/huggingface.py:129\u001b[0m, in \u001b[0;36mHF.forecast\u001b[0;34m(self, X, **kwargs)\u001b[0m\n\u001b[1;32m    126\u001b[0m average_length \u001b[38;5;241m=\u001b[39m input_length \u001b[38;5;241m/\u001b[39m \u001b[38;5;28mlen\u001b[39m(text\u001b[38;5;241m.\u001b[39msplit(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m,\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[1;32m    127\u001b[0m max_tokens \u001b[38;5;241m=\u001b[39m (average_length \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpadding) \u001b[38;5;241m*\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msteps\n\u001b[0;32m--> 129\u001b[0m generate_ids \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    130\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtokenized_input\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    131\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdo_sample\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    132\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmax_new_tokens\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmax_tokens\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    133\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtemperature\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtemp\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    134\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtop_p\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtop_p\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    135\u001b[0m \u001b[43m    \u001b[49m\u001b[43mbad_words_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minvalid_tokens\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    136\u001b[0m \u001b[43m    \u001b[49m\u001b[43mrenormalize_logits\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    137\u001b[0m \u001b[43m    \u001b[49m\u001b[43mnum_return_sequences\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msamples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    138\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    140\u001b[0m responses \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtokenizer\u001b[38;5;241m.\u001b[39mbatch_decode(\n\u001b[1;32m    141\u001b[0m     generate_ids[:, input_length:],\n\u001b[1;32m    142\u001b[0m     skip_special_tokens\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m,\n\u001b[1;32m    143\u001b[0m     clean_up_tokenization_spaces\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m    144\u001b[0m )\n\u001b[1;32m    146\u001b[0m all_responses\u001b[38;5;241m.\u001b[39mappend(responses)\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/utils/_contextlib.py:116\u001b[0m, in \u001b[0;36mcontext_decorator.<locals>.decorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    113\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m    114\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m    115\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m ctx_factory():\n\u001b[0;32m--> 116\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/generation/utils.py:2629\u001b[0m, in \u001b[0;36mGenerationMixin.generate\u001b[0;34m(self, inputs, generation_config, logits_processor, stopping_criteria, prefix_allowed_tokens_fn, synced_gpus, assistant_model, streamer, negative_prompt_ids, negative_prompt_attention_mask, use_model_defaults, custom_generate, **kwargs)\u001b[0m\n\u001b[1;32m   2621\u001b[0m     input_ids, model_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_expand_inputs_for_generation(\n\u001b[1;32m   2622\u001b[0m         input_ids\u001b[38;5;241m=\u001b[39minput_ids,\n\u001b[1;32m   2623\u001b[0m         expand_size\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mnum_return_sequences,\n\u001b[1;32m   2624\u001b[0m         is_encoder_decoder\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39mis_encoder_decoder,\n\u001b[1;32m   2625\u001b[0m         \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_kwargs,\n\u001b[1;32m   2626\u001b[0m     )\n\u001b[1;32m   2628\u001b[0m     \u001b[38;5;66;03m# 12. run sample (it degenerates to greedy search when `generation_config.do_sample=False`)\u001b[39;00m\n\u001b[0;32m-> 2629\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_sample\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   2630\u001b[0m \u001b[43m        \u001b[49m\u001b[43minput_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2631\u001b[0m \u001b[43m        \u001b[49m\u001b[43mlogits_processor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprepared_logits_processor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2632\u001b[0m \u001b[43m        \u001b[49m\u001b[43mstopping_criteria\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprepared_stopping_criteria\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2633\u001b[0m \u001b[43m        \u001b[49m\u001b[43mgeneration_config\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgeneration_config\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2634\u001b[0m \u001b[43m        \u001b[49m\u001b[43msynced_gpus\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msynced_gpus\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2635\u001b[0m \u001b[43m        \u001b[49m\u001b[43mstreamer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstreamer\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2636\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmodel_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2637\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2639\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m generation_mode \u001b[38;5;129;01min\u001b[39;00m (GenerationMode\u001b[38;5;241m.\u001b[39mBEAM_SAMPLE, GenerationMode\u001b[38;5;241m.\u001b[39mBEAM_SEARCH):\n\u001b[1;32m   2640\u001b[0m     \u001b[38;5;66;03m# 11. interleave input_ids with `num_beams` additional sequences per batch\u001b[39;00m\n\u001b[1;32m   2641\u001b[0m     input_ids, model_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_expand_inputs_for_generation(\n\u001b[1;32m   2642\u001b[0m         input_ids\u001b[38;5;241m=\u001b[39minput_ids,\n\u001b[1;32m   2643\u001b[0m         expand_size\u001b[38;5;241m=\u001b[39mgeneration_config\u001b[38;5;241m.\u001b[39mnum_beams,\n\u001b[1;32m   2644\u001b[0m         is_encoder_decoder\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39mis_encoder_decoder,\n\u001b[1;32m   2645\u001b[0m         \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mmodel_kwargs,\n\u001b[1;32m   2646\u001b[0m     )\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/generation/utils.py:3610\u001b[0m, in \u001b[0;36mGenerationMixin._sample\u001b[0;34m(self, input_ids, logits_processor, stopping_criteria, generation_config, synced_gpus, streamer, **model_kwargs)\u001b[0m\n\u001b[1;32m   3607\u001b[0m model_inputs\u001b[38;5;241m.\u001b[39mupdate({\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moutput_hidden_states\u001b[39m\u001b[38;5;124m\"\u001b[39m: output_hidden_states} \u001b[38;5;28;01mif\u001b[39;00m output_hidden_states \u001b[38;5;28;01melse\u001b[39;00m {})\n\u001b[1;32m   3609\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_prefill:\n\u001b[0;32m-> 3610\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mmodel_inputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreturn_dict\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m   3611\u001b[0m     is_prefill \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m   3612\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py:175\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[0;34m(module, *args, **kwargs)\u001b[0m\n\u001b[1;32m    173\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    174\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 175\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_old_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    176\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/utils/generic.py:959\u001b[0m, in \u001b[0;36mcan_return_tuple.<locals>.wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    957\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m return_dict_passed \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    958\u001b[0m     return_dict \u001b[38;5;241m=\u001b[39m return_dict_passed\n\u001b[0;32m--> 959\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    960\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m return_dict \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(output, \u001b[38;5;28mtuple\u001b[39m):\n\u001b[1;32m    961\u001b[0m     output \u001b[38;5;241m=\u001b[39m output\u001b[38;5;241m.\u001b[39mto_tuple()\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py:434\u001b[0m, in \u001b[0;36mMistralForCausalLM.forward\u001b[0;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, labels, use_cache, cache_position, logits_to_keep, **kwargs)\u001b[0m\n\u001b[1;32m    402\u001b[0m \u001b[38;5;129m@can_return_tuple\u001b[39m\n\u001b[1;32m    403\u001b[0m \u001b[38;5;129m@auto_docstring\u001b[39m\n\u001b[1;32m    404\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    415\u001b[0m     \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: Unpack[TransformersKwargs],\n\u001b[1;32m    416\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m CausalLMOutputWithPast:\n\u001b[1;32m    417\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    418\u001b[0m \u001b[38;5;124;03m    Example:\u001b[39;00m\n\u001b[1;32m    419\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    432\u001b[0m \u001b[38;5;124;03m    \"Hey, are you conscious? Can you talk to me?\\nI'm not conscious, but I can talk to you.\"\u001b[39;00m\n\u001b[1;32m    433\u001b[0m \u001b[38;5;124;03m    ```\"\"\"\u001b[39;00m\n\u001b[0;32m--> 434\u001b[0m     outputs: BaseModelOutputWithPast \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    435\u001b[0m \u001b[43m        \u001b[49m\u001b[43minput_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minput_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    436\u001b[0m \u001b[43m        \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    437\u001b[0m \u001b[43m        \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    438\u001b[0m \u001b[43m        \u001b[49m\u001b[43mpast_key_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_values\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    439\u001b[0m \u001b[43m        \u001b[49m\u001b[43minputs_embeds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minputs_embeds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    440\u001b[0m \u001b[43m        \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    441\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcache_position\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_position\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    442\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    443\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    445\u001b[0m     hidden_states \u001b[38;5;241m=\u001b[39m outputs\u001b[38;5;241m.\u001b[39mlast_hidden_state\n\u001b[1;32m    446\u001b[0m     \u001b[38;5;66;03m# Only compute necessary logits, and do not upcast them to float if we are not computing the loss\u001b[39;00m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/utils/generic.py:1083\u001b[0m, in \u001b[0;36mcheck_model_inputs.<locals>.wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1080\u001b[0m                 module\u001b[38;5;241m.\u001b[39mforward \u001b[38;5;241m=\u001b[39m make_capture_wrapper(module, original_forward, key, specs\u001b[38;5;241m.\u001b[39mindex)\n\u001b[1;32m   1081\u001b[0m                 monkey_patched_layers\u001b[38;5;241m.\u001b[39mappend((module, original_forward))\n\u001b[0;32m-> 1083\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1084\u001b[0m \u001b[38;5;66;03m# Restore original forward methods\u001b[39;00m\n\u001b[1;32m   1085\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m module, original_forward \u001b[38;5;129;01min\u001b[39;00m monkey_patched_layers:\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py:364\u001b[0m, in \u001b[0;36mMistralModel.forward\u001b[0;34m(self, input_ids, attention_mask, position_ids, past_key_values, inputs_embeds, use_cache, cache_position, **kwargs)\u001b[0m\n\u001b[1;32m    361\u001b[0m position_embeddings \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrotary_emb(hidden_states, position_ids)\n\u001b[1;32m    363\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m decoder_layer \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlayers[: \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39mnum_hidden_layers]:\n\u001b[0;32m--> 364\u001b[0m     hidden_states \u001b[38;5;241m=\u001b[39m \u001b[43mdecoder_layer\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    365\u001b[0m \u001b[43m        \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    366\u001b[0m \u001b[43m        \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcausal_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    367\u001b[0m \u001b[43m        \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    368\u001b[0m \u001b[43m        \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_values\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    369\u001b[0m \u001b[43m        \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    370\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcache_position\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_position\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    371\u001b[0m \u001b[43m        \u001b[49m\u001b[43mposition_embeddings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_embeddings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    372\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    373\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    374\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnorm(hidden_states)\n\u001b[1;32m    375\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m BaseModelOutputWithPast(\n\u001b[1;32m    376\u001b[0m     last_hidden_state\u001b[38;5;241m=\u001b[39mhidden_states,\n\u001b[1;32m    377\u001b[0m     past_key_values\u001b[38;5;241m=\u001b[39mpast_key_values \u001b[38;5;28;01mif\u001b[39;00m use_cache \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m    378\u001b[0m )\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/modeling_layers.py:94\u001b[0m, in \u001b[0;36mGradientCheckpointingLayer.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m     91\u001b[0m         logger\u001b[38;5;241m.\u001b[39mwarning(message)\n\u001b[1;32m     93\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_gradient_checkpointing_func(partial(\u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__call__\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs), \u001b[38;5;241m*\u001b[39margs)\n\u001b[0;32m---> 94\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__call__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py:175\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[0;34m(module, *args, **kwargs)\u001b[0m\n\u001b[1;32m    173\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    174\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 175\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_old_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    176\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py:228\u001b[0m, in \u001b[0;36mMistralDecoderLayer.forward\u001b[0;34m(self, hidden_states, attention_mask, position_ids, past_key_value, use_cache, cache_position, position_embeddings, **kwargs)\u001b[0m\n\u001b[1;32m    226\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_layernorm(hidden_states)\n\u001b[1;32m    227\u001b[0m \u001b[38;5;66;03m# Self Attention\u001b[39;00m\n\u001b[0;32m--> 228\u001b[0m hidden_states, _ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mself_attn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    229\u001b[0m \u001b[43m    \u001b[49m\u001b[43mhidden_states\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhidden_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    230\u001b[0m \u001b[43m    \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    231\u001b[0m \u001b[43m    \u001b[49m\u001b[43mposition_ids\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_ids\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    232\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpast_key_value\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_key_value\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    233\u001b[0m \u001b[43m    \u001b[49m\u001b[43muse_cache\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43muse_cache\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    234\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcache_position\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcache_position\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    235\u001b[0m \u001b[43m    \u001b[49m\u001b[43mposition_embeddings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mposition_embeddings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    236\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    237\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    238\u001b[0m hidden_states \u001b[38;5;241m=\u001b[39m residual \u001b[38;5;241m+\u001b[39m hidden_states\n\u001b[1;32m    240\u001b[0m \u001b[38;5;66;03m# Fully Connected\u001b[39;00m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1736\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1735\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1736\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/torch/nn/modules/module.py:1747\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1742\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1743\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1744\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1745\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1746\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1749\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1750\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/accelerate/hooks.py:175\u001b[0m, in \u001b[0;36madd_hook_to_module.<locals>.new_forward\u001b[0;34m(module, *args, **kwargs)\u001b[0m\n\u001b[1;32m    173\u001b[0m         output \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39m_old_forward(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    174\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 175\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_old_forward\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    176\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m module\u001b[38;5;241m.\u001b[39m_hf_hook\u001b[38;5;241m.\u001b[39mpost_forward(module, output)\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/models/mistral/modeling_mistral.py:167\u001b[0m, in \u001b[0;36mMistralAttention.forward\u001b[0;34m(self, hidden_states, position_embeddings, attention_mask, past_key_value, cache_position, **kwargs)\u001b[0m\n\u001b[1;32m    164\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39m_attn_implementation \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124meager\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m    165\u001b[0m     attention_interface \u001b[38;5;241m=\u001b[39m ALL_ATTENTION_FUNCTIONS[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconfig\u001b[38;5;241m.\u001b[39m_attn_implementation]\n\u001b[0;32m--> 167\u001b[0m attn_output, attn_weights \u001b[38;5;241m=\u001b[39m \u001b[43mattention_interface\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    168\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    169\u001b[0m \u001b[43m    \u001b[49m\u001b[43mquery_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    170\u001b[0m \u001b[43m    \u001b[49m\u001b[43mkey_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    171\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalue_states\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    172\u001b[0m \u001b[43m    \u001b[49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    173\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdropout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0.0\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtraining\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mattention_dropout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    174\u001b[0m \u001b[43m    \u001b[49m\u001b[43mscaling\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscaling\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    175\u001b[0m \u001b[43m    \u001b[49m\u001b[43msliding_window\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43msliding_window\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# main diff with Llama\u001b[39;49;00m\n\u001b[1;32m    176\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    177\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    179\u001b[0m attn_output \u001b[38;5;241m=\u001b[39m attn_output\u001b[38;5;241m.\u001b[39mreshape(\u001b[38;5;241m*\u001b[39minput_shape, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)\u001b[38;5;241m.\u001b[39mcontiguous()\n\u001b[1;32m    180\u001b[0m attn_output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mo_proj(attn_output)\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/transformers/integrations/sdpa_attention.py:89\u001b[0m, in \u001b[0;36msdpa_attention_forward\u001b[0;34m(module, query, key, value, attention_mask, dropout, scaling, is_causal, **kwargs)\u001b[0m\n\u001b[1;32m     86\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mjit\u001b[38;5;241m.\u001b[39mis_tracing() \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(is_causal, torch\u001b[38;5;241m.\u001b[39mTensor):\n\u001b[1;32m     87\u001b[0m     is_causal \u001b[38;5;241m=\u001b[39m is_causal\u001b[38;5;241m.\u001b[39mitem()\n\u001b[0;32m---> 89\u001b[0m attn_output \u001b[38;5;241m=\u001b[39m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunctional\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscaled_dot_product_attention\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     90\u001b[0m \u001b[43m    \u001b[49m\u001b[43mquery\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     91\u001b[0m \u001b[43m    \u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     92\u001b[0m \u001b[43m    \u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     93\u001b[0m \u001b[43m    \u001b[49m\u001b[43mattn_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattention_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     94\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdropout_p\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdropout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     95\u001b[0m \u001b[43m    \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscaling\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     96\u001b[0m \u001b[43m    \u001b[49m\u001b[43mis_causal\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_causal\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     97\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msdpa_kwargs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     98\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     99\u001b[0m attn_output \u001b[38;5;241m=\u001b[39m attn_output\u001b[38;5;241m.\u001b[39mtranspose(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m)\u001b[38;5;241m.\u001b[39mcontiguous()\n\u001b[1;32m    101\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m attn_output, \u001b[38;5;28;01mNone\u001b[39;00m\n",
+      "\u001b[0;31mOutOfMemoryError\u001b[0m: CUDA out of memory. Tried to allocate 48.00 MiB. GPU 1 has a total capacity of 23.46 GiB of which 43.88 MiB is free. Process 691488 has 13.78 GiB memory in use. Including non-PyTorch memory, this process has 9.61 GiB memory in use. Of the allocated memory 9.39 GiB is allocated by PyTorch, and 30.19 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+     ]
     }
    ],
    "source": [
@@ -600,18 +686,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "id": "ced35d4d-48d6-4a2e-9792-002bc9bbf8d1",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[[',17,12,14,12,14,', ',29,31,29,28,23,'],\n",
-       " [',21,22,17,14,18,', ',18,15,22,32,48,'],\n",
-       " [',33,34,33,24,19,', ',35,47,48,63,63,'],\n",
-       " [',23,21,18,12,19,', ',22,33,34,27,24,'],\n",
-       " [',19,20,15,16,14,', ',19,21,11,12,10,']]"
+       "[[',51,54,38,34,32', ',37,36,56,48,44'],\n",
+       " [',60,61,60,36,36', ',49,56,57,52,48'],\n",
+       " [',75,51,39,40,39', ',57,63,51,53,51'],\n",
+       " [',70,65,54,63,66', ',57,50,42,37,45'],\n",
+       " [',61,59,61,63,58', ',62,62,60,53,53']]"
       ]
      },
      "execution_count": 20,
@@ -637,7 +723,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "id": "093edbfa-9881-4a0a-b5b2-14f81696bb6f",
    "metadata": {},
    "outputs": [
@@ -660,27 +746,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "id": "c175381f-95f1-435f-bcdb-2371c566aaa3",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[[17.],\n",
-       "        [29.]],\n",
+       "array([[[51.],\n",
+       "        [37.]],\n",
        "\n",
-       "       [[21.],\n",
-       "        [18.]],\n",
+       "       [[60.],\n",
+       "        [49.]],\n",
        "\n",
-       "       [[33.],\n",
-       "        [35.]],\n",
+       "       [[75.],\n",
+       "        [57.]],\n",
        "\n",
-       "       [[23.],\n",
-       "        [22.]],\n",
+       "       [[70.],\n",
+       "        [57.]],\n",
        "\n",
-       "       [[19.],\n",
-       "        [19.]]])"
+       "       [[61.],\n",
+       "        [62.]]])"
       ]
      },
      "execution_count": 22,
@@ -694,14 +780,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "id": "e569e052-8beb-419b-b5e4-74540e1beabb",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(1508, 2, 1)"
+       "(64, 2, 1)"
       ]
      },
      "execution_count": 23,
@@ -730,7 +816,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "id": "5cc0579a-bd0f-4333-a56a-068c0616d2c2",
    "metadata": {},
    "outputs": [
@@ -753,27 +839,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "id": "ee049dcb-9da2-443f-8681-f7f60e4ee5cc",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([[[0.170385],\n",
-       "        [0.290385]],\n",
+       "array([[[0.54607339],\n",
+       "        [0.40607339]],\n",
        "\n",
-       "       [[0.210385],\n",
-       "        [0.180385]],\n",
+       "       [[0.63607339],\n",
+       "        [0.52607339]],\n",
        "\n",
-       "       [[0.330385],\n",
-       "        [0.350385]],\n",
+       "       [[0.78607339],\n",
+       "        [0.60607339]],\n",
        "\n",
-       "       [[0.230385],\n",
-       "        [0.220385]],\n",
+       "       [[0.73607339],\n",
+       "        [0.60607339]],\n",
        "\n",
-       "       [[0.190385],\n",
-       "        [0.190385]]])"
+       "       [[0.64607339],\n",
+       "        [0.65607339]]])"
       ]
      },
      "execution_count": 25,
@@ -787,14 +873,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "id": "108cb8cd-3c16-47aa-8ba8-9b8dd87e62e5",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(1508, 2, 1)"
+       "(64, 2, 1)"
       ]
      },
      "execution_count": 26,
@@ -822,7 +908,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "id": "8527ebb5-102c-4c0e-b849-595157cc9f04",
    "metadata": {},
    "outputs": [
@@ -845,14 +931,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "id": "c699ed1b-9619-427d-97d1-518920abd548",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(1508,)"
+       "(64,)"
       ]
      },
      "execution_count": 28,
@@ -878,7 +964,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "id": "71ba3d53-9647-48e2-810a-7b22a6e3fac7",
    "metadata": {},
    "outputs": [
@@ -901,14 +987,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "id": "f9e6efa6-e5b5-4941-9d98-b8c782460d23",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(1508, 1)"
+       "(64, 1)"
       ]
      },
      "execution_count": 30,
@@ -936,7 +1022,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": null,
    "id": "d5274fa0-b505-4a71-b4ed-1c41b655db4e",
    "metadata": {},
    "outputs": [
@@ -959,14 +1045,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": null,
    "id": "4f20a106-0dc3-49c1-8042-474bc5020d93",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(1508, 1)"
+       "(64, 1)"
       ]
      },
      "execution_count": 32,
@@ -994,7 +1080,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": null,
    "id": "31d53428-12e8-4cf7-9803-6a203cea9b9b",
    "metadata": {},
    "outputs": [
@@ -1017,62 +1103,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": null,
    "id": "ae8e26f0-1052-49a4-92b8-5218241d4e4a",
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>start</th>\n",
-       "      <th>end</th>\n",
-       "      <th>score</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>1.312816e+09</td>\n",
-       "      <td>1.313093e+09</td>\n",
-       "      <td>0.005898</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>1.313287e+09</td>\n",
-       "      <td>1.313629e+09</td>\n",
-       "      <td>0.011107</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "          start           end     score\n",
-       "0  1.312816e+09  1.313093e+09  0.005898\n",
-       "1  1.313287e+09  1.313629e+09  0.011107"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
+     "ename": "ValueError",
+     "evalue": "Empty data passed with indices specified.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[34], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mpandas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mpd\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mDataFrame\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcontext\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43manomalies\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mstart\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mend\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mscore\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/pandas/core/frame.py:722\u001b[0m, in \u001b[0;36mDataFrame.__init__\u001b[0;34m(self, data, index, columns, dtype, copy)\u001b[0m\n\u001b[1;32m    712\u001b[0m         mgr \u001b[38;5;241m=\u001b[39m dict_to_mgr(\n\u001b[1;32m    713\u001b[0m             \u001b[38;5;66;03m# error: Item \"ndarray\" of \"Union[ndarray, Series, Index]\" has no\u001b[39;00m\n\u001b[1;32m    714\u001b[0m             \u001b[38;5;66;03m# attribute \"name\"\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    719\u001b[0m             typ\u001b[38;5;241m=\u001b[39mmanager,\n\u001b[1;32m    720\u001b[0m         )\n\u001b[1;32m    721\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 722\u001b[0m         mgr \u001b[38;5;241m=\u001b[39m \u001b[43mndarray_to_mgr\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    723\u001b[0m \u001b[43m            \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    724\u001b[0m \u001b[43m            \u001b[49m\u001b[43mindex\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    725\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcolumns\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    726\u001b[0m \u001b[43m            \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    727\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcopy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    728\u001b[0m \u001b[43m            \u001b[49m\u001b[43mtyp\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmanager\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    729\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    731\u001b[0m \u001b[38;5;66;03m# For data is list-like, or Iterable (will consume into list)\u001b[39;00m\n\u001b[1;32m    732\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m is_list_like(data):\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/pandas/core/internals/construction.py:349\u001b[0m, in \u001b[0;36mndarray_to_mgr\u001b[0;34m(values, index, columns, dtype, copy, typ)\u001b[0m\n\u001b[1;32m    344\u001b[0m \u001b[38;5;66;03m# _prep_ndarraylike ensures that values.ndim == 2 at this point\u001b[39;00m\n\u001b[1;32m    345\u001b[0m index, columns \u001b[38;5;241m=\u001b[39m _get_axes(\n\u001b[1;32m    346\u001b[0m     values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m], values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m], index\u001b[38;5;241m=\u001b[39mindex, columns\u001b[38;5;241m=\u001b[39mcolumns\n\u001b[1;32m    347\u001b[0m )\n\u001b[0;32m--> 349\u001b[0m \u001b[43m_check_values_indices_shape_match\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalues\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcolumns\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    351\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m typ \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124marray\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m    353\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(values\u001b[38;5;241m.\u001b[39mdtype\u001b[38;5;241m.\u001b[39mtype, \u001b[38;5;28mstr\u001b[39m):\n",
+      "File \u001b[0;32m~/miniconda/envs/orion310/lib/python3.10/site-packages/pandas/core/internals/construction.py:416\u001b[0m, in \u001b[0;36m_check_values_indices_shape_match\u001b[0;34m(values, index, columns)\u001b[0m\n\u001b[1;32m    412\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mlen\u001b[39m(columns) \u001b[38;5;129;01mor\u001b[39;00m values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m!=\u001b[39m \u001b[38;5;28mlen\u001b[39m(index):\n\u001b[1;32m    413\u001b[0m     \u001b[38;5;66;03m# Could let this raise in Block constructor, but we get a more\u001b[39;00m\n\u001b[1;32m    414\u001b[0m     \u001b[38;5;66;03m#  helpful exception message this way.\u001b[39;00m\n\u001b[1;32m    415\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m values\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m--> 416\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEmpty data passed with indices specified.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    418\u001b[0m     passed \u001b[38;5;241m=\u001b[39m values\u001b[38;5;241m.\u001b[39mshape\n\u001b[1;32m    419\u001b[0m     implied \u001b[38;5;241m=\u001b[39m (\u001b[38;5;28mlen\u001b[39m(index), \u001b[38;5;28mlen\u001b[39m(columns))\n",
+      "\u001b[0;31mValueError\u001b[0m: Empty data passed with indices specified."
+     ]
     }
    ],
    "source": [
@@ -1083,7 +1130,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": null,
    "id": "037bd699-cd54-4b27-a62e-87bf3c7fc29a",
    "metadata": {},
    "outputs": [
@@ -1121,9 +1168,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "nlp",
+   "display_name": "orion310",
    "language": "python",
-   "name": "nlp"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -1135,7 +1182,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.10.18"
   }
  },
  "nbformat": 4,
diff --git a/tutorials/pipelines/multivariate-pipeline.ipynb b/tutorials/pipelines/multivariate-pipeline.ipynb
new file mode 100644
index 0000000..fe00050
--- /dev/null
+++ b/tutorials/pipelines/multivariate-pipeline.ipynb
@@ -0,0 +1,285 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Multivariate Pipeline Tutorial\n",
+        "\n",
+        "This notebook demonstrates how to use the multivariate detector pipeline with different formatting methods for multidimensional time series data.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "from sigllm.primitives.formatting import (\n",
+        "    JSONFormat,\n",
+        "    UnivariateControl,\n",
+        "    PersistenceControl,\n",
+        "    ValueConcatenation,\n",
+        "    ValueInterleave,\n",
+        "    DigitInterleave\n",
+        ")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Create Sample Multivariate Data\n",
+        "\n",
+        "First, let's create some sample multivariate time series data with 3 dimensions.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Sample data shape: (25, 4)\n"
+          ]
+        },
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>timestamp</th>\n",
+              "      <th>x1</th>\n",
+              "      <th>x2</th>\n",
+              "      <th>x3</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>0.0</td>\n",
+              "      <td>0.10</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0.65</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>3600.0</td>\n",
+              "      <td>0.11</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0.64</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>7200.0</td>\n",
+              "      <td>0.12</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0.63</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>10800.0</td>\n",
+              "      <td>0.13</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0.62</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>14400.0</td>\n",
+              "      <td>0.14</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0.61</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "   timestamp    x1  x2    x3\n",
+              "0        0.0  0.10   0  0.65\n",
+              "1     3600.0  0.11   1  0.64\n",
+              "2     7200.0  0.12   0  0.63\n",
+              "3    10800.0  0.13   1  0.62\n",
+              "4    14400.0  0.14   0  0.61"
+            ]
+          },
+          "execution_count": 2,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Create sample data with 3 dimensions\n",
+        "N = 25\n",
+        "data = pd.DataFrame({\n",
+        "    'timestamp': np.linspace(0, 3600*(N-1), N),\n",
+        "    'x1': np.linspace(10, 9+N, N) / 100,\n",
+        "    'x2': np.array([i % 2 for i in range(N)]),\n",
+        "    'x3': np.linspace(N+40, 41, N) / 100,\n",
+        "})\n",
+        "\n",
+        "print(\"Sample data shape:\", data.shape)\n",
+        "data.head()\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Available Formatting Methods\n",
+        "\n",
+        "The multivariate pipeline supports several formatting methods to convert multi-dimensional data into string representations for LLM processing:\n",
+        "\n",
+        "1. **JSONFormat**: Formats as d0:val,d1:val,... per timestamp\n",
+        "2. **ValueConcatenation**: Flattens all dimensions per timestamp\n",
+        "3. **ValueInterleave**: Interleaves values with zero-padding\n",
+        "4. **DigitInterleave**: Interleaves individual digits\n",
+        "5. **UnivariateControl**: Uses only first dimension (baseline)\n",
+        "6. **PersistenceControl**: Returns last value (naive baseline)\n",
+        "\n",
+        "\n",
+        "For example, given timesteps $t_0$ = [50, 30, 100] and $t_1$ = [55, 28, 104]:\n",
+        "* Value Concatenation - Simply flatten the values across time: 50,30,100,55,28,104\n",
+        "* Value Interleave - Pad values to equal digit length and concatenate timestep by timestep: 050030100,055028104\n",
+        "* Digit Interleave - Interleave digits positionally across dimensions: 001530000,001520584\n",
+        "* JSON Format - Encode as dimension-labeled key:value pairs: d0:50,d1:30,d2:100,d0:55,d1:28,d2:104\n",
+        "* Univariate Control - Keep only one dimension (baseline for comparison): 50,55\n",
+        "* Persistence Control - Bypass the formatting and return last known value: N/A\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Windowed data shape: (15, 10, 3)\n",
+            "\n",
+            "First window (first 3 timestamps):\n",
+            "[[ 100    0  650]\n",
+            " [ 110 1000  640]\n",
+            " [ 120    0  630]]\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Initialize JSONFormat method\n",
+        "json_method = JSONFormat()\n",
+        "\n",
+        "# Create windowed test data (simulating pipeline output)\n",
+        "raw_data = np.array(data)[:, 1:]  # Remove timestamp column\n",
+        "windowed_data = np.array([raw_data[i:i+10,:] for i in range(0, len(raw_data)-10, 1)])\n",
+        "int_data = (1000 * windowed_data).astype(int)\n",
+        "\n",
+        "print(f\"Windowed data shape: {int_data.shape}\")\n",
+        "print(f\"\\nFirst window (first 3 timestamps):\")\n",
+        "print(int_data[0][:3])\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Compare string representations from different methods\n",
+        "methods = {\n",
+        "    'JSONFormat': JSONFormat(),\n",
+        "    'ValueConcatenation': ValueConcatenation(),\n",
+        "    'ValueInterleave': ValueInterleave(),\n",
+        "    'DigitInterleave': DigitInterleave(),\n",
+        "    'UnivariateControl': UnivariateControl(),\n",
+        "    'PersistenceControl': PersistenceControl(),\n",
+        "}\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Comparison of formatting methods on the same data:\n",
+            "\n",
+            "JSONFormat:\n",
+            "  d0:100,d1:0,d2:650,d0:110,d1:1000,d2:640,d0:120,d1:0,d2:630,d0:130,d1:1000,d2:62...\n",
+            "\n",
+            "ValueConcatenation:\n",
+            "  100,0,650,110,1000,640,120,0,630,130,1000,620,140,0,610,150,1000,600,160,0,590,1...\n",
+            "\n",
+            "ValueInterleave:\n",
+            "  010000000650,011010000640,012000000630,013010000620,014000000610,015010000600,01...\n",
+            "\n",
+            "DigitInterleave:\n",
+            "  000106005000,010106104000,000106203000,010106302000,000106401000,010106500000,00...\n",
+            "\n",
+            "UnivariateControl:\n",
+            "  100,110,120,130,140,150,160,170,180,190...\n",
+            "\n",
+            "PersistenceControl:\n",
+            "  100,110,120,130,140,150,160,170,180,190...\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(\"Comparison of formatting methods on the same data:\\n\")\n",
+        "for name, method in methods.items():\n",
+        "    try:\n",
+        "        print(f\"{name}:\")\n",
+        "        output = method.format_as_string(int_data)\n",
+        "        print(f\"  {output[0][:80]}...\\n\")\n",
+        "    except Exception as e:\n",
+        "        print(f\"{name}: Error - {e}\\n\")"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "orion310",
+      "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.10.18"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}