dquant 1.2.4__tar.gz → 1.3.0b0__tar.gz

{dquant-1.2.4/src/DQuant.egg-info → dquant-1.3.0b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dquant
-Version: 1.2.4
+Version: 1.3.0b0
 Summary: DQuant is an open-source Python library for automated volatility forecasting of financial time series. It handles all stages of model construction, from raw prices to the final forecast.
 Author: Denis Makarov
 Project-URL: Homepage, https://dquant.space

{dquant-1.2.4 → dquant-1.3.0b0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dquant"
-version = "1.2.4"
+version = "1.3.0-beta"
 authors = [
   { name="Denis Makarov" },
 ]

{dquant-1.2.4 → dquant-1.3.0b0/src/DQuant.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dquant
-Version: 1.2.4
+Version: 1.3.0b0
 Summary: DQuant is an open-source Python library for automated volatility forecasting of financial time series. It handles all stages of model construction, from raw prices to the final forecast.
 Author: Denis Makarov
 Project-URL: Homepage, https://dquant.space

{dquant-1.2.4 → dquant-1.3.0b0}/src/dquant/models.py

@@ -1,5 +1,4 @@
 import json
-import joblib
 import re
 import onnxruntime as ort
 import os
@@ -10,14 +9,12 @@ from .visual import Visualization
 import time as time
 import numpy as np
 import xgboost
-from sklearn.ensemble import GradientBoostingRegressor
+from sklearn.base import clone
 from sklearn.model_selection import train_test_split
 from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
 from .metrics import qlike_score
-from sklearn.preprocessing import StandardScaler
 from typing import Tuple
 import pandas as pd
-from skl2onnx import convert_sklearn
 from skl2onnx.common.data_types import FloatTensorType
 import warnings
 warnings.filterwarnings('ignore', message='X does not have valid feature names')
@@ -356,7 +353,7 @@ class FichEn:
 
         return np.array(tr_values)
 
-    def forward(self, data, feature_list, trees, input_bars, horizon, trees_count, show_results=False, feature_func=None, target_func=None):
+    def forward(self, data, feature_list, trees, train_window_size, input_bars, horizon, trees_count, show_results=False, feature_func=None, target_func=None):
         self.input_bars = input_bars
         self.horizon = horizon
         self.trees_count = trees_count
@@ -365,6 +362,15 @@ class FichEn:
             "horizon": self.horizon,
             "trees_count": self.trees_count
         }
+        if self.loss == "MAE":
+            loss_f = mean_absolute_error
+        elif self.loss == "MSE":
+            loss_f = mean_squared_error
+        elif self.loss == "QLIKE":
+            loss_f = qlike_score
+        else:
+            raise "Unavailable loss function"
+
         x, y = self._DataSplitting(data, input_bars, horizon, True)
         XX = []
         YY = []
@@ -402,7 +408,6 @@ class FichEn:
         x = np.array(XX)
         y = np.array(YY)
 
-        train_window_size = input_bars
         start_val_idx = train_window_size
 
         total_iterations = len(x) - start_val_idx
@@ -415,8 +420,6 @@ class FichEn:
 
         all_train_errors = []
         all_val_errors = []
-        all_train_r2 = []
-        all_val_r2 = []
 
         if isinstance(horizon, int):
             horizon_list = list(range(horizon))
@@ -435,74 +438,53 @@ class FichEn:
             X_val = x[val_idx:val_idx + 1]  # form (1, n_features)
             y_val_true = y[val_idx]  # form (horizon,)
 
-            # === Normalization ===
-            scaler_X = StandardScaler()
-            scaler_y_local = StandardScaler()
-
-            X_train_scaled = scaler_X.fit_transform(X_train)
-            y_train_scaled = scaler_y_local.fit_transform(y_train)
-
-            X_val_scaled = scaler_X.transform(X_val)
-
             # === training for each horizon ===
             model_ex = self.base_model.__class__(**self.base_model.get_params())
             model_ex.set_params(n_estimators=trees)
             models_temp = []
             for h_idx in horizon_list:
-                if h_idx >= y_train_scaled.shape[1]:
+                if h_idx >= y_train.shape[1]:
                     continue
 
-                y_h = y_train_scaled[:, h_idx]
+                y_h = y_train[:, h_idx]
 
-                model = model_ex
-                model.fit(X_train_scaled, y_h)
+                model = clone(model_ex)
+                model.fit(X_train, y_h)
                 models_temp.append(model)
 
             # === Foracesting train ===
             train_preds_list = []
             for model in models_temp:
-                train_preds_list.append(model.predict(X_train_scaled))
+                train_preds_list.append(model.predict(X_train))
             train_preds = np.column_stack(train_preds_list)  # (train_windows, horizon)
 
             # Forecasting on validation data
             val_preds_list = []
             for model in models_temp:
-                val_preds_list.append(model.predict(X_val_scaled))
+                val_preds_list.append(model.predict(X_val))
             val_preds = np.array(val_preds_list).flatten()  # (horizon,)
 
-
-            y_train_inv = scaler_y_local.inverse_transform(y_train_scaled)
-            train_preds_inv = scaler_y_local.inverse_transform(train_preds)
-
-            y_val_true_inv = y_val_true
-            val_preds_inv = scaler_y_local.inverse_transform(val_preds.reshape(1, -1)).flatten()
-
             # === Metrics ===
-            train_error = mean_squared_error(y_train_inv.flatten(), train_preds_inv.flatten())
-            val_error = mean_squared_error(y_val_true_inv, val_preds_inv)
-            train_r2 = r2_score(y_train_inv.flatten(), train_preds_inv.flatten())
-            val_r2 = r2_score(y_val_true_inv, val_preds_inv)
+            train_error = loss_f(y_train.flatten(), train_preds.flatten())
+            val_error = loss_f(y_val_true, val_preds)
 
             all_train_errors.append(train_error)
             all_val_errors.append(val_error)
-            all_train_r2.append(train_r2)
-            all_val_r2.append(val_r2)
 
             # === Progress bar ===
             percent = (iter_num / total_iterations) * 100
             filled = int(percent / 2)
             bar = '█' * filled + '░' * (50 - filled)
             self.dquantprint(
-                f'\rWalk-Forward: |{bar}| {percent:.1f}% - Iteration {iter_num}/{total_iterations} - Val MSE: {val_error:.6f} - need time: {(time.time()-start_it)*(total_iterations-iter_num)} seconds',
+                f'\rWalk-Forward: |{bar}| {percent:.1f}% - Iteration {iter_num}/{total_iterations} - Val {self.loss}: {val_error:.6f} - need time: {(time.time()-start_it)*(total_iterations-iter_num)} seconds',
                 end='', flush=True)
 
 
-        self.dquantprint(f"Mean validation error (MSE): {np.mean(all_val_errors):.6f} +/- {np.std(all_val_errors):.6f}")
-        self.dquantprint(f"Mean validation R²: {np.mean(all_val_r2):.4f} +/- {np.std(all_val_r2):.4f}")
+        self.dquantprint(f"Mean validation error ({self.loss}): {np.mean(all_val_errors):.6f} +/- {np.std(all_val_errors):.6f}")
         self.dquantprint(f"Maximum validation error: {np.max(all_val_errors):.6f}")
         self.dquantprint(f"Minimum validation error: {np.min(all_val_errors):.6f}")
         if show_results:
-            self.V.forward_validation_errors(all_val_errors, all_val_r2)
+            self.V.forward_validation_errors(all_val_errors)
         return
 
     def fit(self, data, feature_list, input_bars, horizon, trees_count, show_results=False, feature_func=None, target_func=None):
@@ -514,6 +496,15 @@ class FichEn:
             "horizon": self.horizon,
             "trees_count": self.trees_count
         }
+        if self.loss == "MAE":
+            loss_f = mean_absolute_error
+        elif self.loss == "MSE":
+            loss_f = mean_squared_error
+        elif self.loss == "QLIKE":
+            loss_f = qlike_score
+        else:
+            raise "Unavailable loss function"
+
         x, y = self._DataSplitting(data, input_bars, horizon, True)
         XX = []
         YY = []
@@ -553,33 +544,14 @@ class FichEn:
         x = np.array(XX)
         y = np.array(YY)
 
-
         X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, shuffle=False, random_state=42)
-        X_scaled = self.scaler.fit_transform(X_train)
-        X_test_scaled = self.scaler.transform(X_test)
-        #Y_scaled = self.scaler_y.fit_transform(y_train)
-        #Y_test_scaled = self.scaler_y.transform(y_test)
-        """if hasattr(y, 'ndim') and y.ndim == 1:
-            self.X_shape = 1
-            #y_2d = y.values.reshape(-1, 1) if hasattr(y, 'values') else y.reshape(-1, 1)
-        else:
-            self.X_shape = y.shape[1]"""
 
         self.X_shape = x.shape[1]
 
         self.train_errors = []
         self.val_errors = []
-        self.train_mae = []
-        self.val_mae = []
-        self.train_qlike = []
-        self.val_qlike = []
-        self.train_r2 = []
-        self.val_r2 = []
 
         self.best_val_error = float('inf')
-        self.best_val_mae = float('inf')
-        self.best_val_qlike = float('inf')
-        self.best_r2 = -float('inf')
         self.patience_counter = 0
         self.patience = 3
 
@@ -590,12 +562,6 @@ class FichEn:
                 self.dquantprint(f'{i} trees')
                 t_error = 0
                 v_error = 0
-                t_mae = 0
-                v_mae = 0
-                t_qlike = 0
-                v_qlike = 0
-                t_r2 = 0
-                v_r2 = 0
                 if isinstance(horizon, int):
                     horizon_list = list(range(horizon))
                 else:
@@ -609,9 +575,8 @@ class FichEn:
                         y_h = y_train.iloc[:, h_idx] if hasattr(y_train, 'iloc') else y_train[:, h_idx]
 
                         valid_mask = ~pd.isna(y_h) if hasattr(y_h, 'isna') else ~np.isnan(y_h)
-                        X_h = X_scaled[valid_mask]
+                        X_h = X_train[valid_mask]
                         y_h_clean = y_h[valid_mask]
-                        #y_h_clean_orig = self.scaler_y.inverse_transform(y_h_clean.reshape(-1, 1)).ravel()
 
                         if i != 1:
                             self.models[h_idx].set_params(n_estimators=i)
@@ -625,94 +590,49 @@ class FichEn:
                         y_h_v = y_test.iloc[:, h_idx] if hasattr(y_test, 'iloc') else y_test[:, h_idx]
 
                         valid_mask = ~pd.isna(y_h_v) if hasattr(y_h_v, 'isna') else ~np.isnan(y_h_v)
-                        X_h_v = X_test_scaled[valid_mask]
+                        X_h_v = X_test[valid_mask]
                         y_h_v_clean = y_h_v[valid_mask]
-                        #y_h_v_clean_orig = self.scaler_y.inverse_transform(y_h_v_clean.reshape(-1, 1)).ravel()
                         if i != 1:
                             pred_train = self.models[h_idx].predict(X_h)
                             pred_val = self.models[h_idx].predict(X_h_v)
-                            #pred_train_orig = self.scaler_y.inverse_transform(pred_train.reshape(-1, 1)).ravel()
-                            #pred_val_orig = self.scaler_y.inverse_transform(pred_val.reshape(-1, 1)).ravel()
-                            t_error += mean_squared_error(y_h_clean, pred_train)
-                            v_error += mean_squared_error(y_h_v_clean, pred_val)
-                            t_mae += mean_absolute_error(y_h_clean, pred_train)
-                            v_mae += mean_absolute_error(y_h_v_clean, pred_val)
-                            t_qlike += qlike_score(y_h_clean, pred_train)
-                            v_qlike += qlike_score(y_h_v_clean, pred_val)
-                            t_r2 += r2_score(y_h_clean, pred_train)
-                            v_r2 += r2_score(y_h_v_clean, pred_val)
+
+                            t_error += loss_f(y_h_clean, pred_train)
+                            v_error += loss_f(y_h_v_clean, pred_val)
                         else:
                             pred_train = model.predict(X_h)
                             pred_val = model.predict(X_h_v)
-                            #pred_train_orig = self.scaler_y.inverse_transform(pred_train.reshape(-1, 1)).ravel()
-                            #pred_val_orig = self.scaler_y.inverse_transform(pred_val.reshape(-1, 1)).ravel()
-                            t_error += mean_squared_error(y_h_clean, pred_train)
-                            v_error += mean_squared_error(y_h_v_clean, pred_val)
-                            t_mae += mean_absolute_error(y_h_clean, pred_train)
-                            v_mae += mean_absolute_error(y_h_v_clean, pred_val)
-                            t_qlike += qlike_score(y_h_clean, pred_train)
-                            v_qlike += qlike_score(y_h_v_clean, pred_val)
-                            t_r2 += r2_score(y_h_clean, pred_train)
-                            v_r2 += r2_score(y_h_v_clean, pred_val)
+
+                            t_error += loss_f(y_h_clean, pred_train)
+                            v_error += loss_f(y_h_v_clean, pred_val)
 
 
                 var_test_error = float(t_error)/horizon
                 var_val_error = float(v_error)/horizon
-                var_test_mae = float(t_mae) / horizon
-                var_val_mae = float(v_mae) / horizon
-                var_test_qlike = float(t_qlike) / horizon
-                var_val_qlike = float(v_qlike) / horizon
-                var_test_r2 = float(t_r2)/horizon
-                var_val_r2 = float(v_r2)/horizon
 
                 if self.early_stopping:
                     if len(self.val_errors) > 0:
-                        if self.loss == "MAE":
-                            current_min = min(self.val_mae)
-                            best_so_far = min(self.best_val_mae, current_min)
-                            no_improvement_count = len(self.val_mae) - self.val_mae.index(best_so_far) - 1
-                        elif self.loss == "MSE":
-                            current_min = min(self.val_errors)
-                            best_so_far = min(self.best_val_error, current_min)
-                            no_improvement_count = len(self.val_errors) - self.val_errors.index(best_so_far) - 1
-                        elif self.loss == "QLIKE":
-                            current_min = min(self.val_qlike)
-                            best_so_far = min(self.best_val_qlike, current_min)
-                            no_improvement_count = len(self.val_qlike) - self.val_qlike.index(best_so_far) - 1
-                        else:
-                            raise "Unavailable loss function"
+                        current_min = min(self.val_errors)
+                        best_so_far = min(self.best_val_error, current_min)
+                        no_improvement_count = len(self.val_errors) - self.val_errors.index(best_so_far) - 1
 
                         if no_improvement_count >= self.patience:
                             self.dquantprint(f'Early stopping at {i} trees (no improvement for {self.patience} steps)')
                             if show_results:
-                                self.V.show_errors(self.train_errors, self.val_errors,
-                                                   self.train_r2, self.val_r2)
+                                self.V.show_errors(self.train_errors, self.val_errors)
                             self.is_fitted = True
                             return
 
                 self.train_errors.append(var_test_error)
                 self.val_errors.append(var_val_error)
-                self.train_mae.append(var_test_mae)
-                self.val_mae.append(var_val_mae)
-                self.train_qlike.append(var_test_qlike)
-                self.val_qlike.append(var_val_qlike)
-                self.train_r2.append(var_test_r2)
-                self.val_r2.append(var_val_r2)
-                self.dquantprint('Train QLIKE:      ', var_test_qlike)
-                self.dquantprint('Validation QLIKE: ', var_val_qlike)
-                self.dquantprint('Train MSE:        ', var_test_error)
-                self.dquantprint('Validation MSE:   ', var_val_error)
-                self.dquantprint('Train MAE:        ', var_test_mae)
-                self.dquantprint('Validation MAE:   ', var_val_mae)
-                self.dquantprint('Train r2:         ', var_test_r2)
-                self.dquantprint('Validation r2:    ', var_val_r2)
+                self.dquantprint(f'Train {self.loss}:        ', var_test_error)
+                self.dquantprint(f'Validation {self.loss}:   ', var_val_error)
                 self.dquantprint(f"{time.time() - start} seconds spent")
 
         except KeyboardInterrupt:
             self.dquantprint("\nTraining interrupted by Ctrl+C!")
 
         if show_results:
-            self.V.show_errors(self.train_errors, self.val_errors, self.train_r2, self.val_r2)
+            self.V.show_errors(self.train_errors, self.val_errors)
 
         self.dquantprint('model is trained')
         self.is_fitted = True
@@ -777,11 +697,10 @@ class FichEn:
             X = X.astype(np.float32)
             if len(X.shape) == 1:
                 X = X.reshape(1, -1)
-            X_scaled = self.scaler.transform(X)
 
             predictions = [] #jj
             for model in self.models:
-                pred = model.predict(X_scaled)
+                pred = model.predict(X)
                 if len(pred.shape) > 0 and pred.shape[0] > 1:
                     predictions.append(pred)
                 else:
@@ -820,7 +739,7 @@ class FichEn:
 
 
     def show_train_results(self):
-        self.V.show_errors(self.train_errors, self.val_errors, self.train_r2, self.val_r2)
+        self.V.show_errors(self.train_errors, self.val_errors)
 
 
     def save_mql5(self, name):
@@ -1479,175 +1398,11 @@ class FichEn:
 
 
 
-class VolClustGB(FichEn):
-    def __init__(self, sett, early_stopping=True, output=True, loss="MAE"):
-        self.loss = loss
-        self.output = output
-        self.models = []
-        self.scaler = StandardScaler()
-        #self.scaler_y = StandardScaler()
-        self.X_shape = 0
-        self.is_fitted = False
-        self.onnx_load = False
-        self.early_stopping = early_stopping
-        self.V = Visualization('dark')
-        self.default_sett = {
-            'loss': 'squared_error',
-            'learning_rate': 0.01,
-            'n_estimators': 1,
-            'max_depth': 3,
-            'min_samples_split': 5,
-            'min_samples_leaf': 2,
-            'subsample': 0.8,
-            'random_state': 42,
-            'warm_start': True
-        }
-        self.meta = {
-            "model_type": "gb",
-            "model_settings": self.default_sett,
-            "model_loss": loss
-        }
-        if sett == {}:
-            self.base_model = GradientBoostingRegressor(**self.default_sett)
-        else:
-            self.base_model = GradientBoostingRegressor(**sett)
-
-    def save(self, name, type_to_save='default'):
-        if type_to_save == 'default':
-            os.makedirs(name, exist_ok=True)
-            initial_type = [('float_input', FloatTensorType([None, self.X_shape]))]
-
-            file_path = os.path.join(name, f"{name}_features.json")
-            with open(file_path, 'w', encoding='utf-8') as f:
-                json.dump(self.feature_list, f, ensure_ascii=False, indent=2)
-
-            self.meta = {
-                "model_type": "gb",
-                "model_settings": self.default_sett,
-                "input_bars": self.input_bars,
-                "horizon": self.horizon,
-                "trees_count": self.trees_count,
-            }
-            file_path = os.path.join(name, f"{name}_model_settings.json")
-            with open(file_path, 'w', encoding='utf-8') as f:
-                json.dump(self.meta, f, ensure_ascii=False, indent=2)
-
-            if hasattr(self, 'scaler'):
-                scaler_path = os.path.join(name, f"{name}_scaler.pkl")
-                joblib.dump(self.scaler, scaler_path)
-
-            """if hasattr(self, 'scaler_y'):
-                scaler_path = os.path.join(name, f"{name}_scaler_y.pkl")
-                joblib.dump(self.scaler_y, scaler_path)"""
-
-            for i in range(len(self.models)):
-                onx = convert_sklearn(self.models[i], initial_types=initial_type, target_opset=12)
-
-                file_path = os.path.join(name, f"{name}_{i}.onnx")
-
-                with open(file_path, "wb") as f:
-                    f.write(onx.SerializeToString())
-        elif type_to_save == 'mql5':
-            self.save_mql5(name)
-            onnx_dir = os.path.join(name, f"{name}_onnx")
-            os.makedirs(onnx_dir, exist_ok=True)
-            self.dquantprint(f"Directory for ONNX files created: {onnx_dir}")
-
-            initial_type = [('float_input', FloatTensorType([None, self.X_shape]))]
-
-            if hasattr(self, 'scaler') and self.scaler is not None:
-                scaler_path = os.path.join(onnx_dir, f"{name}_scaler.pkl")
-                joblib.dump(self.scaler, scaler_path)
-                self.dquantprint(f"Scaler is saved in {scaler_path}")
-
-            """if hasattr(self, 'scaler_y') and self.scaler_y is not None:
-                scaler_path = os.path.join(onnx_dir, f"{name}_scaler_y.pkl")
-                joblib.dump(self.scaler_y, scaler_path)
-                self.dquantprint(f"Scalery is saved in {scaler_path}")"""
-
-            for i in range(len(self.models)):
-                onx = convert_sklearn(self.models[i], initial_types=initial_type, target_opset=12)
-                file_path = os.path.join(onnx_dir, f"{name}_{i}.onnx")
-                with open(file_path, "wb") as f:
-                    f.write(onx.SerializeToString())
-                self.dquantprint(f"Model {i} is saved in {file_path}")
-
-            self.dquantprint(f"All operations in directory '{name}' completed successfully!")
-
-
-    def load(self, name):
-        self.loaded_models = []
-
-        if not os.path.exists(name):
-            raise FileNotFoundError(f"Directory {name} not found")
-
-        try:
-            file_path = os.path.join(name, f"{name}_features.json")
-            with open(file_path, 'r', encoding='utf-8') as f:
-                self.feature_list = json.load(f)
-        except FileNotFoundError:
-            self.dquantprint(f'Model {name} is not valid, file {name}_features.json is not found')
-            return
-
-        try:
-            file_path = os.path.join(name, f"{name}_model_settings.json")
-            with open(file_path, 'r', encoding='utf-8') as f:
-                self.meta = json.load(f)
-        except FileNotFoundError:
-            self.dquantprint(f'Model {name} is not valid, file {name}_model_settings.json is not found')
-            return
-
-        if self.meta['model_type'] != 'gb':
-            raise ValueError(f"Wrong model type, expected gb and not a {self.meta['model_type']}")
-
-        scaler_files = [f for f in os.listdir(name) if f.endswith('_scaler.pkl')]
-        if scaler_files:
-            scaler_path = os.path.join(name, scaler_files[0])
-            self.scaler = joblib.load(scaler_path)
-
-        """scaler_files = [f for f in os.listdir(name) if f.endswith('_scaler_y.pkl')]
-        if scaler_files:
-            scaler_path = os.path.join(name, scaler_files[0])"""
-            #self.scaler_y = joblib.load(scaler_path)
-
-        model_files = [f for f in os.listdir(name) if f.endswith('.onnx')]
-
-        if not model_files:
-            raise FileNotFoundError(f"No .onnx files found in directory {name}")
-
-        model_files.sort()
-        ml = len(model_files)
-        numbers = {}
-        for f in model_files:
-            match = re.search(r'_(\d+)\.onnx$', f)
-            if match:
-                num = int(match.group(1))
-                numbers[num] = f
-
-        model_files = []
-        for i in range(ml):
-            model_files.append(numbers[i])
-
-
-        for model_file in model_files:
-            model_path = os.path.join(name, model_file)
-            session = ort.InferenceSession(model_path, providers=['CPUExecutionProvider'])
-
-            input_info = session.get_inputs()[0]
-            self.loaded_models.append(session)
-
-        self.onnx_load = True
-
-
-
-
 class VolClustXGB(FichEn):
     def __init__(self, sett, early_stopping=True, output=True, loss="QLIKE"):
         self.loss = loss
         self.output = output
         self.models = []
-        self.scaler = StandardScaler()
-        #self.scaler_y = StandardScaler()
         self.X_shape = 0
         self.is_fitted = False
         self.onnx_load = False
@@ -1713,9 +1468,9 @@ class VolClustXGB(FichEn):
             with open(file_path, 'w', encoding='utf-8') as f:
                 json.dump(self.meta, f, ensure_ascii=False, indent=2)
 
-            if hasattr(self, 'scaler'):
+            """if hasattr(self, 'scaler'):
                 scaler_path = os.path.join(name, f"{name}_scaler.pkl")
-                joblib.dump(self.scaler, scaler_path)
+                joblib.dump(self.scaler, scaler_path)"""
 
             """if hasattr(self, 'scaler_y'):
                 scaler_path = os.path.join(name, f"{name}_scaler_y.pkl")
@@ -1734,10 +1489,10 @@ class VolClustXGB(FichEn):
 
             initial_type = [('float_input', FloatTensorType([None, self.X_shape]))]
 
-            if hasattr(self, 'scaler') and self.scaler is not None:
+            """if hasattr(self, 'scaler') and self.scaler is not None:
                 scaler_path = os.path.join(onnx_dir, f"{name}_scaler.pkl")
                 joblib.dump(self.scaler, scaler_path)
-                self.dquantprint(f"Scaler is saved in {scaler_path}")
+                self.dquantprint(f"Scaler is saved in {scaler_path}")"""
 
             """if hasattr(self, 'scaler_y') and self.scaler_y is not None:
                 scaler_path = os.path.join(onnx_dir, f"{name}_scaler_y.pkl")
@@ -1779,10 +1534,10 @@ class VolClustXGB(FichEn):
         if self.meta['model_type'] != 'xgb':
             raise ValueError(f"Wrong model type, expected xgb and not a {self.meta['model_type']}")
 
-        scaler_files = [f for f in os.listdir(name) if f.endswith('_scaler.pkl')]
+        """scaler_files = [f for f in os.listdir(name) if f.endswith('_scaler.pkl')]
         if scaler_files:
             scaler_path = os.path.join(name, scaler_files[0])
-            self.scaler = joblib.load(scaler_path)
+            self.scaler = joblib.load(scaler_path)"""
 
         """scaler_files = [f for f in os.listdir(name) if f.endswith('_scaler_y.pkl')]
         if scaler_files:
@@ -1823,8 +1578,6 @@ class VolClustLightGBM(FichEn):
         self.loss = loss
         self.output = output
         self.models = []
-        self.scaler = StandardScaler()
-        #self.scaler_y = StandardScaler()
         self.X_shape = 0
         self.is_fitted = False
         self.onnx_load = False
@@ -1892,9 +1645,9 @@ class VolClustLightGBM(FichEn):
             with open(file_path, 'w', encoding='utf-8') as f:
                 json.dump(self.meta, f, ensure_ascii=False, indent=2)
 
-            if hasattr(self, 'scaler'):
+            """if hasattr(self, 'scaler'):
                 scaler_path = os.path.join(name, f"{name}_scaler.pkl")
-                joblib.dump(self.scaler, scaler_path)
+                joblib.dump(self.scaler, scaler_path)"""
 
             """if hasattr(self, 'scaler_y'):
                 scaler_path = os.path.join(name, f"{name}_scaler_y.pkl")
@@ -1913,10 +1666,10 @@ class VolClustLightGBM(FichEn):
 
             initial_type = [('float_input', FloatTensorType([None, self.X_shape]))]
 
-            if hasattr(self, 'scaler') and self.scaler is not None:
+            """if hasattr(self, 'scaler') and self.scaler is not None:
                 scaler_path = os.path.join(onnx_dir, f"{name}_scaler.pkl")
                 joblib.dump(self.scaler, scaler_path)
-                self.dquantprint(f"Scaler is saved in {scaler_path}")
+                self.dquantprint(f"Scaler is saved in {scaler_path}")"""
 
             """if hasattr(self, 'scaler_y') and self.scaler_y is not None:
                 scaler_path = os.path.join(onnx_dir, f"{name}_scaler_y.pkl")
@@ -1958,10 +1711,10 @@ class VolClustLightGBM(FichEn):
         if self.meta['model_type'] != 'lgbm':
             raise ValueError(f"Wrong model type, expected lgbm and not a {self.meta['model_type']}")
 
-        scaler_files = [f for f in os.listdir(name) if f.endswith('_scaler.pkl')]
+        """scaler_files = [f for f in os.listdir(name) if f.endswith('_scaler.pkl')]
         if scaler_files:
             scaler_path = os.path.join(name, scaler_files[0])
-            self.scaler = joblib.load(scaler_path)
+            self.scaler = joblib.load(scaler_path)"""
 
         """scaler_files = [f for f in os.listdir(name) if f.endswith('_scaler_y.pkl')]
         if scaler_files:

{dquant-1.2.4 → dquant-1.3.0b0}/src/dquant/visual.py

@@ -314,8 +314,8 @@ class Visualization:
 
         plt.show()
 
-    def forward_validation_errors(self, mse_errors, r2_errors, save_path=None):
-        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
+    def forward_validation_errors(self, mse_errors, save_path=None):
+        fig, (ax1) = plt.subplots(1, 1, figsize=(15, 6))
 
         ax1.plot(list(mse_errors), label='Train Loss',
                  color=self.config['colors']['primary'])
@@ -327,17 +327,6 @@ class Visualization:
         self.__style_axes(ax1)
         self.__style_legend(ax1)
 
-        ax2.plot(list(r2_errors), label='Train R²',
-                 color=self.config['colors']['primary'])
-
-        ax2.set_xlabel('Trees')
-        ax2.set_ylabel('R² Score')
-        ax2.set_title('R² Score over Trees')
-        ax2.grid(True)
-
-        self.__style_axes(ax2)
-        self.__style_legend(ax2)
-
         plt.tight_layout()
 
         if save_path:
@@ -346,8 +335,8 @@ class Visualization:
         plt.show()
 
 
-    def show_errors(self, train_errors, val_errors, train_r2, val_r2, save_path=None):
-        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
+    def show_errors(self, train_errors, val_errors, save_path=None):
+        fig, (ax1) = plt.subplots(1, 1, figsize=(15, 6))
 
         ax1.plot(list(train_errors), label='Train Loss',
                  color=self.config['colors']['primary'])
@@ -360,19 +349,6 @@ class Visualization:
 
         self.__style_axes(ax1)
         self.__style_legend(ax1)
-
-        ax2.plot(list(train_r2), label='Train R²',
-                 color=self.config['colors']['primary'])
-        ax2.plot(list(val_r2), label='Validation R²',
-                 color=self.config['colors']['secondary'])
-        ax2.set_xlabel('Trees')
-        ax2.set_ylabel('R² Score')
-        ax2.set_title('R² Score over Trees')
-        ax2.grid(True)
-
-        self.__style_axes(ax2)
-        self.__style_legend(ax2)
-
         plt.tight_layout()
 
         if save_path: