12162489906

Committed 04 Dec 2024 03:04PM UTC coverage: 93.934% (-0.2%) from 94.155%

Build # 12162489906

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #6 from tonegas/release/0.15.0

Release/0.15.0

Run Details

37 of 42 new or added lines in 8 files covered. (88.1%)

59 existing lines in 7 files now uncovered.

8625 of 9182 relevant lines covered (93.93%)

0.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.65

/nnodely/visualizer/textvisualizer.py

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()

1	import numpy as np	1✔
2	from pprint import pformat	1✔
3
4	from nnodely.visualizer.visualizer import Visualizer, color, GREEN, RED, BLUE	1✔
5
6	class TextVisualizer(Visualizer):	1✔
7	def __init__(self, verbose=1):	1✔
8	self.verbose = verbose	1✔
9
10	def __title(self,msg, lenght = 80):	1✔
11	print(color((msg).center(lenght, '='), GREEN, True))	1✔
12
13	def __subtitle(self,msg, lenght = 80):	1✔
14	print(color((msg).center(lenght, '-'), GREEN, True))	×
15
16	def __line(self):	1✔
17	print(color('='.center(80, '='),GREEN))	1✔
18
19	def __singleline(self):	1✔
20	print(color('-'.center(80, '-'),GREEN))	×
21
22	def __info(self,name, dim =30):	1✔
23	print(color((name).ljust(dim),BLUE))	1✔
24
25	def __paramjson(self,name, value, dim =30):	1✔
26	lines = pformat(value, width=80 - dim).strip().splitlines()	1✔
27	vai = ('\n' + (' ' * dim)).join(x for x in lines)	1✔
28	# pformat(value).strip().splitlines().rjust(40)
29	print(color((name).ljust(dim) + vai,GREEN))	1✔
30
31	def __param(self,name, value, dim =30):	1✔
32	print(color((name).ljust(dim) + value,GREEN))	1✔
33
34	def showModel(self, model):	1✔
35	if self.verbose >= 1:	1✔
36	self.__title(" nnodely Model ")	1✔
37	print(color(pformat(model),GREEN))	1✔
38	self.__line()	1✔
39
40	def showMinimize(self,variable_name):	1✔
41	if self.verbose >= 2:	×
42	self.__title(f" Minimize Error of {variable_name} with {self.n4m.model_def['Minimizers'][variable_name]['loss']} ")	×
43	self.__paramjson(f"Model {self.n4m.model_def['Minimizers'][variable_name]['A'].name}", self.n4m.model_def['Minimizers'][variable_name]['A'].json)	×
44	self.__paramjson(f"Model {self.n4m.model_def['Minimizers'][variable_name]['B'].name}", self.n4m.model_def['Minimizers'][variable_name]['B'].json)	×
45	self.__line()	×
46
47	def showModelInputWindow(self):	1✔
48	if self.verbose >= 2:	1✔
49	input_ns_backward = {key: value['ns'][0] for key, value in	1✔
50	(self.n4m.model_def['Inputs'] \| self.n4m.model_def['States']).items()}
51	input_ns_forward = {key: value['ns'][1] for key, value in	1✔
52	(self.n4m.model_def['Inputs'] \| self.n4m.model_def['States']).items()}
53	self.__title(" nnodely Model Input Windows ")	1✔
54	#self.__paramjson("time_window_backward:",self.n4m.input_tw_backward)
55	#self.__paramjson("time_window_forward:",self.n4m.input_tw_forward)
56	self.__paramjson("sample_window_backward:", input_ns_backward)	1✔
57	self.__paramjson("sample_window_forward:", input_ns_forward)	1✔
58	self.__paramjson("input_n_samples:", self.n4m.input_n_samples)	1✔
59	self.__param("max_samples [backw, forw]:", f"[{self.n4m.model_def['Info']['ns'][0]},{self.n4m.model_def['Info']['ns'][1]}]")	1✔
60	self.__param("max_samples total:",f"{self.n4m.max_n_samples}")	1✔
61	self.__line()	1✔
62
63	def showModelRelationSamples(self):	1✔
64	if self.verbose >= 2:	×
65	self.__title(" nnodely Model Relation Samples ")	×
66	self.__paramjson("Relation_samples:", self.n4m.relation_samples)	×
67	self.__line()	×
68
69	def showBuiltModel(self):	1✔
70	if self.verbose >= 2:	1✔
71	self.__title(" nnodely Built Model ")	1✔
72	print(color(pformat(self.n4m.model),GREEN))	1✔
73	self.__line()	1✔
74
75	def showWeights(self, weights = None):	1✔
76	self.__title(" nnodely Models Weights ")	×
77	for key, param in self.n4m.model.all_parameters.items():	×
78	if weights is None or key in weights:	×
79	self.__paramjson(key,param.tolist())	×
80	self.__line()	×
81
82	def showWeightsInTrain(self, batch = None, epoch = None, weights = None):	1✔
83	if self.verbose >= 2:	1✔
84	par = self.n4m.run_training_params	1✔
85	dim = len(self.n4m.model_def['Minimizers'])	1✔
86	COLOR = BLUE	1✔
87	if epoch is not None:	1✔
88	print(color('\|' + (f"{epoch + 1}/{par['num_of_epochs']}").center(10, ' ') + '\|',COLOR), end='')	1✔
89	print(color((f' Params end epochs {epoch + 1} ').center(20 * (dim + 1) - 1, '-') + '\|',COLOR))	1✔
90
91	if batch is not None:	1✔
92	print(color('\|' + (f"{batch + 1}").center(10, ' ') + '\|', COLOR), end='')	1✔
93	print(color((f' Params end batch {batch + 1} ').center(20 * (dim + 1) - 1, '-') + '\|', COLOR))	1✔
94
95	for key, param in self.n4m.model.all_parameters.items():	1✔
96	if weights is None or key in weights:	1✔
97	print(color('\|' + (f"{key}").center(10, ' ') + '\|', COLOR), end='')	1✔
98	print(color((f'{param.tolist()}').center(20 * (dim + 1) - 1, ' ') + '\|', COLOR))	1✔
99
100	if epoch is not None:	1✔
101	print(color('\|'+(f'').center(10+20*(dim+1), '-') + '\|'))	1✔
102
103	def showDataset(self, name):	1✔
104	if self.verbose >= 1:	1✔
105	self.__title(" nnodely Model Dataset ")	1✔
106	self.__param("Dataset Name:", name)	1✔
107	self.__param("Number of files:", f'{self.n4m.file_count}')	1✔
108	self.__param("Total number of samples:", f'{self.n4m.num_of_samples[name]}')	1✔
109	for key in self.n4m.model_def['Inputs'].keys():	1✔
110	if key in self.n4m.data[name].keys():	1✔
111	self.__param(f"Shape of {key}:", f'{self.n4m.data[name][key].shape}')	1✔
112	self.__line()	1✔
113
114	def showStartTraining(self):	1✔
115	if self.verbose >= 1:	1✔
116	par = self.n4m.run_training_params	1✔
117	dim = len(self.n4m.model_def['Minimizers'])	1✔
118	self.__title(" nnodely Training ", 12+(len(self.n4m.model_def['Minimizers'])+1)*20)	1✔
119	print(color('\|'+(f'Epoch').center(10,' ')+'\|'),end='')	1✔
120	for key in self.n4m.model_def['Minimizers'].keys():	1✔
121	print(color((f'{key}').center(19, ' ') + '\|'), end='')	1✔
122	print(color((f'Total').center(19, ' ') + '\|'))	1✔
123
124	print(color('\|' + (f' ').center(10, ' ') + '\|'), end='')	1✔
125	for key in self.n4m.model_def['Minimizers'].keys():	1✔
126	print(color((f'Loss').center(19, ' ') + '\|'),end='')	1✔
127	print(color((f'Loss').center(19, ' ') + '\|'))	1✔
128
129	print(color('\|' + (f' ').center(10, ' ') + '\|'), end='')	1✔
130	for key in self.n4m.model_def['Minimizers'].keys():	1✔
131	if par['n_samples_val']:	1✔
UNCOV 132	print(color((f'train').center(9, ' ') + '\|'),end='')	×
UNCOV 133	print(color((f'val').center(9, ' ') + '\|'),end='')	×
134	else:
135	print(color((f'train').center(19, ' ') + '\|'), end='')	1✔
136	if par['n_samples_val']:	1✔
UNCOV 137	print(color((f'train').center(9, ' ') + '\|'), end='')	×
UNCOV 138	print(color((f'val').center(9, ' ') + '\|'))	×
139	else:
140	print(color((f'train').center(19, ' ') + '\|'))	1✔
141
142	print(color('\|'+(f'').center(10+20*(dim+1), '-') + '\|'))	1✔
143
144	def showTraining(self, epoch, train_losses, val_losses):	1✔
145	if self.verbose >= 1:	1✔
146	eng = lambda val: np.format_float_scientific(val, precision=3)	1✔
147	par = self.n4m.run_training_params	1✔
148	show_epoch = 1 if par['num_of_epochs'] <= 20 else 10	1✔
149	dim = len(self.n4m.model_def['Minimizers'])	1✔
150	if epoch < par['num_of_epochs']:	1✔
151	print('', end='\r')	1✔
152	print('\|' + (f"{epoch + 1}/{par['num_of_epochs']}").center(10, ' ') + '\|', end='')	1✔
153	train_loss = []	1✔
154	val_loss = []	1✔
155	for key in self.n4m.model_def['Minimizers'].keys():	1✔
156	train_loss.append(train_losses[key][epoch])	1✔
157	if val_losses:	1✔
UNCOV 158	val_loss.append(val_losses[key][epoch])	×
UNCOV 159	print((f'{eng(train_losses[key][epoch])}').center(9, ' ') + '\|', end='')	×
UNCOV 160	print((f'{eng(val_losses[key][epoch])}').center(9, ' ') + '\|', end='')	×
161	else:
162	print((f'{eng(train_losses[key][epoch])}').center(19, ' ') + '\|', end='')	1✔
163
164	if val_losses:	1✔
UNCOV 165	print((f'{eng(np.mean(train_loss))}').center(9, ' ') + '\|', end='')	×
UNCOV 166	print((f'{eng(np.mean(val_loss))}').center(9, ' ') + '\|', end='')	×
167	else:
168	print((f'{eng(np.mean(train_loss))}').center(19, ' ') + '\|', end='')	1✔
169
170	if (epoch + 1) % show_epoch == 0:	1✔
171	print('', end='\r')	1✔
172	print(color('\|' + (f"{epoch + 1}/{par['num_of_epochs']}").center(10, ' ') + '\|'), end='')	1✔
173	for key in self.n4m.model_def['Minimizers'].keys():	1✔
174	if val_losses:	1✔
UNCOV 175	print(color((f'{eng(train_losses[key][epoch])}').center(9, ' ') + '\|'), end='')	×
UNCOV 176	print(color((f'{eng(val_losses[key][epoch])}').center(9, ' ') + '\|'), end='')	×
177	else:
178	print(color((f'{eng(train_losses[key][epoch])}').center(19, ' ') + '\|'), end='')	1✔
179
180	if val_losses:	1✔
UNCOV 181	print(color((f'{eng(np.mean(train_loss))}').center(9, ' ') + '\|'), end='')	×
UNCOV 182	print(color((f'{eng(np.mean(val_loss))}').center(9, ' ') + '\|'))	×
183	else:
184	print(color((f'{eng(np.mean(train_loss))}').center(19, ' ') + '\|'))	1✔
185
186	if epoch+1 == par['num_of_epochs']:	1✔
187	print(color('\|'+(f'').center(10+20*(dim+1), '-') + '\|'))	1✔
188
189	def showTrainingTime(self, time):	1✔
190	if self.verbose >= 1:	1✔
191	self.__title(" nnodely Training Time ")	1✔
192	self.__param("Total time of Training:", f'{time}')	1✔
193	self.__line()	1✔
194
195	def showTrainParams(self):	1✔
196	if self.verbose >= 1:	1✔
197	self.__title(" nnodely Model Train Parameters ")	1✔
198	par = self.n4m.run_training_params	1✔
199	batch_size = par['train_batch_size']	1✔
200	n_samples = par['n_samples_train']	1✔
201	n_update = par['update_per_epochs']	1✔
202	unused_samples = par['unused_samples']	1✔
203
204	self.__paramjson("models:", par['models'])	1✔
205	self.__paramjson("num of epochs:", par['num_of_epochs'])	1✔
206	self.__param("update per epochs:", f"{n_update}")	1✔
207	if par['recurrent_train']:	1✔
UNCOV 208	self.__info("└>(n_samples-batch_size-prediction_samples+1)/(batch_size+step-1)+1")	×
209	else:
210	self.__info("└>(n_samples-batch_size)/batch_size+1")	1✔
211
212	if par['shuffle_data']:	1✔
213	self.__param('shuffle data:', str(par['shuffle_data']))	1✔
214
215	if 'early_stopping' in par:	1✔
216	self.__param('early stopping:', par['early_stopping'])	×
217	self.__paramjson('early stopping params:', par['early_stopping_params'])	×
218
219	if par['recurrent_train']:	1✔
UNCOV 220	self.__param("prediction samples:", f"{par['prediction_samples']}")	×
UNCOV 221	self.__param("step:", f"{par['step']}")	×
UNCOV 222	self.__paramjson("closed loop:", par['closed_loop'])	×
UNCOV 223	self.__paramjson("connect:", par['connect'])	×
224
225	self.__param("train dataset:", f"{par['train_dataset']}")	1✔
226	self.__param("\t- num of samples:", f"{n_samples}")	1✔
227	self.__param("\t- batch size:", f"{batch_size}")	1✔
228	self.__param("\t- unused samples:", f"{unused_samples}")	1✔
229	if par['recurrent_train']:	1✔
UNCOV 230	self.__info("\t └>n_samples-prediction_samples-update_per_epochs*(batch_size+step-1)")	×
231	else:
232	self.__info("\t └>n_samples-update_per_epochs*batch_size")	1✔
233
234	if par['n_samples_val']:	1✔
235	self.__param("val dataset:", f"{par['validation_dataset']}")	1✔
236	self.__param("val {batch size, samples}:", f"{{{par['val_batch_size']}, {par['n_samples_val']}}}")	1✔
237	if par['n_samples_test']:	1✔
238	self.__param("test dataset:", f"{par['test_dataset']}")	1✔
239	self.__param("test {batch size, samples}:", f"{{{par['test_batch_size']}, {par['n_samples_test']}}}")	1✔
240
241	self.__paramjson('minimizers:', par['minimizers'])	1✔
242
243	self.__param("optimizer:", par['optimizer'])	1✔
244	self.__paramjson("optimizer defaults:",self.n4m.run_training_params['optimizer_defaults'])	1✔
245	if self.n4m.run_training_params['optimizer_params'] is not None:	1✔
246	self.__paramjson("optimizer params:", self.n4m.run_training_params['optimizer_params'])	1✔
247
248	self.__line()	1✔
249
250	def showResult(self, name_data):	1✔
251	eng = lambda val: np.format_float_scientific(val, precision=3)	1✔
252	if self.verbose >= 1:	1✔
253	dim_loss = len(max(self.n4m.model_def['Minimizers'].keys(),key=len))	1✔
254	loss_type_list = set([value["loss"] for ind, (key, value) in enumerate(self.n4m.model_def['Minimizers'].items())])	1✔
255	self.__title(f" nnodely Model Results for {name_data} ", dim_loss + 2 + (len(loss_type_list) + 2) * 20)	1✔
256	print(color('\|' + (f'Loss').center(dim_loss, ' ') + '\|'), end='')	1✔
257	for loss in loss_type_list:	1✔
258	print(color((f'{loss}').center(19, ' ') + '\|'), end='')	1✔
259	print(color((f'FVU').center(19, ' ') + '\|'), end='')	1✔
260	print(color((f'AIC').center(19, ' ') + '\|'))	1✔
261
262	print(color('\|' + (f'').center(dim_loss, ' ') + '\|'), end='')	1✔
263	for i in range(len(loss_type_list)):	1✔
264	print(color((f'small better').center(19, ' ') + '\|'), end='')	1✔
265	print(color((f'small better').center(19, ' ') + '\|'), end='')	1✔
266	print(color((f'lower better').center(19, ' ') + '\|'))	1✔
267
268	print(color('\|' + (f'').center(dim_loss + 20 * (len(loss_type_list) + 2), '-') + '\|'))	1✔
269	for ind, (key, value) in enumerate(self.n4m.model_def['Minimizers'].items()):	1✔
270	print(color('\|'+(f'{key}').center(dim_loss, ' ') + '\|'), end='')	1✔
271	for loss in list(loss_type_list):	1✔
272	if value["loss"] == loss:	1✔
273	print(color((f'{eng(self.n4m.performance[name_data][key][value["loss"]])}').center(19, ' ') + '\|'), end='')	1✔
274	else:
275	print(color((f' ').center(19, ' ') + '\|'), end='')	1✔
276	print(color((f'{eng(self.n4m.performance[name_data][key]["fvu"]["total"])}').center(19, ' ') + '\|'), end='')	1✔
277	print(color((f'{eng(self.n4m.performance[name_data][key]["aic"]["value"])}').center(19, ' ') + '\|'))	1✔
278
279	print(color('\|' + (f'').center(dim_loss + 20 * (len(loss_type_list) + 2), '-') + '\|'))	1✔
280	print(color('\|'+(f'Total').center(dim_loss, ' ') + '\|'), end='')	1✔
281	print(color((f'{eng(self.n4m.performance[name_data]["total"]["mean_error"])}').center(len(loss_type_list)*20-1, ' ') + '\|'), end='')	1✔
282	print(color((f'{eng(self.n4m.performance[name_data]["total"]["fvu"])}').center(19, ' ') + '\|'), end='')	1✔
283	print(color((f'{eng(self.n4m.performance[name_data]["total"]["aic"])}').center(19, ' ') + '\|'))	1✔
284
285	print(color('\|' + (f'').center(dim_loss + 20 * (len(loss_type_list) + 2), '-') + '\|'))	1✔
286
287	if self.verbose >= 2:	1✔
288	self.__title(" Detalied Results ")	1✔
289	print(color(pformat(self.n4m.performance), GREEN))	1✔
290	self.__line()	1✔
291
292	def saveModel(self, name, path):	1✔
293	if self.verbose >= 1:	×
294	self.__title(f" Save {name} ")	×
295	self.__param("Model saved in:", path)	×
296	self.__line()	×
297
298	def loadModel(self, name, path):	1✔
299	if self.verbose >= 1:	×
300	self.__title(f" Load {name} ")	×
301	self.__param("Model loaded from:", path)	×
302	self.__line()	×
303
304	def exportModel(self, name, path):	1✔
305	if self.verbose >= 1:	×
306	self.__title(f" Export {name} ")	×
307	self.__param("Model exported in:", path)	×
308	self.__line()	×
309
310	def importModel(self, name, path):	1✔
311	if self.verbose >= 1:	×
312	self.__title(f" Import {name} ")	×
313	self.__param("Model imported from:", path)	×
314	self.__line()	×
315
316	def exportReport(self, name, path):	1✔
317	if self.verbose >= 1:	×
318	self.__title(f" Export {name} Report ")	×
319	self.__param("Report exported in:", path)	×
320	self.__line()	×

tonegas / nnodely / 12162489906

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous