nnodely 0.14.0__py3-none-any.whl

nnodely/logger.py

@@ -0,0 +1,94 @@
+import logging
+import sys
+
+from nnodely import LOG_LEVEL
+
+BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8)
+
+#The background is set with 40 plus the number of the color, and the foreground with 30
+
+#These are the sequences need to get colored ouput
+RESET_SEQ = "\033[0m"
+COLOR_SEQ = "\033[%dm"
+COLOR_BOLD_SEQ = "\033[1;%dm"
+BOLD_SEQ = "\033[1m"
+
+SUPPRESS = logging.CRITICAL + 10
+logging.getLogger().setLevel(SUPPRESS)
+COLORS = {
+    logging.DEBUG: MAGENTA,
+    logging.INFO: BLUE,
+    logging.WARNING: YELLOW,
+    logging.CRITICAL: RED,
+    logging.ERROR: RED
+}
+LEVEL_STRING = {
+    logging.DEBUG: "DEBUG",
+    logging.INFO: "INFO",
+    logging.WARNING: "WARNING",
+    logging.CRITICAL: "CRITICAL",
+    logging.ERROR: "ERROR",
+    SUPPRESS: "SUPPRESS"
+}
+
+
+
+class JsonFormatter(logging.Formatter):
+    FORMAT = "[%(levelname)s][%(name)s:%(filename)s:%(funcName)s:%(lineno)d] %(message)s" # + ""
+    FORMAT_WARNING = "[%(funcName)s] %(message)s"
+    FORMAT_INFO = "%(message)s"
+    def __init__(self):
+        logging.Formatter.__init__(self, self.FORMAT)
+
+    def format(self, record):
+        if record.levelno == logging.WARNING:
+            self._style._fmt = self.FORMAT_WARNING
+        elif record.levelno == logging.INFO:
+            self._style._fmt = self.FORMAT_INFO
+        else:
+            self._style._fmt = self.FORMAT
+        result = logging.Formatter.format(self, record)
+        result = COLOR_SEQ % (30 + COLORS[record.levelno]) + result + RESET_SEQ
+        return result
+
+
+# Custom logger class with multiple destinations
+class nnLogger(logging.Logger):
+    levels = []
+    loggers = []
+    params = {'level':None}
+    def __init__(self, name, level):
+        logging.Logger.__init__(self, name)
+        self.setLevel(max(level, LOG_LEVEL))
+
+        #file = logging.FileHandler('example.log')
+        #color_formatter = ColoredFormatter(self.COLOR_FORMAT)
+
+        self.console = logging.StreamHandler(sys.stdout)
+        color_formatter = JsonFormatter()
+
+        self.console.setFormatter(color_formatter)
+        #self.console.setLevel(logging.CRITICAL)
+
+        #logging.getLogger().addHandler(self.console)
+        self.addHandler(self.console)
+        self.loggers.append(self)
+        self.levels.append(level)
+        #self.addHandler(file)
+
+    def setAllLevel(self, level):
+        if self.params['level'] is None or self.params['level'] != level:
+            self._log(logging.INFO,
+                      COLOR_SEQ % (30 + BLUE) + (f" Loggers to {LEVEL_STRING[level]} ").center(80, '=') + RESET_SEQ, None)
+            self.params['level'] = level
+        for ind, logger in enumerate(self.loggers):
+            logger.setLevel(level)
+
+    def resetAllLevel(self):
+        if self.params['level'] != 0:
+            self._log(logging.INFO, COLOR_SEQ % (30 + BLUE) + (" Standard Level Log ").center(80, '=') + RESET_SEQ, None)
+            self.params['level'] = None
+        for ind, logger in enumerate(self.loggers):
+            logger.setLevel(self.levels[ind])
+
+

nnodely/loss.py

@@ -0,0 +1,30 @@
+import torch.nn as nn
+import torch
+from nnodely.utils import check
+
+available_losses = ['mse', 'rmse', 'mae']
+
+# class CustomRMSE(nn.Module):
+#     def __init__(self):
+#         super(CustomRMSE, self).__init__()
+#         self.mse = nn.MSELoss()
+#
+#     def forward(self, inA, inB):
+#         #assert predictions.keys() == labels.keys(), "Keys of predictions and labels must match"
+#         #loss = torch.sqrt(self.mse(inA, inB))
+#         return self.mse(inA, inB)
+
+class CustomLoss(nn.Module):
+    def __init__(self, loss_type='mse'):
+        super(CustomLoss, self).__init__()
+        check(loss_type in available_losses, TypeError, f'The \"{loss_type}\" loss is not available. Possible losses are: {available_losses}.')
+        self.loss_type = loss_type
+        self.loss = nn.MSELoss()
+        if self.loss_type == 'mae':
+            self.loss = nn.L1Loss()
+        
+    def forward(self, inA, inB):
+        res = self.loss(inA,inB)
+        if self.loss_type == 'rmse':
+            res = torch.sqrt(res)
+        return res

nnodely/model.py

@@ -0,0 +1,263 @@
+from itertools import product
+import numpy as np
+
+import torch.nn as nn
+import torch
+
+import copy
+
+class Model(nn.Module):
+    def __init__(self, model_def):
+        super(Model, self).__init__()
+        model_def = copy.deepcopy(model_def)
+        self.inputs = model_def['Inputs']
+        self.outputs = model_def['Outputs']
+        self.relations = model_def['Relations']
+        self.params = model_def['Parameters']
+        self.constants = model_def['Constants']
+        self.sample_time = model_def['Info']['SampleTime']
+        self.functions = model_def['Functions']
+        self.state_model_main = model_def['States']
+        self.minimizers = model_def['Minimizers']
+        self.state_model = copy.deepcopy(self.state_model_main)
+        self.input_ns_backward = {key:value['ns'][0] for key, value in (model_def['Inputs']|model_def['States']).items()}
+        self.input_n_samples = {key:value['ntot'] for key, value in (model_def['Inputs']|model_def['States']).items()}
+        self.minimizers_keys = [self.minimizers[key]['A'] for key in self.minimizers] + [self.minimizers[key]['B'] for key in self.minimizers]
+
+        ## Build the network
+        self.all_parameters = {}
+        self.all_constants = {}
+        self.relation_forward = {}
+        self.relation_inputs = {}
+        self.states = {}
+        self.states_closed_loop = {}
+        self.states_connect = {}
+        #self.constants = set()
+
+        self.connect_variables = {}
+        self.connect = {}
+        self.initialize_connect = False
+
+        ## Define the correct slicing
+        json_inputs = self.inputs | self.state_model
+        for _, items in self.relations.items():
+            if items[0] == 'SamplePart':
+                if items[1][0] in json_inputs.keys():
+                    items[2][0] = self.input_ns_backward[items[1][0]] + items[2][0]
+                    items[2][1] = self.input_ns_backward[items[1][0]] + items[2][1]
+                    if len(items) > 3: ## Offset
+                        items[3] = self.input_ns_backward[items[1][0]] + items[3]
+            if items[0] == 'TimePart':
+                if items[1][0] in json_inputs.keys():
+                    items[2][0] = self.input_ns_backward[items[1][0]] + round(items[2][0]/self.sample_time)
+                    items[2][1] = self.input_ns_backward[items[1][0]] + round(items[2][1]/self.sample_time)
+                    if len(items) > 3: ## Offset
+                        items[3] = self.input_ns_backward[items[1][0]] + round(items[3]/self.sample_time)
+                else:
+                    items[2][0] = round(items[2][0]/self.sample_time)
+                    items[2][1] = round(items[2][1]/self.sample_time)
+                    if len(items) > 3: ## Offset
+                        items[3] = round(items[3]/self.sample_time)
+
+        ## Create all the parameters
+        for name, param_data in self.params.items():
+            window = 'tw' if 'tw' in param_data.keys() else ('sw' if 'sw' in param_data.keys() else None)
+            aux_sample_time = self.sample_time if 'tw' == window else 1
+            sample_window = round(param_data[window] / aux_sample_time) if window else 1
+            param_size = (sample_window,)+tuple(param_data['dim']) if type(param_data['dim']) is list else (sample_window, param_data['dim'])
+            if 'values' in param_data:
+                self.all_parameters[name] = nn.Parameter(torch.tensor(param_data['values'], dtype=torch.float32), requires_grad=True)
+            # TODO clean code
+            elif 'init_fun' in param_data:
+                exec(param_data['init_fun']['code'], globals())
+                function_to_call = globals()[param_data['init_fun']['name']]
+                values = np.zeros(param_size)
+                for indexes in product(*(range(v) for v in param_size)):
+                    if 'params' in param_data['init_fun']:
+                        values[indexes] = function_to_call(indexes, param_size, param_data['init_fun']['params'])
+                    else:
+                        values[indexes] = function_to_call(indexes, param_size)
+                self.all_parameters[name] = nn.Parameter(torch.tensor(values.tolist(), dtype=torch.float32), requires_grad=True)
+            else:
+                self.all_parameters[name] = nn.Parameter(torch.rand(size=param_size, dtype=torch.float32), requires_grad=True)
+
+        ## Create all the constants
+        for name, param_data in self.constants.items():
+            self.all_constants[name] = nn.Parameter(torch.tensor(param_data['values'], dtype=torch.float32), requires_grad=False)
+
+
+        ## Initialize state variables
+        self.init_states(self.state_model_main, reset_states=True)
+        all_params_and_consts = self.all_parameters | self.all_constants
+
+        ## Create all the relations
+        for relation, inputs in self.relations.items():
+            ## Take the relation name
+            rel_name = inputs[0]
+            ## collect the inputs needed for the relation
+            input_var = inputs[1]
+            ## collect the constants of the model
+            #self.constants.update([item for item in inputs[1] if not isinstance(item, str)])
+            
+            ## Create All the Relations
+            func = getattr(self,rel_name)
+            if func:
+                layer_inputs = []
+                for item in inputs[2:]:
+                    if item in list(self.params.keys()): ## the relation takes parameters
+                        layer_inputs.append(self.all_parameters[item])
+                    elif item in list(self.constants.keys()): ## the relation takes parameters
+                        layer_inputs.append(self.all_constants[item])
+                    elif item in list(self.functions.keys()): ## the relation takes a custom function
+                        layer_inputs.append(self.functions[item])
+                        if 'params_and_consts' in self.functions[item].keys() and len(self.functions[item]['params_and_consts']) >= 0: ## Parametric function that takes parameters
+                            layer_inputs.append([all_params_and_consts[par] for par in self.functions[item]['params_and_consts']])
+                        if 'map_over_dim' in self.functions[item].keys():
+                            layer_inputs.append(self.functions[item]['map_over_dim'])
+                    else: 
+                        layer_inputs.append(item)
+
+                ## Initialize the relation
+                self.relation_forward[relation] = func(*layer_inputs)
+                ## Save the inputs needed for the relative relation
+                self.relation_inputs[relation] = input_var
+
+            else:
+                print(f"Key Error: [{rel_name}] Relation not defined")
+
+        ## Add the gradient to all the relations and parameters that requires it
+        self.relation_forward = nn.ParameterDict(self.relation_forward)
+        self.all_constants = nn.ParameterDict(self.all_constants)
+        self.all_parameters = nn.ParameterDict(self.all_parameters)
+
+        ## list of network outputs
+        self.network_output_predictions = set(self.outputs.values())
+
+        ## list of network minimization outputs
+        self.network_output_minimizers = [] 
+        for _,value in self.minimizers.items():
+            self.network_output_minimizers.append(self.outputs[value['A']]) if value['A'] in self.outputs.keys() else self.network_output_minimizers.append(value['A'])
+            self.network_output_minimizers.append(self.outputs[value['B']]) if value['B'] in self.outputs.keys() else self.network_output_minimizers.append(value['B'])
+        self.network_output_minimizers = set(self.network_output_minimizers)
+
+        ## list of all the network Outputs
+        self.network_outputs = self.network_output_predictions.union(self.network_output_minimizers)
+
+    def forward(self, kwargs):
+        result_dict = {}
+
+        ## Initially i have only the inputs from the dataset, the parameters, and the constants
+        available_inputs = [key for key in self.inputs.keys() if key not in self.connect.keys()]  ## remove connected inputs
+        available_states = [key for key in self.state_model.keys() if key not in self.states_connect.keys()] ## remove connected states
+        available_keys = set(available_inputs + list(self.all_parameters.keys()) + list(self.all_constants.keys()) + available_states)
+
+        ## Forward pass through the relations
+        while not self.network_outputs.issubset(available_keys): ## i need to climb the relation tree until i get all the outputs
+            for relation in self.relations.keys():
+                ## if i have all the variables i can calculate the relation
+                if set(self.relation_inputs[relation]).issubset(available_keys) and (relation not in available_keys):
+                    ## Collect all the necessary inputs for the relation
+                    layer_inputs = []
+                    for key in self.relation_inputs[relation]:
+                        if key in self.all_constants.keys(): ## relation that takes a constant
+                            layer_inputs.append(self.all_constants[key])
+                        elif key in self.states.keys(): ## relation that takes a state
+                            layer_inputs.append(self.states[key])
+                        elif key in available_inputs:  ## relation that takes inputs (self.inputs.keys())
+                            layer_inputs.append(kwargs[key])
+                        elif key in self.all_parameters.keys(): ## relation that takes parameters
+                            layer_inputs.append(self.all_parameters[key])
+                        else: ## relation than takes another relation or a connect variable
+                            layer_inputs.append(result_dict[key])
+
+                    ## Execute the current relation
+                    result_dict[relation] = self.relation_forward[relation](*layer_inputs)
+                    available_keys.add(relation)
+
+                    ## Update the connect variables if necessary
+                    for connect_in, connect_out in self.connect.items():
+                        if relation == self.outputs[connect_out]:  ## we have to save the output
+                            shift = result_dict[relation].shape[1]
+                            self.connect_variables[connect_in] = torch.roll(self.connect_variables[connect_in], shifts=-1, dims=1)
+                            self.connect_variables[connect_in][:, -shift:, :] = result_dict[relation]
+                            result_dict[connect_in] = self.connect_variables[connect_in].clone()
+                            available_keys.add(connect_in)
+
+                    ## Update connect state if necessary
+                    if relation in self.states_connect.values():
+                        for state in [key for key, value in self.states_connect.items() if value == relation]:
+                            shift = result_dict[relation].shape[1]
+                            self.states[state] = torch.roll(self.states[state], shifts=-1, dims=1)
+                            self.states[state][:, -shift:, :] = result_dict[relation]#.detach() ## TODO: detach??
+                            available_keys.add(state)
+
+        ## Update closed loop state if necessary
+        for relation in self.relations.keys():
+            if relation in self.states_closed_loop.values():
+                for state in [key for key, value in self.states_closed_loop.items() if value == relation]:
+                    shift = result_dict[relation].shape[1]
+                    self.states[state] = torch.roll(self.states[state], shifts=-1, dims=1)  # shifts=-shift, dims=1)
+                    self.states[state][:, -shift:, :] = result_dict[relation]  # .detach() ## TODO: detach??
+
+        ## Return a dictionary with all the outputs final values
+        output_dict = {key: result_dict[value] for key, value in self.outputs.items()}
+        ## Return a dictionary with the minimization relations
+        minimize_dict = {}
+        for key in self.minimizers_keys:
+            minimize_dict[key] = result_dict[self.outputs[key]] if key in self.outputs.keys() else result_dict[key]
+                
+        return output_dict, minimize_dict
+
+
+    def init_states(self, state_model, connect = {}, reset_states = False):
+        ## Initialize state variables
+        if reset_states:
+            self.reset_states()
+        self.reset_connect_variables(copy.deepcopy(connect), only=False)
+        self.states_connect = {}
+        self.states_closed_loop = {}
+        ## save the states updates
+        for state, param in state_model.items():
+            if 'connect' in param.keys():
+                self.states_connect[state] = param['connect']
+            else:
+                self.states_closed_loop[state] = param['closedLoop']
+
+    def reset_connect_variables(self, connect, values = None, only = True):
+        if only == False:
+            self.connect = connect
+            self.connect_variables = {}
+            self.initialize_connect = True
+        for key in connect.keys():
+            if values is not None and key in values.keys():
+                self.connect_variables[key] = values[key].clone()
+            elif only == False:
+                batch = values[list(values)[0]].shape[0] if values is not None else 1
+                window_size = self.input_n_samples[key]
+                self.connect_variables[key] = torch.zeros(size=(batch, window_size, self.inputs[key]['dim']),
+                                                           dtype=torch.float32, requires_grad=False)
+    def reset_states(self, values = None, only = True):
+        if values is None:
+            for key, value in self.state_model.items():
+                batch = self.states[key].shape[0] if key in self.states else 1
+                window_size = self.input_n_samples[key]
+                self.states[key] = torch.zeros(size=(batch, window_size, self.state_model[key]['dim']),
+                                               dtype=torch.float32, requires_grad=False)
+        else:
+            if type(values) is set:
+                for key in self.state_model.keys():
+                    if key in values:
+                        batch = self.states[key].shape[0] if key in self.states else 1
+                        window_size = self.input_n_samples[key]
+                        self.states[key] = torch.zeros(size=(batch, window_size, self.state_model[key]['dim']),
+                                                   dtype=torch.float32, requires_grad=False)
+            else:
+                for key in self.state_model.keys():
+                    if key in values.keys():
+                        self.states[key] = values[key].clone()
+                        self.states[key].requires_grad = False
+                    elif only == False:
+                        batch = values[list(values)[0]].shape[0]
+                        window_size = self.input_n_samples[key]
+                        self.states[key] = torch.zeros(size=(batch, window_size, self.state_model[key]['dim']),
+                                                         dtype=torch.float32, requires_grad=False)

nnodely/modeldef.py

@@ -0,0 +1,205 @@
+import copy
+
+import numpy as np
+
+from nnodely.input import closedloop_name, connect_name
+from nnodely.utils import check, merge
+from nnodely.relation import MAIN_JSON, Stream
+from nnodely.output import Output
+
+from nnodely.logger import logging, nnLogger
+log = nnLogger(__name__, logging.INFO)
+
+class ModelDef():
+    def __init__(self, model_def = MAIN_JSON):
+        # Models definition
+        self.json_base = copy.deepcopy(model_def)
+
+        # Inizialize the model definition
+        self.json = copy.deepcopy(self.json_base)
+        if "SampleTime" in self.json['Info']:
+            self.sample_time = self.json['Info']["SampleTime"]
+        else:
+            self.sample_time = None
+        self.model_dict = {}
+        self.minimize_dict = {}
+        self.update_state_dict = {}
+
+    def __contains__(self, key):
+        return key in self.json
+
+    def __getitem__(self, key):
+        return self.json[key]
+
+    def __setitem__(self, key, value):
+        self.json[key] = value
+
+    def isDefined(self):
+        return self.json is not None
+
+    def update(self, model_def = None, model_dict = None, minimize_dict = None, update_state_dict = None):
+        self.json = copy.deepcopy(model_def) if model_def is not None else copy.deepcopy(self.json_base)
+        model_dict = copy.deepcopy(model_dict) if model_dict is not None else self.model_dict
+        minimize_dict = copy.deepcopy(minimize_dict) if minimize_dict is not None else self.minimize_dict
+        update_state_dict = copy.deepcopy(update_state_dict) if update_state_dict is not None else self.update_state_dict
+
+        # Add models to the model_def
+        for key, stream_list in model_dict.items():
+            for stream in stream_list:
+                self.json = merge(self.json, stream.json)
+        if len(model_dict) > 1:
+            if 'Models' not in self.json:
+                self.json['Models'] = {}
+            for model_name, model_params in model_dict.items():
+                self.json['Models'][model_name] = {'Inputs': [], 'States': [], 'Outputs': [], 'Parameters': [],
+                                                        'Constants': []}
+                parameters, constants, inputs, states = set(), set(), set(), set()
+                for param in model_params:
+                    self.json['Models'][model_name]['Outputs'].append(param.name)
+                    parameters |= set(param.json['Parameters'].keys())
+                    constants |= set(param.json['Constants'].keys())
+                    inputs |= set(param.json['Inputs'].keys())
+                    states |= set(param.json['States'].keys())
+                self.json['Models'][model_name]['Parameters'] = list(parameters)
+                self.json['Models'][model_name]['Constants'] = list(constants)
+                self.json['Models'][model_name]['Inputs'] = list(inputs)
+                self.json['Models'][model_name]['States'] = list(states)
+        elif len(model_dict) == 1:
+            self.json['Models'] = list(model_dict.keys())[0]
+
+        if 'Minimizers' not in self.json:
+            self.json['Minimizers'] = {}
+        for key, minimize in minimize_dict.items():
+            self.json = merge(self.json, minimize['A'].json)
+            self.json = merge(self.json, minimize['B'].json)
+            self.json['Minimizers'][key] = {}
+            self.json['Minimizers'][key]['A'] = minimize['A'].name
+            self.json['Minimizers'][key]['B'] = minimize['B'].name
+            self.json['Minimizers'][key]['loss'] = minimize['loss']
+
+        for key, update_state in update_state_dict.items():
+            self.json = merge(self.json, update_state.json)
+
+        if "SampleTime" in self.json['Info']:
+            self.sample_time = self.json['Info']["SampleTime"]
+
+
+    def __update_state(self, stream_out, state_list_in, UpdateState):
+        from nnodely.input import  State
+        if type(state_list_in) is not list:
+            state_list_in = [state_list_in]
+        for state_in in state_list_in:
+            check(isinstance(stream_out, (Output, Stream)), TypeError,
+                  f"The {stream_out} must be a Stream or Output and not a {type(stream_out)}.")
+            check(type(state_in) is State, TypeError,
+                  f"The {state_in} must be a State and not a {type(state_in)}.")
+            check(stream_out.dim['dim'] == state_in.dim['dim'], ValueError,
+                  f"The dimension of {stream_out.name} is not equal to the dimension of {state_in.name} ({stream_out.dim['dim']}!={state_in.dim['dim']}).")
+            if type(stream_out) is Output:
+                stream_name = self.json['Outputs'][stream_out.name]
+                stream_out = Stream(stream_name,stream_out.json,stream_out.dim, 0)
+            self.update_state_dict[state_in.name] = UpdateState(stream_out, state_in)
+
+    def addConnect(self, stream_out, state_list_in):
+        from nnodely.input import Connect
+        self.__update_state(stream_out, state_list_in, Connect)
+        self.update()
+
+    def addClosedLoop(self, stream_out, state_list_in):
+        from nnodely.input import ClosedLoop
+        self.__update_state(stream_out, state_list_in, ClosedLoop)
+        self.update()
+
+    def addModel(self, name, stream_list):
+        if isinstance(stream_list, (Output,Stream)):
+            stream_list = [stream_list]
+        if type(stream_list) is list:
+            self.model_dict[name] = copy.deepcopy(stream_list)
+        else:
+            raise TypeError(f'stream_list is type {type(stream_list)} but must be an Output or Stream or a list of them')
+        self.update()
+
+    def removeModel(self, name_list):
+        if type(name_list) is str:
+            name_list = [name_list]
+        if type(name_list) is list:
+            for name in name_list:
+                check(name in self.model_dict, IndexError, f"The name {name} is not part of the available models")
+                del self.model_dict[name]
+        self.update()
+
+    def addMinimize(self, name, streamA, streamB, loss_function='mse'):
+        check(isinstance(streamA, (Output, Stream)), TypeError, 'streamA must be an instance of Output or Stream')
+        check(isinstance(streamB, (Output, Stream)), TypeError, 'streamA must be an instance of Output or Stream')
+        check(streamA.dim == streamB.dim, ValueError, f'Dimension of streamA={streamA.dim} and streamB={streamB.dim} are not equal.')
+        self.minimize_dict[name]={'A':copy.deepcopy(streamA), 'B': copy.deepcopy(streamB), 'loss':loss_function}
+        self.update()
+
+    def removeMinimize(self, name_list):
+        if type(name_list) is str:
+            name_list = [name_list]
+        if type(name_list) is list:
+            for name in name_list:
+                check(name in self.minimize_dict, IndexError, f"The name {name} is not part of the available minimuzes")
+                del self.minimize_dict[name]
+        self.update()
+
+    def setBuildWindow(self, sample_time = None):
+        check(self.json is not None, RuntimeError, "No model is defined!")
+        if sample_time is not None:
+            check(sample_time > 0, RuntimeError, 'Sample time must be strictly positive!')
+            self.sample_time = sample_time
+        else:
+            if self.sample_time is None:
+                self.sample_time = 1
+
+        self.json['Info'] = {"SampleTime": self.sample_time}
+
+        check(self.json['Inputs'] | self.json['States'] != {}, RuntimeError, "No model is defined!")
+        json_inputs = self.json['Inputs'] | self.json['States']
+
+        for key,value in self.json['States'].items():
+            check(closedloop_name in self.json['States'][key] or connect_name in self.json['States'][key],
+                  KeyError, f'Update function is missing for state {key}. Use Connect or ClosedLoop to update the state.')
+
+        input_tw_backward, input_tw_forward, input_ns_backward, input_ns_forward = {}, {}, {}, {}
+        for key, value in json_inputs.items():
+            if value['sw'] == [0,0] and value['tw'] == [0,0]:
+                assert(False), f"Input {key} has no time window or sample window"
+            if value['sw'] == [0, 0] and self.sample_time is not None:
+                input_ns_backward[key] = round(-value['tw'][0] / self.sample_time)
+                input_ns_forward[key] = round(value['tw'][1] / self.sample_time)
+            elif self.sample_time is not None:
+                input_ns_backward[key] = max(round(-value['tw'][0] / self.sample_time),-value['sw'][0])
+                input_ns_forward[key] = max(round(value['tw'][1] / self.sample_time),value['sw'][1])
+            else:
+                check(value['tw'] == [0,0], RuntimeError, f"Sample time is not defined for input {key}")
+                input_ns_backward[key] = -value['sw'][0]
+                input_ns_forward[key] = value['sw'][1]
+            value['ns'] = [input_ns_backward[key], input_ns_forward[key]]
+            value['ntot'] = sum(value['ns'])
+
+        self.json['Info']['ns'] = [max(input_ns_backward.values()), max(input_ns_forward.values())]
+        self.json['Info']['ntot'] = sum(self.json['Info']['ns'])
+        if self.json['Info']['ns'][0] < 0:
+            log.warning(
+                f"The input is only in the far past the max_samples_backward is: {self.json['Info']['ns'][0]}")
+        if self.json['Info']['ns'][1] < 0:
+            log.warning(
+                f"The input is only in the far future the max_sample_forward is: {self.json['Info']['ns'][1]}")
+
+        for k, v in (self.json['Parameters']|self.json['Constants']).items():
+            if 'values' in v:
+                window = 'tw' if 'tw' in v.keys() else ('sw' if 'sw' in v.keys() else None)
+                if window == 'tw':
+                    check(np.array(v['values']).shape[0] == v['tw']/self.sample_time, ValueError,
+                      f"{k} has a different number of values for this sample time.")
+
+
+    def updateParameters(self, model):
+        if model is not None:
+            for key in self.json['Parameters'].keys():
+                if key in model.all_parameters:
+                    self.json['Parameters'][key]['values'] = model.all_parameters[key].tolist()
+                    if 'init_fun' in self.json['Parameters'][key]:
+                        del self.json['Parameters'][key]['init_fun']