nnodely 1.3.1__tar.gz → 1.4.0__tar.gz

{nnodely-1.3.1/nnodely.egg-info → nnodely-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: nnodely
-Version: 1.3.1
+Version: 1.4.0
 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
@@ -32,15 +32,16 @@ Classifier: Operating System :: OS Independent
 Requires-Python: <3.13,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy==1.26.4; platform_machine == "x86_64"
-Requires-Dist: torch==2.2.2; platform_machine == "x86_64"
-Requires-Dist: numpy; platform_machine != "x86_64"
-Requires-Dist: torch; platform_machine != "x86_64"
+Requires-Dist: numpy==1.26.4; platform_machine == "x86_64" and python_version == "3.10"
+Requires-Dist: torch==2.2.2; platform_machine == "x86_64" and python_version == "3.10"
+Requires-Dist: numpy
+Requires-Dist: torch
 Requires-Dist: onnx
 Requires-Dist: pandas
 Requires-Dist: reportlab
 Requires-Dist: matplotlib
 Requires-Dist: onnxruntime
+Dynamic: license-file
 
 <p align="center">
 <img src="https://raw.githubusercontent.com/tonegas/nnodely/main/imgs/logo_white_info.png" alt="logo" >
@@ -308,7 +309,7 @@ This operation is presented in [[1]](#1).
 3. __localmodel.py__ this file contains the logic for build a local model. This operation is presented in [[1]](#1), [[3]](#3), [[4]](#4) and [[5]](#5).
 4. __parametricfunction.py__ are the user custom function. The function can use the pytorch syntax. A parametric function is presented in [[3]](#3), [[4]](#4), [[5]](#5).
 5. __equationlearner.py__ contains the logic for the equation learner. The equation learner is used for learn a relation input outpur following a list of activation functions. The first implementation is presented in [[6]](#6).
-6. __timeoperation.py__ contains the time operation functions. The time operation are used for extract a time window from a signal.
+6. __timeoperation.py__ contains the time operation functions. The time operation are used for extract a time window from a signal. The derivative operation can be used to implement Physics-informed neural network [[7]](#7) Sobolev learning [[8]](#8).
 
 <a name="testsfolder"></a>
 ### Tests Folder
@@ -359,6 +360,17 @@ and [[code extended]](https://github.com/tonegas/nnodely-applications/blob/main/
 <a id="6">[6]</a> 
 Hector Perez-Villeda, Justus Piater, Matteo Saveriano. (2023).
 Learning and extrapolation of robotic skills using task-parameterized equation learner networks.
-Robotics and Autonomous Systems. https://doi.org/10.1016/j.robot.2022.104309
+Robotics and Autonomous Systems. https://doi.org/10.1016/j.robot.2022.104309 (look the [[code]](https://github.com/tonegas/nnodely-applications/blob/main/equation_learner/equation_learner.ipynb))
+
+<a id="7">[7]</a> 
+M. Raissi. P. Perdikaris b, G.E. Karniadakis a. (2019).
+Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations
+Journal of Computational Physics. https://doi.org/10.1016/j.jcp.2018.10.045 (look the [[example Burger's equation]](https://github.com/tonegas/nnodely-applications/blob/main/pinn/pinn_Burgers_equation.ipynb))
+
+<a id="8">[8]</a> 
+Wojciech Marian Czarnecki, Simon Osindero, Max Jaderberg, Grzegorz Świrszcz, Razvan Pascanu. (2017).
+Sobolev Training for Neural Networks.
+arXiv. https://doi.org/10.48550/arXiv.1706.04859 (look the [[code]](https://github.com/tonegas/nnodely-applications/blob/main/sobolev/Sobolev_learning.ipynb))
+
 
 <p align="right">(<a href="#readme-top">back to top</a>)</p>

{nnodely-1.3.1 → nnodely-1.4.0}/README.md

@@ -264,7 +264,7 @@ This operation is presented in [[1]](#1).
 3. __localmodel.py__ this file contains the logic for build a local model. This operation is presented in [[1]](#1), [[3]](#3), [[4]](#4) and [[5]](#5).
 4. __parametricfunction.py__ are the user custom function. The function can use the pytorch syntax. A parametric function is presented in [[3]](#3), [[4]](#4), [[5]](#5).
 5. __equationlearner.py__ contains the logic for the equation learner. The equation learner is used for learn a relation input outpur following a list of activation functions. The first implementation is presented in [[6]](#6).
-6. __timeoperation.py__ contains the time operation functions. The time operation are used for extract a time window from a signal.
+6. __timeoperation.py__ contains the time operation functions. The time operation are used for extract a time window from a signal. The derivative operation can be used to implement Physics-informed neural network [[7]](#7) Sobolev learning [[8]](#8).
 
 <a name="testsfolder"></a>
 ### Tests Folder
@@ -315,6 +315,17 @@ and [[code extended]](https://github.com/tonegas/nnodely-applications/blob/main/
 <a id="6">[6]</a> 
 Hector Perez-Villeda, Justus Piater, Matteo Saveriano. (2023).
 Learning and extrapolation of robotic skills using task-parameterized equation learner networks.
-Robotics and Autonomous Systems. https://doi.org/10.1016/j.robot.2022.104309
+Robotics and Autonomous Systems. https://doi.org/10.1016/j.robot.2022.104309 (look the [[code]](https://github.com/tonegas/nnodely-applications/blob/main/equation_learner/equation_learner.ipynb))
+
+<a id="7">[7]</a> 
+M. Raissi. P. Perdikaris b, G.E. Karniadakis a. (2019).
+Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations
+Journal of Computational Physics. https://doi.org/10.1016/j.jcp.2018.10.045 (look the [[example Burger's equation]](https://github.com/tonegas/nnodely-applications/blob/main/pinn/pinn_Burgers_equation.ipynb))
+
+<a id="8">[8]</a> 
+Wojciech Marian Czarnecki, Simon Osindero, Max Jaderberg, Grzegorz Świrszcz, Razvan Pascanu. (2017).
+Sobolev Training for Neural Networks.
+arXiv. https://doi.org/10.48550/arXiv.1706.04859 (look the [[code]](https://github.com/tonegas/nnodely-applications/blob/main/sobolev/Sobolev_learning.ipynb))
+
 
 <p align="right">(<a href="#readme-top">back to top</a>)</p>

nnodely-1.4.0/nnodely/__init__.py

@@ -0,0 +1,47 @@
+
+__version__ = '1.4.0'
+
+import sys
+major, minor = sys.version_info.major, sys.version_info.minor
+
+import logging
+LOG_LEVEL = logging.INFO
+
+if major < 3:
+    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__+".")
+else:
+    print(f'>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>'+
+          f' {__package__}_v{__version__} '.center(20, '-')+
+          f'<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<')
+
+# Network input, outputs and parameters
+from nnodely.layers.input import Input, State, Connect, ClosedLoop
+from nnodely.layers.parameter import Parameter, Constant, SampleTime
+from nnodely.layers.output import Output
+
+# Network elements
+from nnodely.layers.activation import Relu, ELU, Softmax, Sigmoid, Identity
+from nnodely.layers.fir import Fir
+from nnodely.layers.linear import Linear
+from nnodely.layers.arithmetic import Add, Sum, Sub, Mul, Div, Pow, Neg
+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.localmodel import LocalModel
+from nnodely.layers.equationlearner import EquationLearner
+from nnodely.layers.timeoperation import Integrate, Derivate
+from nnodely.layers.interpolation import Interpolation
+
+# Main nnodely classes
+from nnodely.nnodely import nnodely, Modely, clearNames
+from nnodely.visualizer import Visualizer, TextVisualizer, MPLVisualizer, MPLNotebookVisualizer
+from nnodely.exporter import StandardExporter
+
+# Basic nnodely
+from nnodely.basic.optimizer import Optimizer, SGD, Adam
+
+# Support functions
+from nnodely.support.initializer import init_negexp, init_lin, init_constant, init_exp

{nnodely-1.3.1/nnodely → nnodely-1.4.0/nnodely/basic}/loss.py

@@ -1,8 +1,8 @@
 import torch.nn as nn
 import torch
-from nnodely.utils import check
+from nnodely.support.utils import check
 
-available_losses = ['mse', 'rmse', 'mae']
+available_losses = ['mse', 'rmse', 'mae', 'cross_entropy']
 
 # class CustomRMSE(nn.Module):
 #     def __init__(self):
@@ -15,15 +15,22 @@ available_losses = ['mse', 'rmse', 'mae']
 #         return self.mse(inA, inB)
 
 class CustomLoss(nn.Module):
-    def __init__(self, loss_type='mse'):
+    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}.')
         self.loss_type = loss_type
-        self.loss = nn.MSELoss()
-        if self.loss_type == 'mae':
-            self.loss = nn.L1Loss()
+        self.loss = nn.MSELoss(**kwargs)
+        if callable(loss_type):
+            self.loss = loss_type
+        elif self.loss_type == 'mae':
+            self.loss = nn.L1Loss(**kwargs)
+        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()
+            inA = inA.squeeze()
         res = self.loss(inA,inB)
         if self.loss_type == 'rmse':
             res = torch.sqrt(res)

{nnodely-1.3.1/nnodely → nnodely-1.4.0/nnodely/basic}/model.py

@@ -1,6 +1,6 @@
 from itertools import product
-from nnodely.utils import TORCH_DTYPE
-from nnodely import initializer
+from nnodely.support.utils import TORCH_DTYPE
+from nnodely.support import initializer
 import numpy as np
 
 import torch.nn as nn
@@ -34,14 +34,6 @@ class Model(nn.Module):
         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]
 
-        #print('inputs: ',self.inputs)
-        #print('outputs: ',self.outputs)
-        #print('relations: ',self.relations)
-        #print('params: ',self.params)
-        #print('constants: ',self.constants)
-        #print('sample_time: ',self.sample_time)
-        #print('states: ',self.states)
-
         ## Build the network
         self.all_parameters = {}
         self.all_constants = {}
@@ -149,7 +141,7 @@ class Model(nn.Module):
         self.network_output_predictions = set(self.outputs.values())
 
         ## list of network minimization outputs
-        self.network_output_minimizers = [] 
+        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'])
@@ -178,7 +170,7 @@ class Model(nn.Module):
                             layer_inputs.append(self.all_constants[key])
                         elif key in available_states: ## relation that takes a state
                             layer_inputs.append(kwargs[key])
-                        elif key in available_inputs:  ## relation that takes inputs 
+                        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
                             layer_inputs.append(self.all_parameters[key])
@@ -205,7 +197,7 @@ class Model(nn.Module):
         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, closed_loop_update_dict, connect_update_dict
 
 

{nnodely-1.3.1/nnodely → nnodely-1.4.0/nnodely/basic}/modeldef.py

@@ -2,90 +2,100 @@ 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.support.utils import check, merge
+from nnodely.basic.relation import MAIN_JSON, Stream
+from nnodely.layers.output import Output
 
-from nnodely.logger import logging, nnLogger
+from nnodely.support.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)
+        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"]
+        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 = {}
+            self.__sample_time = None
+        self.__model_dict = {}
+        self.__minimize_dict = {}
+        self.__update_state_dict = {}
 
     def __contains__(self, key):
-        return key in self.json
+        return key in self.__json
 
     def __getitem__(self, key):
-        return self.json[key]
+        return self.__json[key]
 
     def __setitem__(self, key, value):
-        self.json[key] = value
+        self.__json[key] = value
+
+    #TODO to remove when getJson takes a model list as argment
+    def getModelDict(self):
+        return copy.deepcopy(self.__model_dict)
+
+    def getJson(self):
+        return copy.deepcopy(self.__json)
+
+    def getSampleTime(self):
+        check(self.__sample_time is not None, AttributeError, "Sample time is not defined the model is not neuralized!")
+        return self.__sample_time
 
     def isDefined(self):
-        return self.json is not None
+        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
+        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)
+                self.__json = merge(self.__json, stream.json)
         if len(model_dict) > 1:
-            if 'Models' not in self.json:
-                self.json['Models'] = {}
+            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': [],
+                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)
+                    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)
+                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]
+            self.__json['Models'] = list(model_dict.keys())[0]
 
-        if 'Minimizers' not in self.json:
-            self.json['Minimizers'] = {}
+        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']
+            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)
+            self.__json = merge(self.__json, update_state.json)
 
-        if "SampleTime" in self.json['Info']:
-            self.sample_time = self.json['Info']["SampleTime"]
+        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
+        from nnodely.layers.input import  State
         if type(state_list_in) is not list:
             state_list_in = [state_list_in]
         for state_in in state_list_in:
@@ -96,17 +106,17 @@ class ModelDef():
             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_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)
+            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
+        from nnodely.layers.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
+        from nnodely.layers.input import ClosedLoop
         self.__update_state(stream_out, state_list_in, ClosedLoop)
         self.update()
 
@@ -114,8 +124,8 @@ class ModelDef():
         if isinstance(stream_list, (Output,Stream)):
             stream_list = [stream_list]
         if type(stream_list) is list:
-            check(name not in self.model_dict.keys(),ValueError,f"The name '{name}' of the model is already used")
-            self.model_dict[name] = copy.deepcopy(stream_list)
+            check(name not in self.__model_dict.keys(), ValueError, f"The name '{name}' of the model is already used")
+            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()
@@ -125,15 +135,15 @@ class ModelDef():
             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]
+                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}
+        #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):
@@ -141,23 +151,23 @@ class ModelDef():
             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]
+                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!")
+        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
+            self.__sample_time = sample_time
         else:
-            if self.sample_time is None:
-                self.sample_time = 1
+            if self.__sample_time is None:
+                self.__sample_time = 1
 
-        self.json['Info'] = {"SampleTime": self.sample_time}
+        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']
+        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].keys() or connect_name in self.json['States'][key].keys(),
@@ -167,16 +177,16 @@ class ModelDef():
         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:
+            if value['sw'] == [0, 0] and self.__sample_time is not None:
                 ## check if value['tw'] is a multiple of sample_time
                 absolute_tw = abs(value['tw'][0]) + abs(value['tw'][1])
-                check(round(absolute_tw % self.sample_time) == 0, ValueError,
+                check(round(absolute_tw % self.__sample_time) == 0, ValueError,
                       f"Time window of input '{key}' is not a multiple of sample time. This network cannot be neuralized")
-                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])
+                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]
@@ -184,35 +194,28 @@ class ModelDef():
             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:
+        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:
+                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]}")
+                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():
+        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,
+                    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.")
                 if v['values'] == "SampleTime":
-                    v['values'] = self.sample_time
-
+                    v['values'] = self.__sample_time
 
-    def updateParameters(self, model, recurrent=True):
+    def updateParameters(self, model):
         if model is not None:
-            for key in self.json['Parameters'].keys():
-                # if recurrent:
-                #     if key in model.Cell.all_parameters:
-                #         self.json['Parameters'][key]['values'] = model.Cell.all_parameters[key].tolist()
-                #         if 'init_fun' in self.json['Parameters'][key]:
-                #             del self.json['Parameters'][key]['init_fun']
-                # else:
+            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']
+                    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']

{nnodely-1.3.1/nnodely → nnodely-1.4.0/nnodely/basic}/optimizer.py

@@ -1,7 +1,7 @@
 import copy
 import torch
 
-from nnodely.utils import check
+from nnodely.support.utils import check
 
 class Optimizer:
     """