nnodely 0.14.0__py3-none-any.whl

nnodely/visualizer/mplnotebookvisualizer.py

@@ -0,0 +1,66 @@
+import matplotlib.pyplot as plt
+
+from nnodely.visualizer.textvisualizer import TextVisualizer
+from nnodely.fuzzify import return_fuzzify
+from nnodely.parametricfunction import return_standard_inputs, return_function
+from nnodely.utils import check
+from mplplots import plots
+
+class MPLNotebookVisualizer(TextVisualizer):
+    def __init__(self, verbose = 1):
+        super().__init__(verbose)
+
+    def showEndTraining(self, epoch, train_losses, val_losses):
+        for key in self.n4m.model_def['Minimizers'].keys():
+            fig = plt.figure()
+            ax = fig.add_subplot(111)
+            plots.plot_training(ax, "Training", key, train_losses[key], val_losses[key])
+        plt.show()
+
+    def showResult(self, name_data):
+        super().showResult(name_data)
+        for key in self.n4m.model_def['Minimizers'].keys():
+            fig = plt.figure()
+            ax = fig.add_subplot(111)
+            plots.plot_results(ax, name_data, key, self.n4m.prediction[name_data][key]['A'],
+                               self.n4m.prediction[name_data][key]['B'], self.n4m.model_def['Info']["SampleTime"])
+        plt.show()
+
+    def showWeights(self, weights = None):
+        pass
+
+    def showFunctions(self, functions = None, xlim = None, num_points = 1000):
+        check(self.n4m.neuralized, ValueError, "The model has not been neuralized.")
+        for fun, value in self.n4m.model_def['Functions'].items():
+            if fun in functions:
+                if 'functions' in self.n4m.model_def['Functions'][fun]:
+                    x, activ_fun = return_fuzzify(value, xlim, num_points)
+                    fig = plt.figure()
+                    ax = fig.add_subplot(111)
+                    plots.plot_fuzzy(ax, fun, x, activ_fun, value['centers'])
+                    plt.show()
+                elif 'code':
+                    function_inputs = return_standard_inputs(value, self.n4m.model_def_values, xlim, num_points)
+                    function_output, function_input_list = return_function(value, function_inputs)
+                    if value['n_input'] == 2:
+                        x0 = function_inputs[0].reshape(num_points, num_points).tolist()
+                        x1 = function_inputs[1].reshape(num_points, num_points).tolist()
+                        output = function_output.reshape(num_points, num_points).tolist()
+                        params = []
+                        for i, key in enumerate(value['params_and_consts']):
+                            params += [function_inputs[i + value['n_input']].tolist()]
+                        plots.plot_3d_function(plt, fun, x0, x1, params, output, function_input_list)
+                    else:
+                        x = function_inputs[0].reshape(num_points).tolist()
+                        output = function_output.reshape(num_points).tolist()
+                        params = []
+                        for i, key in enumerate(value['params_and_consts']):
+                            params += [function_inputs[i + value['n_input']].tolist()]
+                        plots.plot_2d_function(plt, fun, x, params, output, function_input_list)
+                    plt.show()
+
+
+
+
+
+

nnodely/visualizer/mplvisualizer.py

@@ -0,0 +1,215 @@
+import subprocess, json, os, importlib
+
+from nnodely.visualizer.textvisualizer import TextVisualizer
+from nnodely.fuzzify import return_fuzzify
+from nnodely.parametricfunction import return_standard_inputs, return_function
+from nnodely.utils import check
+from nnodely.modeldef import ModelDef
+
+from nnodely.logger import logging, nnLogger
+log = nnLogger(__name__, logging.INFO)
+
+def get_library_path(library_name):
+    spec = importlib.util.find_spec(library_name)
+    if spec is None:
+        raise ImportError(f"Library {library_name} not found")
+    return os.path.dirname(spec.origin)
+
+class MPLVisualizer(TextVisualizer):
+    def __init__(self, verbose = 1):
+        super().__init__(verbose)
+        # Path to the data visualizer script
+        import signal
+        import sys
+        get_library_path('nnodely')
+        self.training_visualizer_script = os.path.join(get_library_path('nnodely'),'visualizer/dynamicmpl/trainingplot.py')
+        self.time_series_visualizer_script = os.path.join(get_library_path('nnodely'),'visualizer/dynamicmpl/resultsplot.py')
+        self.fuzzy_visualizer_script = os.path.join(get_library_path('nnodely'),'visualizer/dynamicmpl/fuzzyplot.py')
+        self.function_visualizer_script = os.path.join(get_library_path('nnodely'),'visualizer/dynamicmpl/functionplot.py')
+        self.process_training = {}
+        self.process_results = {}
+        self.process_function = {}
+        def signal_handler(sig, frame):
+            for key in self.process_training.keys():
+                self.process_training[key].terminate()
+                self.process_training[key].wait()
+            for name_data in self.process_results.keys():
+                for key in self.process_results[name_data].keys():
+                    self.process_results[name_data][key].terminate()
+                    self.process_results[name_data][key].wait()
+            self.process_results = {}
+            for key in self.process_function.keys():
+                self.process_function[key].terminate()
+                self.process_functios[key].wait()
+            sys.exit()
+
+        signal.signal(signal.SIGINT, signal_handler)
+
+    def showStartTraining(self):
+        pass
+
+    def showTraining(self, epoch, train_losses, val_losses):
+        if epoch == 0:
+            for key in self.process_training.keys():
+                if self.process_training[key].poll() is None:
+                    self.process_training[key].terminate()
+                    self.process_training[key].wait()
+                self.process_training[key] = {}
+
+            self.process_training = {}
+            for key in self.n4m.model_def['Minimizers'].keys():
+                self.process_training[key] = subprocess.Popen(['python', self.training_visualizer_script], stdin=subprocess.PIPE, text=True)
+
+        num_of_epochs = self.n4m.run_training_params['num_of_epochs']
+        train_dataset = self.n4m.run_training_params['train_dataset']
+        validation_dataset = self.n4m.run_training_params['validation_dataset']
+        if epoch+1 <= num_of_epochs:
+            for key in self.n4m.model_def['Minimizers'].keys():
+                if val_losses:
+                    val_loss = val_losses[key][epoch]
+                else:
+                    val_loss = []
+                data = {"title":f"Training on {train_dataset} and {validation_dataset}", "key": key, "last": num_of_epochs - (epoch + 1), "epoch": epoch,
+                        "train_losses": train_losses[key][epoch], "val_losses": val_loss}
+                try:
+                    # Send data to the visualizer process
+                    self.process_training[key].stdin.write(f"{json.dumps(data)}\n")
+                    self.process_training[key].stdin.flush()
+                except BrokenPipeError:
+                    self.closeTraining()
+                    log.warning("The visualizer process has been closed.")
+
+        if epoch+1 == num_of_epochs:
+            for key in self.n4m.model_def['Minimizers'].keys():
+                self.process_training[key].stdin.close()
+
+    def showResult(self, name_data):
+        super().showResult(name_data)
+        check(name_data in self.n4m.performance, ValueError, f"Results not available for {name_data}.")
+        if name_data in self.process_results:
+            for key in self.n4m.model_def['Minimizers'].keys():
+                if key in self.process_results[name_data] and self.process_results[name_data][key].poll() is None:
+                    self.process_results[name_data][key].terminate()
+                    self.process_results[name_data][key].wait()
+                self.process_results[name_data][key] = None
+        self.process_results[name_data] = {}
+
+        for key in self.n4m.model_def['Minimizers'].keys():
+            # Start the data visualizer process
+            self.process_results[name_data][key] = subprocess.Popen(['python', self.time_series_visualizer_script], stdin=subprocess.PIPE,
+                                                    text=True)
+            data = {"name_data": name_data,
+                    "key": key,
+                    "performance": self.n4m.performance[name_data][key],
+                    "prediction_A": self.n4m.prediction[name_data][key]['A'],
+                    "prediction_B": self.n4m.prediction[name_data][key]['B'],
+                    "sample_time": self.n4m.model_def['Info']["SampleTime"]}
+            try:
+                # Send data to the visualizer process
+                self.process_results[name_data][key].stdin.write(f"{json.dumps(data)}\n")
+                self.process_results[name_data][key].stdin.flush()
+                self.process_results[name_data][key].stdin.close()
+            except BrokenPipeError:
+                self.closeResult(self, name_data)
+                log.warning(f"The visualizer {name_data} process has been closed.")
+
+    def showWeights(self, weights = None):
+        pass
+
+    def showFunctions(self, functions = None, xlim = None, num_points = 1000):
+        check(self.n4m.neuralized, ValueError, "The model has not been neuralized.")
+        for key, value in self.n4m.model_def['Functions'].items():
+            if key in functions:
+                if key in self.process_function and self.process_function[key].poll() is None:
+                    self.process_function[key].terminate()
+                    self.process_function[key].wait()
+
+                if 'functions' in self.n4m.model_def['Functions'][key]:
+                    x, activ_fun = return_fuzzify(value, xlim, num_points)
+                    data = {"name": key,
+                            "x": x,
+                            "y": activ_fun,
+                            "chan_centers": value['centers']}
+                    # Start the data visualizer process
+                    self.process_function[key] = subprocess.Popen(['python', self.fuzzy_visualizer_script],
+                                                                  stdin=subprocess.PIPE,
+                                                                  text=True)
+                elif 'code':
+                    model_def = ModelDef(self.n4m.model_def)
+                    model_def.updateParameters(self.n4m.model)
+                    function_inputs = return_standard_inputs(value, model_def, xlim, num_points)
+                    function_output, function_input_list = return_function(value, function_inputs)
+
+                    data = {"name": key}
+                    if value['n_input'] == 2:
+                        data['x0'] = function_inputs[0].reshape(num_points, num_points).tolist()
+                        data['x1'] = function_inputs[1].reshape(num_points, num_points).tolist()
+                        data['output'] = function_output.reshape(num_points, num_points).tolist()
+                    else:
+                        data['x0'] = function_inputs[0].reshape(num_points).tolist()
+                        data['output'] = function_output.reshape(num_points).tolist()
+                    data['params'] = []
+                    for i, key in enumerate(value['params_and_consts']):
+                        data['params'] += [function_inputs[i+value['n_input']].tolist()]
+                    data['input_names'] = function_input_list
+
+                    # Start the data visualizer process
+                    self.process_function[key] = subprocess.Popen(['python', self.function_visualizer_script],
+                                                                  stdin=subprocess.PIPE,
+                                                                  text=True)
+                try:
+                    # Send data to the visualizer process
+                    self.process_function[key].stdin.write(f"{json.dumps(data)}\n")
+                    self.process_function[key].stdin.flush()
+                    self.process_function[key].stdin.close()
+                except BrokenPipeError:
+                    self.closeFunctions()
+                    log.warning(f"The visualizer {functions} process has been closed.")
+
+    def closeFunctions(self, functions = None):
+        if functions is None:
+            for key in self.process_function.keys():
+                self.process_function[key].terminate()
+                self.process_function[key].wait()
+            self.process_function = {}
+        else:
+            for key in functions:
+                self.process_function[key].terminate()
+                self.process_function[key].wait()
+                self.process_function.pop(key)
+
+    def closeTraining(self, minimizer = None):
+        if minimizer is None:
+            for key in self.n4m.model_def['Minimizers'].keys():
+                if key in self.process_training and self.process_training[key].poll() is None:
+                    self.process_training[key].terminate()
+                    self.process_training[key].wait()
+                self.process_training[key] = {}
+        else:
+            self.process_training[minimizer].terminate()
+            self.process_training[minimizer].wait()
+            self.process_training.pop(minimizer)
+
+    def closeResult(self, name_data = None, minimizer = None):
+        if name_data is None:
+            check(minimizer is None, ValueError, "If name_data is None, minimizer must be None.")
+            for name_data in self.process_results.keys():
+                for key in self.process_results[name_data].keys():
+                    self.process_results[name_data][key].terminate()
+                    self.process_results[name_data][key].wait()
+            self.process_results = {}
+        else:
+            if minimizer is None:
+                for key in self.process_results[name_data].keys():
+                    self.process_results[name_data][key].terminate()
+                    self.process_results[name_data][key].wait()
+                self.process_results[name_data] = {}
+            else:
+                self.process_results[name_data][minimizer].terminate()
+                self.process_results[name_data][minimizer].wait()
+                self.process_results[name_data].pop(minimizer)
+
+
+
+
+

nnodely/visualizer/textvisualizer.py

@@ -0,0 +1,320 @@
+import numpy as np
+from pprint import pformat
+
+from nnodely.visualizer.visualizer import Visualizer, color, GREEN, RED, BLUE
+
+class TextVisualizer(Visualizer):
+    def __init__(self, verbose=1):
+        self.verbose = verbose
+
+    def __title(self,msg, lenght = 80):
+        print(color((msg).center(lenght, '='), GREEN, True))
+
+    def __subtitle(self,msg, lenght = 80):
+        print(color((msg).center(lenght, '-'), GREEN, True))
+
+    def __line(self):
+        print(color('='.center(80, '='),GREEN))
+
+    def __singleline(self):
+        print(color('-'.center(80, '-'),GREEN))
+
+    def __info(self,name, dim =30):
+        print(color((name).ljust(dim),BLUE))
+
+    def __paramjson(self,name, value, dim =30):
+        lines = pformat(value, width=80 - dim).strip().splitlines()
+        vai = ('\n' + (' ' * dim)).join(x for x in lines)
+        # pformat(value).strip().splitlines().rjust(40)
+        print(color((name).ljust(dim) + vai,GREEN))
+
+    def __param(self,name, value, dim =30):
+        print(color((name).ljust(dim) + value,GREEN))
+
+    def showModel(self, model):
+        if self.verbose >= 1:
+            self.__title(" nnodely Model ")
+            print(color(pformat(model),GREEN))
+            self.__line()
+
+    def showMinimize(self,variable_name):
+        if self.verbose >= 2:
+            self.__title(f" Minimize Error of {variable_name} with {self.n4m.model_def['Minimizers'][variable_name]['loss']} ")
+            self.__paramjson(f"Model {self.n4m.model_def['Minimizers'][variable_name]['A'].name}", self.n4m.model_def['Minimizers'][variable_name]['A'].json)
+            self.__paramjson(f"Model {self.n4m.model_def['Minimizers'][variable_name]['B'].name}", self.n4m.model_def['Minimizers'][variable_name]['B'].json)
+            self.__line()
+
+    def showModelInputWindow(self):
+        if self.verbose >= 2:
+            input_ns_backward = {key: value['ns'][0] for key, value in
+                                 (self.n4m.model_def['Inputs'] | self.n4m.model_def['States']).items()}
+            input_ns_forward = {key: value['ns'][1] for key, value in
+                                (self.n4m.model_def['Inputs'] | self.n4m.model_def['States']).items()}
+            self.__title(" nnodely Model Input Windows ")
+            #self.__paramjson("time_window_backward:",self.n4m.input_tw_backward)
+            #self.__paramjson("time_window_forward:",self.n4m.input_tw_forward)
+            self.__paramjson("sample_window_backward:", input_ns_backward)
+            self.__paramjson("sample_window_forward:", input_ns_forward)
+            self.__paramjson("input_n_samples:", self.n4m.input_n_samples)
+            self.__param("max_samples [backw, forw]:", f"[{self.n4m.model_def['Info']['ns'][0]},{self.n4m.model_def['Info']['ns'][1]}]")
+            self.__param("max_samples total:",f"{self.n4m.max_n_samples}")
+            self.__line()
+
+    def showModelRelationSamples(self):
+        if self.verbose >= 2:
+            self.__title(" nnodely Model Relation Samples ")
+            self.__paramjson("Relation_samples:", self.n4m.relation_samples)
+            self.__line()
+
+    def showBuiltModel(self):
+        if self.verbose >= 2:
+            self.__title(" nnodely Built Model ")
+            print(color(pformat(self.n4m.model),GREEN))
+            self.__line()
+
+    def showWeights(self, weights = None):
+        self.__title(" nnodely Models Weights ")
+        for key, param in self.n4m.model.all_parameters.items():
+            if weights is None or key in weights:
+                self.__paramjson(key,param.tolist())
+        self.__line()
+
+    def showWeightsInTrain(self, batch = None, epoch = None, weights = None):
+        if self.verbose >= 2:
+            par = self.n4m.run_training_params
+            dim = len(self.n4m.model_def['Minimizers'])
+            COLOR = BLUE
+            if epoch is not None:
+                print(color('|' + (f"{epoch + 1}/{par['num_of_epochs']}").center(10, ' ') + '|',COLOR), end='')
+                print(color((f' Params end epochs {epoch + 1} ').center(20 * (dim + 1) - 1, '-') + '|',COLOR))
+
+            if batch is not None:
+                print(color('|' + (f"{batch + 1}").center(10, ' ') + '|', COLOR), end='')
+                print(color((f' Params end batch {batch + 1} ').center(20 * (dim + 1) - 1, '-') + '|', COLOR))
+
+            for key, param in self.n4m.model.all_parameters.items():
+                if weights is None or key in weights:
+                    print(color('|' + (f"{key}").center(10, ' ') + '|', COLOR), end='')
+                    print(color((f'{param.tolist()}').center(20 * (dim + 1) - 1, ' ') + '|', COLOR))
+
+            if epoch is not None:
+                print(color('|'+(f'').center(10+20*(dim+1), '-') + '|'))
+
+    def showDataset(self, name):
+        if self.verbose >= 1:
+            self.__title(" nnodely Model Dataset ")
+            self.__param("Dataset Name:", name)
+            self.__param("Number of files:", f'{self.n4m.file_count}')
+            self.__param("Total number of samples:", f'{self.n4m.num_of_samples[name]}')
+            for key in self.n4m.model_def['Inputs'].keys():
+                if key in self.n4m.data[name].keys():
+                    self.__param(f"Shape of {key}:", f'{self.n4m.data[name][key].shape}')
+            self.__line()
+
+    def showStartTraining(self):
+        if self.verbose >= 1:
+            par = self.n4m.run_training_params
+            dim = len(self.n4m.model_def['Minimizers'])
+            self.__title(" nnodely Training ", 12+(len(self.n4m.model_def['Minimizers'])+1)*20)
+            print(color('|'+(f'Epoch').center(10,' ')+'|'),end='')
+            for key in self.n4m.model_def['Minimizers'].keys():
+                print(color((f'{key}').center(19, ' ') + '|'), end='')
+            print(color((f'Total').center(19, ' ') + '|'))
+
+            print(color('|' + (f' ').center(10, ' ') + '|'), end='')
+            for key in self.n4m.model_def['Minimizers'].keys():
+                print(color((f'Loss').center(19, ' ') + '|'),end='')
+            print(color((f'Loss').center(19, ' ') + '|'))
+
+            print(color('|' + (f' ').center(10, ' ') + '|'), end='')
+            for key in self.n4m.model_def['Minimizers'].keys():
+                if par['n_samples_val']:
+                    print(color((f'train').center(9, ' ') + '|'),end='')
+                    print(color((f'val').center(9, ' ') + '|'),end='')
+                else:
+                    print(color((f'train').center(19, ' ') + '|'), end='')
+            if par['n_samples_val']:
+                print(color((f'train').center(9, ' ') + '|'), end='')
+                print(color((f'val').center(9, ' ') + '|'))
+            else:
+                print(color((f'train').center(19, ' ') + '|'))
+
+            print(color('|'+(f'').center(10+20*(dim+1), '-') + '|'))
+
+    def showTraining(self, epoch, train_losses, val_losses):
+        if self.verbose >= 1:
+            eng = lambda val: np.format_float_scientific(val, precision=3)
+            par = self.n4m.run_training_params
+            show_epoch = 1 if par['num_of_epochs'] <= 20 else 10
+            dim = len(self.n4m.model_def['Minimizers'])
+            if epoch < par['num_of_epochs']:
+                print('', end='\r')
+                print('|' + (f"{epoch + 1}/{par['num_of_epochs']}").center(10, ' ') + '|', end='')
+                train_loss = []
+                val_loss = []
+                for key in self.n4m.model_def['Minimizers'].keys():
+                    train_loss.append(train_losses[key][epoch])
+                    if val_losses:
+                        val_loss.append(val_losses[key][epoch])
+                        print((f'{eng(train_losses[key][epoch])}').center(9, ' ') + '|', end='')
+                        print((f'{eng(val_losses[key][epoch])}').center(9, ' ') + '|', end='')
+                    else:
+                        print((f'{eng(train_losses[key][epoch])}').center(19, ' ') + '|', end='')
+
+                if val_losses:
+                    print((f'{eng(np.mean(train_loss))}').center(9, ' ') + '|', end='')
+                    print((f'{eng(np.mean(val_loss))}').center(9, ' ') + '|', end='')
+                else:
+                    print((f'{eng(np.mean(train_loss))}').center(19, ' ') + '|', end='')
+
+                if (epoch + 1) % show_epoch == 0:
+                    print('', end='\r')
+                    print(color('|' + (f"{epoch + 1}/{par['num_of_epochs']}").center(10, ' ') + '|'), end='')
+                    for key in self.n4m.model_def['Minimizers'].keys():
+                        if val_losses:
+                            print(color((f'{eng(train_losses[key][epoch])}').center(9, ' ') + '|'), end='')
+                            print(color((f'{eng(val_losses[key][epoch])}').center(9, ' ') + '|'), end='')
+                        else:
+                            print(color((f'{eng(train_losses[key][epoch])}').center(19, ' ') + '|'), end='')
+
+                    if val_losses:
+                        print(color((f'{eng(np.mean(train_loss))}').center(9, ' ') + '|'), end='')
+                        print(color((f'{eng(np.mean(val_loss))}').center(9, ' ') + '|'))
+                    else:
+                        print(color((f'{eng(np.mean(train_loss))}').center(19, ' ') + '|'))
+
+            if epoch+1 == par['num_of_epochs']:
+                print(color('|'+(f'').center(10+20*(dim+1), '-') + '|'))
+
+    def showTrainingTime(self, time):
+        if self.verbose >= 1:
+            self.__title(" nnodely Training Time ")
+            self.__param("Total time of Training:", f'{time}')
+            self.__line()
+
+    def showTrainParams(self):
+        if self.verbose >= 1:
+            self.__title(" nnodely Model Train Parameters ")
+            par = self.n4m.run_training_params
+            batch_size = par['train_batch_size']
+            n_samples = par['n_samples_train']
+            n_update = par['update_per_epochs']
+            unused_samples = par['unused_samples']
+
+            self.__paramjson("models:", par['models'])
+            self.__paramjson("num of epochs:", par['num_of_epochs'])
+            self.__param("update per epochs:", f"{n_update}")
+            if par['recurrent_train']:
+                self.__info("└>(n_samples-batch_size-prediction_samples+1)/(batch_size+step-1)+1")
+            else:
+                self.__info("└>(n_samples-batch_size)/batch_size+1")
+
+            if par['shuffle_data']:
+                self.__param('shuffle data:', str(par['shuffle_data']))
+
+            if 'early_stopping' in par:
+                self.__param('early stopping:', par['early_stopping'])
+                self.__paramjson('early stopping params:', par['early_stopping_params'])
+
+            if par['recurrent_train']:
+                self.__param("prediction samples:", f"{par['prediction_samples']}")
+                self.__param("step:", f"{par['step']}")
+                self.__paramjson("closed loop:", par['closed_loop'])
+                self.__paramjson("connect:", par['connect'])
+
+            self.__param("train dataset:", f"{par['train_dataset']}")
+            self.__param("\t- num of samples:", f"{n_samples}")
+            self.__param("\t- batch size:", f"{batch_size}")
+            self.__param("\t- unused samples:", f"{unused_samples}")
+            if par['recurrent_train']:
+                self.__info("\t  └>n_samples-prediction_samples-update_per_epochs*(batch_size+step-1)")
+            else:
+                self.__info("\t  └>n_samples-update_per_epochs*batch_size")
+
+            if par['n_samples_val']:
+                self.__param("val dataset:", f"{par['validation_dataset']}")
+                self.__param("val {batch size, samples}:", f"{{{par['val_batch_size']}, {par['n_samples_val']}}}")
+            if par['n_samples_test']:
+                self.__param("test dataset:", f"{par['test_dataset']}")
+                self.__param("test {batch size, samples}:", f"{{{par['test_batch_size']}, {par['n_samples_test']}}}")
+
+            self.__paramjson('minimizers:', par['minimizers'])
+
+            self.__param("optimizer:", par['optimizer'])
+            self.__paramjson("optimizer defaults:",self.n4m.run_training_params['optimizer_defaults'])
+            if self.n4m.run_training_params['optimizer_params'] is not None:
+                self.__paramjson("optimizer params:", self.n4m.run_training_params['optimizer_params'])
+
+            self.__line()
+
+    def showResult(self, name_data):
+        eng = lambda val: np.format_float_scientific(val, precision=3)
+        if self.verbose >= 1:
+            dim_loss = len(max(self.n4m.model_def['Minimizers'].keys(),key=len))
+            loss_type_list = set([value["loss"] for ind, (key, value) in enumerate(self.n4m.model_def['Minimizers'].items())])
+            self.__title(f" nnodely Model Results for {name_data} ", dim_loss + 2 + (len(loss_type_list) + 2) * 20)
+            print(color('|' + (f'Loss').center(dim_loss, ' ') + '|'), end='')
+            for loss in loss_type_list:
+                print(color((f'{loss}').center(19, ' ') + '|'), end='')
+            print(color((f'FVU').center(19, ' ') + '|'), end='')
+            print(color((f'AIC').center(19, ' ') + '|'))
+
+            print(color('|' + (f'').center(dim_loss, ' ') + '|'), end='')
+            for i in range(len(loss_type_list)):
+                print(color((f'small better').center(19, ' ') + '|'), end='')
+            print(color((f'small better').center(19, ' ') + '|'), end='')
+            print(color((f'lower better').center(19, ' ') + '|'))
+
+            print(color('|' + (f'').center(dim_loss + 20 * (len(loss_type_list) + 2), '-') + '|'))
+            for ind, (key, value) in enumerate(self.n4m.model_def['Minimizers'].items()):
+                print(color('|'+(f'{key}').center(dim_loss, ' ') + '|'), end='')
+                for loss in list(loss_type_list):
+                    if value["loss"] == loss:
+                        print(color((f'{eng(self.n4m.performance[name_data][key][value["loss"]])}').center(19, ' ') + '|'), end='')
+                    else:
+                        print(color((f' ').center(19, ' ') + '|'), end='')
+                print(color((f'{eng(self.n4m.performance[name_data][key]["fvu"]["total"])}').center(19, ' ') + '|'), end='')
+                print(color((f'{eng(self.n4m.performance[name_data][key]["aic"]["value"])}').center(19, ' ') + '|'))
+
+            print(color('|' + (f'').center(dim_loss + 20 * (len(loss_type_list) + 2), '-') + '|'))
+            print(color('|'+(f'Total').center(dim_loss, ' ') + '|'), end='')
+            print(color((f'{eng(self.n4m.performance[name_data]["total"]["mean_error"])}').center(len(loss_type_list)*20-1, ' ') + '|'), end='')
+            print(color((f'{eng(self.n4m.performance[name_data]["total"]["fvu"])}').center(19, ' ') + '|'), end='')
+            print(color((f'{eng(self.n4m.performance[name_data]["total"]["aic"])}').center(19, ' ') + '|'))
+
+            print(color('|' + (f'').center(dim_loss + 20 * (len(loss_type_list) + 2), '-') + '|'))
+
+        if self.verbose >= 2:
+            self.__title(" Detalied Results ")
+            print(color(pformat(self.n4m.performance), GREEN))
+            self.__line()
+
+    def saveModel(self, name, path):
+        if self.verbose >= 1:
+            self.__title(f" Save {name} ")
+            self.__param("Model saved in:", path)
+            self.__line()
+
+    def loadModel(self, name, path):
+        if self.verbose >= 1:
+            self.__title(f" Load {name} ")
+            self.__param("Model loaded from:", path)
+            self.__line()
+
+    def exportModel(self, name, path):
+        if self.verbose >= 1:
+            self.__title(f" Export {name} ")
+            self.__param("Model exported in:", path)
+            self.__line()
+
+    def importModel(self, name, path):
+        if self.verbose >= 1:
+            self.__title(f" Import {name} ")
+            self.__param("Model imported from:", path)
+            self.__line()
+
+    def exportReport(self, name, path):
+        if self.verbose >= 1:
+            self.__title(f" Export {name} Report ")
+            self.__param("Report exported in:", path)
+            self.__line()