nnodely 1.5.4__py3-none-any.whl → 1.5.5.dev2__py3-none-any.whl

nnodely/__init__.py

@@ -14,7 +14,15 @@ from nnodely.layers.arithmetic import Add, Sum, Sub, Mul, Div, Pow, Neg, Sign
 from nnodely.layers.trigonometric import Sin, Cos, Tan, Cosh, Tanh, Sech
 from nnodely.layers.parametricfunction import ParamFun
 from nnodely.layers.fuzzify import Fuzzify
-from nnodely.layers.part import Part, Select, Concatenate, SamplePart, SampleSelect, TimePart, TimeConcatenate
+from nnodely.layers.part import (
+    Part,
+    Select,
+    Concatenate,
+    SamplePart,
+    SampleSelect,
+    TimePart,
+    TimeConcatenate,
+)
 from nnodely.layers.localmodel import LocalModel
 from nnodely.layers.equationlearner import EquationLearner
 from nnodely.layers.timeoperation import Integrate, Differentiate
@@ -37,43 +45,85 @@ from nnodely.support import logger
 major, minor = sys.version_info.major, sys.version_info.minor
 logger.LOG_LEVEL = logging.INFO
 
-__version__ = '1.5.4'
+__version__ = "1.5.4"
 
 if major < 3:
-    sys.exit("Sorry, Python 2 is not supported. You need Python >= 3.10 for "+__package__+".")
+    sys.exit(
+        "Sorry, Python 2 is not supported. You need Python >= 3.10 for "
+        + __package__
+        + "."
+    )
 elif minor < 9:
-    sys.exit("Sorry, You need Python >= 3.10 for "+__package__+".")
+    sys.exit("Sorry, You need Python >= 3.10 for " + __package__ + ".")
 else:
-    print('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>' +
-          f' {__package__}_v{__version__} '.center(20, '-') +
-          '<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<')
+    print(
+        ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
+        + f" {__package__}_v{__version__} ".center(20, "-")
+        + "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"
+    )
 
 
 __all__ = [
-    'nnodely', 'Modely', 'clearNames',
-    'Input', 'Connect', 'ClosedLoop',
-    'Parameter', 'Constant', 'SampleTime',
-    'Output',
-    'Relu', 'ELU', 'Softmax', 'Sigmoid', 'Identity',
-    'Fir',
-    'Linear',
-    'NeuralODE',
-    'Add', 'Sum', 'Sub', 'Mul', 'Div', 'Pow', 'Neg', 'Sign',
-    'Sin', 'Cos', 'Tan', 'Cosh', 'Tanh', 'Sech',
-    'ParamFun',
-    'Fuzzify',
-    'Part',  'Select',  'Concatenate',
-    'SamplePart',  'SampleSelect',
-    'TimePart',  'TimeConcatenate',
-    'LocalModel',
-    'EquationLearner',
-    'Integrate',  'Differentiate',
-    'Interpolation',
-    'ForwardEuler', 'RK2', 'RK4',
-    'TextVisualizer', 'MPLVisualizer', 'MPLNotebookVisualizer',
-    'StandardExporter',
-    'SGD', 'Adam', 'Optimizer',
-    'init_negexp', 'init_lin', 'init_constant', 'init_exp',
+    "nnodely",
+    "Modely",
+    "clearNames",
+    "Input",
+    "Connect",
+    "ClosedLoop",
+    "Parameter",
+    "Constant",
+    "SampleTime",
+    "Output",
+    "Relu",
+    "ELU",
+    "Softmax",
+    "Sigmoid",
+    "Identity",
+    "Fir",
+    "Linear",
+    "NeuralODE",
+    "Add",
+    "Sum",
+    "Sub",
+    "Mul",
+    "Div",
+    "Pow",
+    "Neg",
+    "Sign",
+    "Sin",
+    "Cos",
+    "Tan",
+    "Cosh",
+    "Tanh",
+    "Sech",
+    "ParamFun",
+    "Fuzzify",
+    "Part",
+    "Select",
+    "Concatenate",
+    "SamplePart",
+    "SampleSelect",
+    "TimePart",
+    "TimeConcatenate",
+    "LocalModel",
+    "EquationLearner",
+    "Integrate",
+    "Differentiate",
+    "Interpolation",
+    "ForwardEuler",
+    "RK2",
+    "RK4",
+    "TextVisualizer",
+    "MPLVisualizer",
+    "MPLNotebookVisualizer",
+    "StandardExporter",
+    "SGD",
+    "Adam",
+    "Optimizer",
+    "init_negexp",
+    "init_lin",
+    "init_constant",
+    "init_exp",
     # Main nnodely classes
-    '__version__'
+    "__version__",
 ]

nnodely/basic/loss.py

@@ -2,26 +2,35 @@ import torch.nn as nn
 import torch
 from nnodely.support.utils import check
 
-available_losses = ['mse', 'rmse', 'mae', 'cross_entropy']
+available_losses = ["mse", "rmse", "mae", "cross_entropy"]
+
 
 class CustomLoss(nn.Module):
-    def __init__(self, loss_type='mse', **kwargs):
+    def __init__(self, loss_type="mse", **kwargs):
         super(CustomLoss, self).__init__()
-        check(loss_type in available_losses, TypeError, f'The \"{loss_type}\" loss is not available. Possible losses are: {available_losses}.')
+        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(**kwargs)
         if callable(loss_type):
             self.loss = loss_type
-        elif self.loss_type == 'mae':
+        elif self.loss_type == "mae":
             self.loss = nn.L1Loss(**kwargs)
-        elif self.loss_type == 'cross_entropy':
+        elif self.loss_type == "cross_entropy":
             self.loss = nn.CrossEntropyLoss(**kwargs)
-        
+
     def forward(self, inA, inB):
-        if self.loss_type == 'cross_entropy':
-            inB = inB.squeeze().float() if inA.shape == inB.shape else inB.squeeze().long()
+        if self.loss_type == "cross_entropy":
+            inB = (
+                inB.squeeze().float()
+                if inA.shape == inB.shape
+                else inB.squeeze().long()
+            )
             inA = inA.squeeze()
-        res = self.loss(inA,inB)
-        if self.loss_type == 'rmse':
+        res = self.loss(inA, inB)
+        if self.loss_type == "rmse":
             res = torch.sqrt(res)
-        return res
+        return res

nnodely/basic/model.py

@@ -9,34 +9,46 @@ from itertools import product
 from nnodely.support.utils import TORCH_DTYPE
 from nnodely.support import initializer
 
+
 @torch.fx.wrap
 def update_state(data_in, rel):
-    #virtual = torch.roll(data_in, shifts=-1, dims=1)
+    # virtual = torch.roll(data_in, shifts=-1, dims=1)
     max_dim = min(rel.size(1), data_in.size(1))
     data_out = data_in.clone()
     data_out[:, -max_dim:, :] = rel[:, -max_dim:, :]
     return data_out
 
+
 class Model(nn.Module):
     def __init__(self, model_def):
         super(Model, self).__init__()
         model_def = copy.deepcopy(model_def)
 
-        self.states = {key: value for key, value in model_def['Inputs'].items() if ('closedLoop' in value.keys() or 'connect' in value.keys())}
+        self.states = {
+            key: value
+            for key, value in model_def["Inputs"].items()
+            if ("closedLoop" in value.keys() or "connect" in value.keys())
+        }
 
-        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.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.minimizers = model_def['Minimizers'] if 'Minimizers' in model_def else {}
-        self.minimizers_keys = [self.minimizers[key]['A'] for key in self.minimizers] + [self.minimizers[key]['B'] for key in self.minimizers]
+        self.minimizers = model_def["Minimizers"] if "Minimizers" in model_def else {}
+        self.minimizers_keys = [
+            self.minimizers[key]["A"] for key in self.minimizers
+        ] + [self.minimizers[key]["B"] for key in self.minimizers]
 
-        self.input_ns_backward = {key:value['ns'][0] for key, value in model_def['Inputs'].items()}
-        self.input_n_samples = {key:value['ntot'] for key, value in model_def['Inputs'].items()}
+        self.input_ns_backward = {
+            key: value["ns"][0] for key, value in model_def["Inputs"].items()
+        }
+        self.input_n_samples = {
+            key: value["ntot"] for key, value in model_def["Inputs"].items()
+        }
 
         ## Build the network
         self.all_parameters = {}
@@ -51,55 +63,89 @@ class Model(nn.Module):
 
         ## Define the correct slicing
         for _, items in self.relations.items():
-            if items[0] == 'SamplePart':
+            if items[0] == "SamplePart":
                 if items[1][0] in self.inputs.keys():
                     items[3][0] = self.input_ns_backward[items[1][0]] + items[3][0]
                     items[3][1] = self.input_ns_backward[items[1][0]] + items[3][1]
-                    if len(items) > 4: ## Offset
+                    if len(items) > 4:  ## Offset
                         items[4] = self.input_ns_backward[items[1][0]] + items[4]
-            if items[0] == 'TimePart':
+            if items[0] == "TimePart":
                 if items[1][0] in self.inputs.keys():
-                    items[3][0] = self.input_ns_backward[items[1][0]] + round(items[3][0]/self.sample_time)
-                    items[3][1] = self.input_ns_backward[items[1][0]] + round(items[3][1]/self.sample_time)
-                    if len(items) > 4: ## Offset
-                        items[4] = self.input_ns_backward[items[1][0]] + round(items[4]/self.sample_time)
+                    items[3][0] = self.input_ns_backward[items[1][0]] + round(
+                        items[3][0] / self.sample_time
+                    )
+                    items[3][1] = self.input_ns_backward[items[1][0]] + round(
+                        items[3][1] / self.sample_time
+                    )
+                    if len(items) > 4:  ## Offset
+                        items[4] = self.input_ns_backward[items[1][0]] + round(
+                            items[4] / self.sample_time
+                        )
                 else:
-                    items[3][0] = round(items[3][0]/self.sample_time)
-                    items[3][1] = round(items[3][1]/self.sample_time)
-                    if len(items) > 4: ## Offset
-                        items[4] = round(items[4]/self.sample_time)
+                    items[3][0] = round(items[3][0] / self.sample_time)
+                    items[3][1] = round(items[3][1] / self.sample_time)
+                    if len(items) > 4:  ## Offset
+                        items[4] = round(items[4] / 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 None
+            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 None
+            )
             if sample_window is None:
-                param_size = tuple(param_data['dim']) if type(param_data['dim']) is list else (param_data['dim'],)
+                param_size = (
+                    tuple(param_data["dim"])
+                    if type(param_data["dim"]) is list
+                    else (param_data["dim"],)
+                )
             else:
-                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_DTYPE), requires_grad=True)
+                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_DTYPE),
+                    requires_grad=True,
+                )
             # TODO clean code
-            elif 'init_fun' in param_data:
-                if 'code' in param_data['init_fun'].keys():
-                    exec(param_data['init_fun']['code'], globals())
-                    function_to_call = globals()[param_data['init_fun']['name']]
+            elif "init_fun" in param_data:
+                if "code" in param_data["init_fun"].keys():
+                    exec(param_data["init_fun"]["code"], globals())
+                    function_to_call = globals()[param_data["init_fun"]["name"]]
                 else:
-                    function_to_call = getattr(initializer, param_data['init_fun']['name'])
+                    function_to_call = getattr(
+                        initializer, 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'])
+                    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_DTYPE), requires_grad=True)
+                self.all_parameters[name] = nn.Parameter(
+                    torch.tensor(values.tolist(), dtype=TORCH_DTYPE), requires_grad=True
+                )
             else:
-                self.all_parameters[name] = nn.Parameter(torch.rand(size=param_size, dtype=TORCH_DTYPE), requires_grad=True)
+                self.all_parameters[name] = nn.Parameter(
+                    torch.rand(size=param_size, dtype=TORCH_DTYPE), 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_DTYPE), requires_grad=False)
+            self.all_constants[name] = nn.Parameter(
+                torch.tensor(param_data["values"], dtype=TORCH_DTYPE),
+                requires_grad=False,
+            )
         all_params_and_consts = self.all_parameters | self.all_constants
 
         ## Create all the relations
@@ -107,27 +153,41 @@ class Model(nn.Module):
             ## Take the relation name and the inputs needed to solve the relation
             rel_name, input_var = inputs[0], inputs[1]
             ## Create All the Relations
-            func = getattr(self,rel_name)
+            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
+                    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 a constant
+                    elif item in list(
+                        self.constants.keys()
+                    ):  ## the relation takes a constant
                         layer_inputs.append(self.all_constants[item])
-                    elif item in list(self.functions.keys()): ## the relation takes a custom function
+                    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'])
+                        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)
 
-                if rel_name == 'SamplePart':
+                if rel_name == "SamplePart":
                     if layer_inputs[0] == -1:
                         layer_inputs[0] = self.input_n_samples[input_var[0]]
-                elif rel_name == 'TimePart':
+                elif rel_name == "TimePart":
                     if layer_inputs[0] == -1:
                         layer_inputs[0] = self.input_n_samples[input_var[0]]
                     else:
@@ -145,60 +205,96 @@ class Model(nn.Module):
         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'])
+        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)
+        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_update.keys()]  ## remove connected inputs
-        available_keys = set(available_inputs + list(self.all_parameters.keys()) + list(self.all_constants.keys()))
+        available_inputs = [
+            key for key in self.inputs.keys() if key not in self.connect_update.keys()
+        ]  ## remove connected inputs
+        available_keys = set(
+            available_inputs
+            + list(self.all_parameters.keys())
+            + list(self.all_constants.keys())
+        )
 
         ## 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
+        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):
+                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
+                        if (
+                            key in self.all_constants.keys()
+                        ):  ## relation that takes a constant
                             layer_inputs.append(self.all_constants[key])
                         elif key in available_inputs:  ## relation that takes inputs
                             layer_inputs.append(kwargs[key])
-                        elif key in self.all_parameters.keys(): ## relation that takes parameters
+                        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
+                        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)
+                    result_dict[relation] = self.relation_forward[relation](
+                        *layer_inputs
+                    )
                     available_keys.add(relation)
 
                     ## Check if the relation is inside the connect
                     for connect_input, connect_rel in self.connect_update.items():
                         if relation == connect_rel:
-                            result_dict[connect_input] = update_state(kwargs[connect_input], result_dict[relation])
+                            result_dict[connect_input] = update_state(
+                                kwargs[connect_input], result_dict[relation]
+                            )
                             available_keys.add(connect_input)
 
         ## Return a dictionary with all the connected inputs
-        connect_update_dict = {key: result_dict[key] for key in self.connect_update.keys()}
+        connect_update_dict = {
+            key: result_dict[key] for key in self.connect_update.keys()
+        }
         ## Return a dictionary with all the relations that updates the state variables
-        closed_loop_update_dict = {key: result_dict[value] for key, value in self.closed_loop_update.items()}
+        closed_loop_update_dict = {
+            key: result_dict[value] for key, value in self.closed_loop_update.items()
+        }
         ## 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]
+            minimize_dict[key] = (
+                result_dict[self.outputs[key]]
+                if key in self.outputs.keys()
+                else result_dict[key]
+            )
         return output_dict, minimize_dict, closed_loop_update_dict, connect_update_dict
 
-    def update(self, *, closed_loop = {}, connect = {}, disconnect = False):
+    def update(self, *, closed_loop={}, connect={}, disconnect=False):
         self.closed_loop_update = {}
         self.connect_update = {}
 
@@ -206,15 +302,23 @@ class Model(nn.Module):
             return
 
         for key, state in self.states.items():
-            if 'connect' in state.keys():
-                self.connect_update[key] = state['connect']
-            elif 'closedLoop' in state.keys():
-                self.closed_loop_update[key] = state['closedLoop']
+            if "connect" in state.keys():
+                self.connect_update[key] = state["connect"]
+            elif "closedLoop" in state.keys():
+                self.closed_loop_update[key] = state["closedLoop"]
 
         # Get relation from outputs
         for connect_in, connect_rel in connect.items():
-            set_relation = self.outputs[connect_rel] if connect_rel in self.outputs.keys() else connect_rel
+            set_relation = (
+                self.outputs[connect_rel]
+                if connect_rel in self.outputs.keys()
+                else connect_rel
+            )
             self.connect_update[connect_in] = set_relation
         for close_in, close_rel in closed_loop.items():
-            set_relation = self.outputs[close_rel] if close_rel in self.outputs.keys() else close_rel
+            set_relation = (
+                self.outputs[close_rel]
+                if close_rel in self.outputs.keys()
+                else close_rel
+            )
             self.closed_loop_update[close_in] = set_relation