nnodely 1.5.0__tar.gz → 1.5.2__tar.gz

{nnodely-1.5.0/nnodely.egg-info → nnodely-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nnodely
-Version: 1.5.0
+Version: 1.5.2
 Summary: Model-structured neural network framework for the modeling and control of physical systems
 Author-email: Gastone Pietro Rosati Papini <tonegas@gmail.com>
 License: MIT License
@@ -138,7 +138,6 @@ Download the source code and install the dependencies using the following comman
 To contribute to the nnodely framework, you can:
 - Open a pull request, if you have a new feature or bug fix.
 - Open an issue, if you have a question or suggestion.
-- Contact us via email at [gastone.rosatipapini@unitn.it](mailto:gastone.rosatipapini@unitn.it) or [mattia.piccinini@tum.de](mailto:mattia.piccinini@tum.de) to directly **collaborate** with us **on your project**!
 
 We are very happy to collaborate with you!
  
@@ -190,7 +189,7 @@ where $x[1]$ is the next position of the mass, $F[0]$ is the last sample of the
 
 For the input variable `x`, we are using a time window $T_w = 1$ second, which means that we are using the last $N_x$ samples of the variable `x` to estimate the next position of the mass. The value of $N_x$ is equal to $T_w/T_s$, where $T_s$ is the sampling time used to sample the input variable `x`.
 
-In a particular case, our MS-NN formulation becomes equivalent to the discrete-time response of the mass-spring-damper system. This happens when we choose the following values: $N_x = 3$, $h_x$ equal to the characteristic polynomial of the system, and $h_f = T_s^2/m$, where $T_s$ is the sampling time and $m$ is the mass of the system. 
+In a particular case, our MS-NN formulation becomes equivalent to the discrete-time response (discretize with Forward-Euler) of the mass-spring-damper system. This happens when we choose the following values: $N_x = 3$, $h_x$ equal to the characteristic polynomial of the system, and $h_f = T_s^2/m$, where $T_s$ is the sampling time and $m$ is the mass of the system. 
 
 However, our formulation is more general and can take better adapt to model mismatches and noise levels in the measured variables. This improved learning potential can be achieved by using a larger number of samples $N_x$ in the time window of the input variable `x`. 
 
@@ -286,11 +285,29 @@ print(results)
 ### nnodely Folder
 This folder contains all the nnodely library files with relative references.
 
-The nnodely main library files are:
-1. __nnodely.py__ the main file for create the structured network.
-2. __model.py__ containts the pytorch template model for the structured network.
-
-The model structured NN Inputs Outputs and Parameters:
+The `Moldey` main class defined in __nnodely.py__, it contains all the main properties of the nnodely object and it derives from five main operators:
+1. __composer.py__ contains all the functions to build the networks: `addModel`, `neuralizeModel`, `addConnection`, `addClosedLool` etc..
+2. __loader.py__ contains the function for managing the dataset, the main function is `dataLoad`.
+3. __trainer.py__ contains the function for train the network as the `trainModel`.
+4. __exporter.py__ contains all the function for import and export: `saveModel`, `loadModel`, `exportONNX` etc..
+5. __validator.py__ contains all the function for validate the model ad the `resultsAnalysis`.
+All the operators derive from `Network`defined in __network.py__, that contains the shared support functions for all the operators.
+
+The folder basic contatins the main classes for the low level functionalities: 
+1. __model.py__ containts the pytorch template model for the structured network.
+2. __modeldef.py__ containts the operation for work with the json model definition.
+3. __loss.py__ contatins the loss functions.
+4. __optimizer.py__ contains the optimizer calss.
+6. __relation.py__ contains all the main classes from which all the layers are derived.
+
+The other folders are:
+1. exporter that contains the classes for the export functions.
+2. support for the support functions.
+3. visualizer that contains all the classes related to the visualization.
+4. And finally the layers folder.
+
+The layers folder contains all the layers that can be used in the MSNN.
+In particular, the model structured NN is defined by `Inputs`, `Outputs` and `Parameters`:
 1. __input.py__ contains the Input class used for create an input for the network.
 2. __ouptut.py__ contains the Output class used for create an output for the network.
 3. __parameter.py__ contains the logic for create a generic parameters and constants.

{nnodely-1.5.0 → nnodely-1.5.2}/README.md

@@ -92,7 +92,6 @@ Download the source code and install the dependencies using the following comman
 To contribute to the nnodely framework, you can:
 - Open a pull request, if you have a new feature or bug fix.
 - Open an issue, if you have a question or suggestion.
-- Contact us via email at [gastone.rosatipapini@unitn.it](mailto:gastone.rosatipapini@unitn.it) or [mattia.piccinini@tum.de](mailto:mattia.piccinini@tum.de) to directly **collaborate** with us **on your project**!
 
 We are very happy to collaborate with you!
  
@@ -144,7 +143,7 @@ where $x[1]$ is the next position of the mass, $F[0]$ is the last sample of the
 
 For the input variable `x`, we are using a time window $T_w = 1$ second, which means that we are using the last $N_x$ samples of the variable `x` to estimate the next position of the mass. The value of $N_x$ is equal to $T_w/T_s$, where $T_s$ is the sampling time used to sample the input variable `x`.
 
-In a particular case, our MS-NN formulation becomes equivalent to the discrete-time response of the mass-spring-damper system. This happens when we choose the following values: $N_x = 3$, $h_x$ equal to the characteristic polynomial of the system, and $h_f = T_s^2/m$, where $T_s$ is the sampling time and $m$ is the mass of the system. 
+In a particular case, our MS-NN formulation becomes equivalent to the discrete-time response (discretize with Forward-Euler) of the mass-spring-damper system. This happens when we choose the following values: $N_x = 3$, $h_x$ equal to the characteristic polynomial of the system, and $h_f = T_s^2/m$, where $T_s$ is the sampling time and $m$ is the mass of the system. 
 
 However, our formulation is more general and can take better adapt to model mismatches and noise levels in the measured variables. This improved learning potential can be achieved by using a larger number of samples $N_x$ in the time window of the input variable `x`. 
 
@@ -240,11 +239,29 @@ print(results)
 ### nnodely Folder
 This folder contains all the nnodely library files with relative references.
 
-The nnodely main library files are:
-1. __nnodely.py__ the main file for create the structured network.
-2. __model.py__ containts the pytorch template model for the structured network.
-
-The model structured NN Inputs Outputs and Parameters:
+The `Moldey` main class defined in __nnodely.py__, it contains all the main properties of the nnodely object and it derives from five main operators:
+1. __composer.py__ contains all the functions to build the networks: `addModel`, `neuralizeModel`, `addConnection`, `addClosedLool` etc..
+2. __loader.py__ contains the function for managing the dataset, the main function is `dataLoad`.
+3. __trainer.py__ contains the function for train the network as the `trainModel`.
+4. __exporter.py__ contains all the function for import and export: `saveModel`, `loadModel`, `exportONNX` etc..
+5. __validator.py__ contains all the function for validate the model ad the `resultsAnalysis`.
+All the operators derive from `Network`defined in __network.py__, that contains the shared support functions for all the operators.
+
+The folder basic contatins the main classes for the low level functionalities: 
+1. __model.py__ containts the pytorch template model for the structured network.
+2. __modeldef.py__ containts the operation for work with the json model definition.
+3. __loss.py__ contatins the loss functions.
+4. __optimizer.py__ contains the optimizer calss.
+6. __relation.py__ contains all the main classes from which all the layers are derived.
+
+The other folders are:
+1. exporter that contains the classes for the export functions.
+2. support for the support functions.
+3. visualizer that contains all the classes related to the visualization.
+4. And finally the layers folder.
+
+The layers folder contains all the layers that can be used in the MSNN.
+In particular, the model structured NN is defined by `Inputs`, `Outputs` and `Parameters`:
 1. __input.py__ contains the Input class used for create an input for the network.
 2. __ouptut.py__ contains the Output class used for create an output for the network.
 3. __parameter.py__ contains the logic for create a generic parameters and constants.
@@ -340,4 +357,4 @@ Robust and Sample-Efficient Estimation of Vehicle Lateral Velocity Using Neural
 IEEE Transactions on Intelligent Transportation Systems. https://doi.org/10.1109/TITS.2023.3303776
 
 
-<p align="right">(<a href="#readme-top">back to top</a>)</p>
+<p align="right">(<a href="#readme-top">back to top</a>)</p>

{nnodely-1.5.0 → nnodely-1.5.2}/mplplots/plots.py

@@ -30,36 +30,80 @@ def plot_training(ax, title, key, data_train, data_val = None, last = None):
     ax.set_ylim(min_val - min_val / 10, max_val + max_val / 10)
 
 
-def plot_results(ax, name_data, key, A, B, sample_time):
+def plot_results(ax, name_data, key, A, B, data_idxs, sample_time):
     # Plot data
     ax.set_title(f'{key} on the dataset {name_data}')
     A_t = np.transpose(np.array(A))
     B_t = np.transpose(np.array(B))
-    for ind_win in range(A_t.shape[0]):
-        for ind_dim in range(A_t.shape[1]):
-            if len(A_t.shape) == 3:
-                num_samples = len(A_t[ind_win, ind_dim])
-                time_array = np.linspace(0, (num_samples - 1) * sample_time, num_samples)
-                ax.plot(time_array, A_t[ind_win, ind_dim],
-                        label=f'real')
-                ax.plot(time_array, B_t[ind_win, ind_dim], '-.',
-                        label=f'prediction')
-                correlation = np.corrcoef(A_t[ind_win, ind_dim],B_t[ind_win, ind_dim])[0, 1]
-                ax.text(0.05, 0.95, f'Correlation: {correlation:.2f}', transform=ax.transAxes, verticalalignment='top')
+    idxs_t = np.transpose(np.array(data_idxs))
+    color_A = 'tab:blue'
+    rgb_A = mcolors.to_rgb(color_A)
+    color_B = 'tab:orange'
+    rgb_B = mcolors.to_rgb(color_B)
+    delta = 0.1
+
+    if len(A_t.shape) == 3:
+        # Print without prediction samples
+        time_array = []
+        num_samples = A_t.shape[2]
+        for o in range(A_t.shape[1]):
+            time_array.append(np.linspace(0, (num_samples - 1) * sample_time, num_samples) + sample_time * o)
+        time_array = np.array(time_array)
+        for ind_dim in range(A_t.shape[0]):
+            # Print the marker only if the output have a time window
+            ax.plot(time_array[0,:], A_t[ind_dim, 0, :],
+                    color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_A),
+                    marker='s' if A_t.shape[1] > 1 else None, markersize=2,
+                    label=f'A_{ind_dim}')
+            ax.plot(time_array[0,:], B_t[ind_dim, 0, :], '-.',
+                    color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_B),
+                    marker='o' if A_t.shape[1] > 1 else None, markersize=2,
+                    label=f'B_{ind_dim}')
+            if A_t.shape[1] > 1 :
+                correlation = np.empty((A_t.shape[0],A_t.shape[2]))
+                for ind_el in range(A_t.shape[2]):
+                    ax.plot(time_array[:,ind_el], A_t[ind_dim,:,ind_el],  color=tuple((x + delta*ind_dim)%1.0001 for x in rgb_A))
+                    ax.plot(time_array[:,ind_el], B_t[ind_dim,:,ind_el], '-.',  color=tuple((x + delta*ind_dim)%1.0001 for x in rgb_B))
+                    correlation[ind_dim, ind_el] = np.corrcoef(A_t[ind_dim,:,ind_el], B_t[ind_dim,:,ind_el])[0, 1]
+                    ax.text(0.05, 0.95 - 0.05 * ind_dim,
+                            f'Correlation A_{ind_dim} - B_{ind_dim}: {np.mean(correlation, axis=1)[ind_dim]:.2f}',
+                            transform=ax.transAxes, verticalalignment='top')
             else:
-                num_samples = A_t.shape[3]
-                for idx in range(A_t.shape[2]):
-                    time_array = np.linspace(idx * sample_time, (idx + num_samples - 1) * sample_time, num_samples)
-                    ax.plot(time_array, A_t[ind_win, ind_dim, idx],
-                            label=f'real')
-                    ax.plot(time_array, B_t[ind_win, ind_dim, idx], '-.',
-                            label=f'prediction')
-                    correlation = np.corrcoef(A_t[ind_win, ind_dim, idx],B_t[ind_win, ind_dim, idx])[0, 1]
-                    ax.text(0.05, 0.95, f'Correlation: {correlation:.2f}', transform=ax.transAxes, verticalalignment='top')
+                correlation = np.empty((A_t.shape[0],))
+                correlation[ind_dim] = np.corrcoef(A_t[ind_dim, 0], B_t[ind_dim, 0])[0, 1]
+                ax.text(0.05, 0.95-0.05*ind_dim, f'Correlation A_{ind_dim} - B_{ind_dim}: {correlation[ind_dim]:.2f}', transform=ax.transAxes, verticalalignment='top')
+    else:
+        correlation = np.empty(A_t.shape)
+        for ind_dim in range(A_t.shape[0]):
+            first = True
+            ax.scatter(idxs_t[:,0] * sample_time, A_t[ind_dim, 0, :, 0], marker='s', s=6,
+                    color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_A))
+            ax.scatter(idxs_t[:,0] * sample_time, B_t[ind_dim, 0, :, 0], marker='o', s=6,
+                    color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_B))
+            for ind_el in range(A_t.shape[2]):
+                time_array = idxs_t[ind_el] * sample_time
+                # Print the marker only if the output have a time window
+                ax.plot(time_array, A_t[ind_dim, 0, ind_el], marker = 's' if A_t.shape[1] > 1 else None, markersize=2,
+                        color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_A),
+                        label=f'A_{ind_dim}' if first else None)
+                ax.plot(time_array, B_t[ind_dim, 0, ind_el], '-.', marker = 'o' if A_t.shape[1] > 1 else None, markersize=2,
+                        color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_B),
+                        label=f'B_{ind_dim}' if first else None)
+                for ind_pred in range(A_t.shape[3]):
+                    time_array = idxs_t[ind_el,ind_pred] * sample_time + np.linspace(0, (A_t.shape[1] - 1) * sample_time, A_t.shape[1])
+                    ax.plot(time_array, A_t[ind_dim, :, ind_el,ind_pred],
+                            color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_A))
+                    ax.plot(time_array, B_t[ind_dim, :, ind_el,ind_pred], '-.',
+                            color=tuple((x + delta * ind_dim) % 1.0001 for x in rgb_B))
+                first = False
+                for ind_win in range(A_t.shape[1]):
+                    correlation[ind_dim,ind_win,ind_el] = np.corrcoef(A_t[ind_dim,ind_win,ind_el], B_t[ind_dim,ind_win,ind_el])[0, 1]
+            ax.text(0.05, 0.95-0.05*ind_dim, f'Correlation A_{ind_dim} - B_{ind_dim}: {np.mean(correlation, axis=(1, 2, 3))[ind_dim]:.2f}', transform=ax.transAxes, verticalalignment='top')
+
 
     ax.grid(True)
     ax.legend(loc='best')
-    ax.set_xlabel('Time (s)')
+    ax.set_xlabel('Time [s]')
     ax.set_ylabel(f'Value {key}')
 
     # min_val = min([min(A), min(B)])

{nnodely-1.5.0 → nnodely-1.5.2}/nnodely/__init__.py

@@ -17,8 +17,9 @@ from nnodely.layers.fuzzify import Fuzzify
 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, Derivate
+from nnodely.layers.timeoperation import Integrate, Differentiate
 from nnodely.layers.interpolation import Interpolation
+from nnodely.layers.rungekutta import ForwardEuler, RK2, RK4
 
 # Main nnodely classes
 from nnodely.nnodely import nnodely, Modely, clearNames
@@ -35,7 +36,7 @@ from nnodely.support import logger
 major, minor = sys.version_info.major, sys.version_info.minor
 logger.LOG_LEVEL = logging.INFO
 
-__version__ = '1.5.0'
+__version__ = '1.5.2'
 
 if major < 3:
     sys.exit("Sorry, Python 2 is not supported. You need Python >= 3.10 for "+__package__+".")
@@ -64,8 +65,9 @@ __all__ = [
     'TimePart',  'TimeConcatenate',
     'LocalModel',
     'EquationLearner',
-    'Integrate',  'Derivate',
+    'Integrate',  'Differentiate',
     'Interpolation',
+    'ForwardEuler', 'RK2', 'RK4',
     'TextVisualizer', 'MPLVisualizer', 'MPLNotebookVisualizer',
     'StandardExporter',
     'SGD', 'Adam', 'Optimizer',

{nnodely-1.5.0 → nnodely-1.5.2}/nnodely/basic/model.py

@@ -9,14 +9,13 @@ from itertools import product
 from nnodely.support.utils import TORCH_DTYPE
 from nnodely.support import initializer
 
-
-
 @torch.fx.wrap
-def connect(data_in, rel):
-    virtual = torch.roll(data_in, shifts=-1, dims=1)
+def update_state(data_in, rel):
+    #virtual = torch.roll(data_in, shifts=-1, dims=1)
     max_dim = min(rel.size(1), data_in.size(1))
-    virtual[:, -max_dim:, :] = rel[:, -max_dim:, :]
-    return virtual
+    data_out = data_in.clone()
+    data_out[:, -max_dim:, :] = rel[:, -max_dim:, :]
+    return data_out
 
 class Model(nn.Module):
     def __init__(self, model_def):
@@ -184,7 +183,7 @@ class Model(nn.Module):
                     ## 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] = connect(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

{nnodely-1.5.0 → nnodely-1.5.2}/nnodely/basic/modeldef.py

@@ -3,9 +3,10 @@ import copy
 import numpy as np
 
 from nnodely.support.utils import check, check_and_get_list
-from nnodely.support.jsonutils import merge, subjson_from_model,subjson_from_relation, check_model, get_models_json
+from nnodely.support.jsonutils import merge, subjson_from_model, subjson_from_minimize, check_model, get_models_json
 from nnodely.basic.relation import MAIN_JSON, Stream, check_names
 from nnodely.layers.output import Output
+from nnodely.layers.input import Input
 
 from nnodely.support.logger import logging, nnLogger
 log = nnLogger(__name__, logging.INFO)
@@ -36,17 +37,11 @@ class ModelDef:
         self.__json[key] = value
 
     def __rebuild_json(self, models_names, minimizers):
-        new_json = subjson_from_model(self.__json, list(models_names))
-
-        if 'Minimizers' in self.__json:
-            rel_A = [self.__json['Minimizers'][key]['A'] for key in minimizers]
-            rel_B = [self.__json['Minimizers'][key]['B'] for key in minimizers]
-            relations_name = set(rel_A) | set(rel_B)
-            if len(relations_name) != 0:
-                minimizers_json = subjson_from_relation(self.__json, list(relations_name))
-                new_json = merge(new_json, minimizers_json)
-
-        return copy.deepcopy(new_json)
+        models_json = subjson_from_model(self.__json, list(models_names))
+        if 'Minimizers' in self.__json and len(minimizers) > 0:
+            minimizers_json = subjson_from_minimize(self.__json, list(minimizers))
+            models_json = merge(models_json, minimizers_json)
+        return copy.deepcopy(models_json)
 
     def recurrentInputs(self):
         return {key:value for key, value in self.__json['Inputs'].items() if ('closedLoop' in value.keys() or 'connect' in value.keys())}
@@ -66,24 +61,30 @@ class ModelDef:
     def isDefined(self):
         return self.__json is not None
 
-    def addConnect(self, stream_name:str, input_name:str, local:bool = False):
-        input_name = check_and_get_list(input_name, set(self.__json['Inputs'].keys()),
-                                       lambda name: f"The name {name} is not part of the available inputs")[0]
-        stream_name = check_and_get_list(stream_name, set(self.__json['Relations'].keys()),
-                                        lambda name: f"The name {name} is not part of the available relations")[0]
-        self.__json['Inputs'][input_name]['connect'] = stream_name
-        self.__json['Inputs'][input_name]['local'] = int(local)
+    def addConnection(self, stream_out:str|Output|Stream, input_in:str|Input, type:str, local:bool = False):
+        outputs = self.__json['Outputs']
+
+        if isinstance(stream_out, (Output, Stream)):
+            stream_name = outputs[stream_out.name] if stream_out.name in outputs.keys() else stream_out.name
+        else:
+            output_name = check_and_get_list(stream_out, set(outputs.keys()),
+                                             lambda name: f"The name {name} is not part of the available Outputs")[0]
+            stream_name = outputs[output_name]
+
+        if isinstance(input_in, Input):
+            input_name = input_in.name
+        else:
+            input_name = input_in #TODO Add tests
 
-    def addClosedLoop(self, stream_name:str, input_name:str, local:bool = False):
         input_name = check_and_get_list(input_name, set(self.__json['Inputs'].keys()),
-                                       lambda name: f"The name {name} is not part of the available inputs")[0]
+                                       lambda name: f"The name {name} is not part of the available Inputs")[0]
         stream_name = check_and_get_list(stream_name, set(self.__json['Relations'].keys()),
-                                        lambda name: f"The name {name} is not part of the available relations")[0]
-        self.__json['Inputs'][input_name]['closedLoop'] = stream_name
+                                        lambda name: f"The name {name} is not part of the available Relations")[0]
+        self.__json['Inputs'][input_name][type] = stream_name
         self.__json['Inputs'][input_name]['local'] = int(local)
 
     def removeConnection(self, name_list:str|list[str]):
-        name_list = check_and_get_list(name_list, set(self.__json['Inputs'].keys()), lambda name: f"The name {name} is not part of the available inputs")
+        name_list = check_and_get_list(name_list, set(self.__json['Inputs'].keys()), lambda name: f"The name {name} is not part of the available Inputs")
         for input_in in name_list:
             if 'closedLoop' in self.__json['Inputs'][input_in].keys():
                 del self.__json['Inputs'][input_in]['closedLoop']
@@ -124,17 +125,25 @@ class ModelDef:
         self.__json = self.__rebuild_json(models_names, minimizers)
 
     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.')
         if 'Minimizers' not in self.__json:
             self.__json['Minimizers'] = {}
-
         check_names(name, set(self.__json['Minimizers'].keys()), 'Minimizers')
-        streams = merge(streamA.json, streamB.json)
-        streamA_name = streamA.json['Outputs'][streamA.name] if isinstance(streamA, Output) else streamA.name
-        streamB_name = streamB.json['Outputs'][streamB.name] if isinstance(streamB, Output) else streamB.name
-        self.__json = merge(self.__json, streams)
+
+        if isinstance(streamA, str):
+            streamA_name = streamA
+        else:
+            check(isinstance(streamA, (Output, Stream)), TypeError, 'streamA must be an instance of Output or Stream')
+            streamA_name = streamA.json['Outputs'][streamA.name] if isinstance(streamA, Output) else streamA.name
+            self.__json = merge(self.__json, streamA.json)
+
+        if isinstance(streamB, str):
+            streamB_name = streamB
+        else:
+            check(isinstance(streamB, (Output, Stream)), TypeError, 'streamA must be an instance of Output or Stream')
+            streamB_name = streamB.json['Outputs'][streamB.name] if isinstance(streamB, Output) else streamB.name
+            self.__json = merge(self.__json, streamB.json)
+        #check(streamA.dim == streamB.dim, ValueError, f'Dimension of streamA={streamA.dim} and streamB={streamB.dim} are not equal.')
+
         self.__json['Minimizers'][name] = {}
         self.__json['Minimizers'][name]['A'] = streamA_name
         self.__json['Minimizers'][name]['B'] = streamB_name
@@ -158,6 +167,8 @@ class ModelDef:
                 self.__sample_time = 1
 
         self.__json['Info'] = {"SampleTime": self.__sample_time}
+        if 'SampleTime' in self.__json['Constants']:
+            self.__json['Constants']['SampleTime'] = {'dim': 1, 'values': self.__sample_time}
 
         check(self.__json['Inputs'] != {}, RuntimeError, "No model is defined!")
         json_inputs = self.__json['Inputs']

{nnodely-1.5.0 → nnodely-1.5.2}/nnodely/basic/relation.py

@@ -261,11 +261,11 @@ class Stream(Relation):
         Stream
             A Stream of the signal represents the integral or derivation operation.
         """
-        from nnodely.layers.timeoperation import Derivate, Integrate
+        from nnodely.layers.timeoperation import Differentiate, Integrate
         check(order != 0, ValueError, "The order must be a positive or negative integer not a zero")
         if order > 0:
             for i in range(order):
-                o = Derivate(self, der_name = der_name, int_name = int_name, method = method)
+                o = Differentiate(self, der_name = der_name, int_name = int_name, method = method)
         elif order < 0:
             for i in range(-order):
                 o = Integrate(self, der_name = der_name, int_name = int_name, method = method)

{nnodely-1.5.0 → nnodely-1.5.2}/nnodely/exporter/export.py

@@ -1,4 +1,4 @@
-import sys, os, torch, importlib
+import sys, os, torch, importlib, json
 
 from torch.fx import symbolic_trace
 
@@ -54,11 +54,19 @@ def export_python_model(model_def, model, model_path):
         file.write("import torch\n\n")
 
         ## write the connect wrap function
-        file.write(f"def {package_name}_basic_model_connect(data_in, rel):\n")
-        file.write("    virtual = torch.cat((data_in[:, 1:, :], data_in[:, :1, :]), dim=1)\n")
+        # file.write(f"def {package_name}_basic_model_update_state(data_in, rel):\n")
+        # file.write("    virtual = torch.cat((data_in[:, 1:, :], data_in[:, :1, :]), dim=1)\n")
+        # file.write("    max_dim = min(rel.size(1), data_in.size(1))\n")
+        # file.write("    virtual[:, -max_dim:, :] = rel[:, -max_dim:, :]\n")
+        # file.write("    return virtual\n\n")
+        file.write(f"def {package_name}_basic_model_update_state(data_in, rel):\n")
+        file.write("    data_out = data_in.clone()\n")
         file.write("    max_dim = min(rel.size(1), data_in.size(1))\n")
-        file.write("    virtual[:, -max_dim:, :] = rel[:, -max_dim:, :]\n")
-        file.write("    return virtual\n\n")
+        file.write("    data_out[:, -max_dim:, :] = rel[:, -max_dim:, :]\n")
+        file.write("    return data_out\n\n")
+
+        file.write(f"def {package_name}_basic_model_timeshift(data_in):\n")
+        file.write("    return torch.cat((data_in[:, 1:, :], data_in[:, :1, :]), dim=1)\n\n")
 
         for name in model_def['Functions'].keys():
             if 'Fuzzify' in name:
@@ -126,8 +134,8 @@ def export_python_model(model_def, model, model_path):
                     # file.write(f"        self.all_parameters[\"{param}\"] = torch.nn.Parameter(torch.{value}, requires_grad=True)\n")
                 elif 'Part' in key or 'Select' in key: # any(element in key for element in ['Part', 'Select']):
                     value = model.relation_forward[key].W
-                    temp_value = str(value).replace(')',', requires_grad=False)')
-                    file.write(f"        self.all_constants[\"{key}\"] = torch.{temp_value}\n")
+                    temp_value = json.dumps(value.tolist())
+                    file.write(f"        self.all_constants[\"{key}\"] = torch.tensor({temp_value}, requires_grad=True)\n")
             elif 'all_parameters' in attr:
                 key = attr.split('.')[-1]
                 file.write(f"        self.all_parameters[\"{key}\"] = torch.nn.Parameter(torch.tensor({model.all_parameters[key].tolist()}), requires_grad=True)\n")
@@ -194,7 +202,10 @@ def export_python_model(model_def, model, model_path):
             file.write("            for key, value in results.items():\n")
             file.write("                results[key].append(out[key])\n")
             file.write("            for key, val in closed_loop.items():\n")
-            file.write("                self.states[key] = nnodely_basic_model_connect(self.states[key], val)\n")
+            file.write("                self.states[key] = nnodely_basic_model_timeshift(self.states[key])\n")
+            file.write("                self.states[key] = nnodely_basic_model_update_state(self.states[key], val)\n")
+            file.write("            for key, val in connect.items():\n")
+            file.write("                self.states[key] = nnodely_basic_model_timeshift(val)\n")
             file.write("        return results\n")
 
 def export_pythononnx_model(model_def, model_path, model_onnx_path, input_order=None, outputs_order=None):
@@ -289,9 +300,11 @@ def export_pythononnx_model(model_def, model_path, model_onnx_path, input_order=
             for idx, key in enumerate(model_outputs):
                 file.write(f"            results_{key}.append(out[{idx}])\n")
             for idx, key in enumerate(closed_loop_states):
-                file.write(f"            {key} = nnodely_basic_model_connect({key}, closed_loop[{idx}])\n")
+                file.write(f"            {key} = nnodely_basic_model_timeshift({key})\n")
+                file.write(f"            {key} = nnodely_basic_model_update_state({key}, closed_loop[{idx}])\n")
             for idx, key in enumerate(connect_states):
-                file.write(f"            {key} = connect[{idx}]\n")
+                file.write(f"            {key} = nnodely_basic_model_timeshift(connect[{idx}])\n")
+                #file.write(f"            {key} = connect[{idx}]\n")
             for idx, key in enumerate(model_outputs):
                 file.write(f"        results_{key} = torch.stack(results_{key}, dim=0)\n")
             return_str = "        return "

{nnodely-1.5.0 → nnodely-1.5.2}/nnodely/exporter/reporter.py

@@ -38,8 +38,11 @@ class Reporter:
                     for ind, name_data in enumerate(self.modely.prediction.keys()):
                         fig = plt.figure(figsize=(10, 5))
                         ax = fig.add_subplot(111)
+                        idxs = None
+                        if 'idxs' in self.modely.prediction[name_data]:
+                            idxs = self.modely.prediction[name_data]['idxs']
                         plots.plot_results(ax, name_data, key, self.modely.prediction[name_data][key]['A'],
-                                       self.modely.prediction[name_data][key]['B'], self.modely._model_def['Info']["SampleTime"])
+                                       self.modely.prediction[name_data][key]['B'], idxs, self.modely._model_def['Info']["SampleTime"])
                         # Add a text box with correlation coefficient
                         results = io.BytesIO()
                         plt.savefig(results, format='png')

{nnodely-1.5.0 → nnodely-1.5.2}/nnodely/layers/arithmetic.py

@@ -178,6 +178,7 @@ class Sum(Stream, ToStream):
         obj = toStream(obj)
         check(type(obj) is Stream, TypeError,
               f"The type of {obj} is {type(obj)} and is not supported for sum operation.")
+        obj.dim['dim'] = 1
         super().__init__(sum_relation_name + str(Stream.count),obj.json,obj.dim)
         self.json['Relations'][self.name] = [sum_relation_name,[obj.name]]
 
@@ -313,7 +314,7 @@ class Sum_Layer(nn.Module):
         super(Sum_Layer, self).__init__()
 
     def forward(self, inputs):
-        return torch.sum(inputs, dim = 2)
+        return torch.sum(inputs, dim = 2, keepdim = True)
 
 def createSum(name, *inputs):
     """

{nnodely-1.5.0 → nnodely-1.5.2}/nnodely/layers/fir.py

@@ -29,11 +29,11 @@ class Fir(NeuObj, AutoToStream):
     ----------
     output_dimension : int, optional
         The output dimension of the FIR relation.
-    W_init : Callable, optional
+    W_init : Callable, str, optional
         A callable for initializing the parameters.
     W_init_params : dict, optional
         A dictionary of parameters for the parameter initializer.
-    b_init : Callable, optional
+    b_init : Callable, str, optional
         A callable for initializing the bias.
     b_init_params : dict, optional
         A dictionary of parameters for the bias initializer.
@@ -83,14 +83,14 @@ class Fir(NeuObj, AutoToStream):
 
     Example - passing a parameter:
         >>> input = Input('in')
-        >>> par = Parameter('par', dimensions=3, sw=2, init=init_constant)
+        >>> par = Parameter('par', dimensions=3, sw=2, init='init_constant')
         >>> relation = Fir(W=par)(input.sw(2))
 
     Example - parameters initialization:
         >>> x = Input('x')
         >>> F = Input('F')
-        >>> fir_x = Fir(W_init=init_negexp)(x.tw(0.2)) 
-        >>> fir_F = Fir(W_init=init_constant, W_init_params={'value':1})(F.last())
+        >>> fir_x = Fir(W_init='init_negexp')(x.tw(0.2))
+        >>> fir_F = Fir(W_init='init_constant', W_init_params={'value':1})(F.last())
 
     """
     @enforce_types
@@ -112,7 +112,8 @@ class Fir(NeuObj, AutoToStream):
         super().__init__('P'+fir_relation_name + str(NeuObj.count))
 
         if type(self.W) is Parameter:
-            check(len(self.W.dim) == 2,ValueError,f"The values of the parameters must have two dimensions (tw/sample_rate or sw,output_dimension).")
+            check('tw' in self.W.dim or 'sw' in self.W.dim, TypeError, f'The "W" Parameter must have a time dimension or a sample dimension but got {self.W.dim}.')
+            #check(len(self.W.dim) == 2,ValueError,f"The values of the parameters must have two dimensions [tw/sample_rate,output_dimension] or [sw,output_dimension].")
             if output_dimension is None:
                 check(type(self.W.dim['dim']) is int, TypeError, 'Dimension of the parameter must be an integer for the Fir')
                 self.output_dimension = self.W.dim['dim']

{nnodely-1.5.0 → nnodely-1.5.2}/nnodely/layers/fuzzify.py

@@ -10,9 +10,6 @@ from nnodely.basic.model import Model
 from nnodely.support.utils import check, enforce_types
 from nnodely.support.jsonutils import merge
 
-from nnodely.support.logger import logging, nnLogger
-log = nnLogger(__name__, logging.CRITICAL)
-
 fuzzify_relation_name = 'Fuzzify'
 
 class Fuzzify(NeuObj):

{nnodely-1.5.0 → nnodely-1.5.2}/nnodely/layers/input.py

@@ -4,7 +4,7 @@ from nnodely.basic.relation import NeuObj, Stream, ToStream
 from nnodely.support.utils import check, enforce_types
 from nnodely.support.jsonutils import merge, stream_to_str
 from nnodely.layers.part import SamplePart, TimePart
-from nnodely.layers.timeoperation import Derivate, Integrate
+from nnodely.layers.timeoperation import Differentiate, Integrate
 
 class Input(NeuObj):
     """
@@ -119,16 +119,16 @@ class Input(NeuObj):
         Examples
         --------
         Select a sample window considering a signal T = [-3,-2,-1,0,1,2] where the time vector 0 represent the last passed instant. If sw is an integer #1 represent the number of step in the past
-            >>> T.s(2) #= [-1, 0] represents two sample step in the past
+            >>> T.sw(2) #= [-1, 0] represents two sample step in the past
 
         If sw is a list [#1,#2] the numbers represent the sample indexes in the vector with the second element excluded
-            >>> T.s([-2,0])  #= [-1, 0] represents two time step in the past zero in the future
-            >>> T.s([0,1])   #= [1]     the first time in the future
-            >>> T.s([-4,-2]) #= [-3,-2]
+            >>> T.sw([-2,0])  #= [-1, 0] represents two time step in the past zero in the future
+            >>> T.sw([0,1])   #= [1]     the first time in the future
+            >>> T.sw([-4,-2]) #= [-3,-2]
 
         The total number of samples can be computed #2-#1. The offset represent the index of the vector that need to be used to offset the window
-            >>> T.s(2,offset=-2)       #= [0, 1]      the value of the window is [-1,0]
-            >>> T.s([-2,2],offset=-1)  #= [-1,0,1,2]  the value of the window is [-1,0,1,2]
+            >>> T.sw(2,offset=-2)       #= [0, 1]      the value of the window is [-1,0]
+            >>> T.sw([-2,2],offset=-1)  #= [-1,0,1,2]  the value of the window is [-1,0,1,2]
         """
         dim = copy.deepcopy(self.dim)
         json = copy.deepcopy(self.json)
@@ -224,7 +224,7 @@ class Input(NeuObj):
         if order > 0:
             o = self.last()
             for i in range(order):
-                o = Derivate(o, der_name = der_name, int_name = int_name, method = method)
+                o = Differentiate(o, der_name = der_name, int_name = int_name, method = method)
         elif order < 0:
             o = self.last()
             for i in range(-order):

{nnodely-1.5.0 → nnodely-1.5.2}/nnodely/layers/interpolation.py

@@ -7,9 +7,6 @@ from nnodely.basic.model import Model
 from nnodely.support.utils import check, enforce_types
 from nnodely.support.jsonutils import merge
 
-from nnodely.support.logger import logging, nnLogger
-log = nnLogger(__name__, logging.CRITICAL)
-
 interpolation_relation_name = 'Interpolation'
 class Interpolation(NeuObj):
     """