nnodely 0.25.0__tar.gz → 1.2.3__tar.gz

{nnodely-0.25.0/nnodely.egg-info → nnodely-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: nnodely
-Version: 0.25.0
+Version: 1.2.3
 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
@@ -40,6 +40,7 @@ Requires-Dist: onnx
 Requires-Dist: pandas
 Requires-Dist: reportlab
 Requires-Dist: matplotlib
+Requires-Dist: onnxruntime
 
 <p align="center">
 <img src="https://raw.githubusercontent.com/tonegas/nnodely/main/imgs/logo_white_info.png" alt="logo" >

{nnodely-0.25.0 → nnodely-1.2.3}/mplplots/plots.py

@@ -37,12 +37,25 @@ def plot_results(ax, name_data, key, A, B, sample_time):
     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]):
-            ax.plot(np.arange(0, len(A_t[ind_win, ind_dim]) * sample_time, sample_time), A_t[ind_win, ind_dim],
-                    label=f'real')
-            ax.plot(np.arange(0, len(B_t[ind_win, ind_dim]) * sample_time, sample_time), 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')
+            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')
+            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')
 
     ax.grid(True)
     ax.legend(loc='best')

{nnodely-0.25.0 → nnodely-1.2.3}/nnodely/__init__.py

@@ -1,5 +1,5 @@
 
-__version__ = '0.25.0'
+__version__ = '1.2.3'
 
 import sys
 major, minor = sys.version_info.major, sys.version_info.minor
@@ -18,19 +18,22 @@ else:
 
 # Network input, outputs and parameters
 from nnodely.input import Input, State, Connect, ClosedLoop
-from nnodely.parameter import Parameter, Constant
+from nnodely.parameter import Parameter, Constant, SampleTime
 from nnodely.output import Output
 
 # Network elements
-from nnodely.activation import Relu, Tanh, ELU
+from nnodely.activation import Relu, ELU, Softmax, Sigmoid, Identity
 from nnodely.fir import Fir
 from nnodely.linear import Linear
 from nnodely.arithmetic import Add, Sum, Sub, Mul, Pow, Neg
-from nnodely.trigonometric import Sin, Cos, Tan
+from nnodely.trigonometric import Sin, Cos, Tan, Cosh, Tanh, Sech
 from nnodely.parametricfunction import ParamFun
 from nnodely.fuzzify import Fuzzify
-from nnodely.part import TimePart, TimeSelect, SamplePart, SampleSelect, Part, Select
+from nnodely.part import  Part, Select, Concatenate, SamplePart, SampleSelect, TimePart, TimeConcatenate
 from nnodely.localmodel import LocalModel
+from nnodely.equationlearner import EquationLearner
+from nnodely.timeoperation import Integrate, Derivate
+from nnodely.interpolation import Interpolation
 
 # Main nnodely classes
 from nnodely.nnodely import nnodely, Modely
@@ -39,4 +42,4 @@ from nnodely.optimizer import Optimizer, SGD, Adam
 from nnodely.exporter import Exporter, StandardExporter
 
 # Support functions
-from nnodely.initializer import init_negexp, init_lin, init_constant
+from nnodely.initializer import init_negexp, init_lin, init_constant, init_exp

nnodely-1.2.3/nnodely/activation.py

@@ -0,0 +1,197 @@
+import torch
+import torch.nn as nn
+
+from nnodely import Parameter, Constant
+from nnodely.relation import Stream, ToStream, toStream
+from nnodely.model import Model
+from nnodely.utils import check, enforce_types
+
+
+relu_relation_name = 'Relu'
+elu_relation_name = 'ELU'
+sigmoid_relation_name = 'Sigmoid'
+
+identity_relation_name = 'Identity'
+
+softmax_relation_name = 'Softmax'
+
+
+class Relu(Stream, ToStream):
+    """
+        Implement the Rectified-Linear Unit (ReLU) relation function.
+
+        See also:
+            Official PyTorch ReLU documentation: 
+            `torch.nn.ReLU <https://pytorch.org/docs/stable/generated/torch.nn.ReLU.html>`_
+
+        :param obj: The relation stream.
+        :type obj: Stream 
+
+        Example:
+            >>> x = Relu(x)
+    """
+    @enforce_types
+    def __init__(self, obj:Stream|Parameter|Constant|float|int) -> Stream:
+        obj = toStream(obj)
+        check(type(obj) is Stream, TypeError,
+              f"The type of {obj} is {type(obj)} and is not supported for Relu operation.")
+        super().__init__(relu_relation_name + str(Stream.count),obj.json,obj.dim)
+        self.json['Relations'][self.name] = [relu_relation_name,[obj.name]]
+
+class ELU(Stream, ToStream):
+    """
+        Implement the Exponential-Linear Unit (ELU) relation function.
+
+        See also:
+            Official PyTorch ReLU documentation: 
+            `torch.nn.ELU <https://pytorch.org/docs/stable/generated/torch.nn.ELU.html>`_
+
+        :param obj: The relation stream.
+        :type obj: Stream 
+
+        Example:
+            >>> x = ELU(x)
+    """
+    @enforce_types
+    def __init__(self, obj:Stream|Parameter|Constant|float|int) -> Stream:
+        obj = toStream(obj)
+        check(type(obj) is Stream,TypeError,
+              f"The type of {obj} is {type(obj)} and is not supported for Tanh operation.")
+        super().__init__(elu_relation_name + str(Stream.count),obj.json,obj.dim)
+        self.json['Relations'][self.name] = [elu_relation_name,[obj.name]]
+
+class Identity(Stream, ToStream):
+    """
+    Implement the Identity relation function that simply returns the input vector x.
+
+    See also:
+        Official PyTorch Identity documentation: 
+        `torch.nn.Identity <https://pytorch.org/docs/stable/generated/torch.nn.Identity.html>`_
+
+    :param obj: The relation stream.
+    :type obj: Stream 
+
+    Example:
+        >>> x = Identity(x)
+    """
+    @enforce_types
+    def __init__(self, obj: Stream|Parameter|Constant|float|int) -> Stream:
+        obj = toStream(obj)
+        check(type(obj) is Stream, TypeError,
+              f"The type of {obj} is {type(obj)} and is not supported for Identity operation.")
+        super().__init__(identity_relation_name + str(Stream.count), obj.json, obj.dim)
+        self.json['Relations'][self.name] = [identity_relation_name, [obj.name]]
+
+
+class Softmax(Stream, ToStream):
+    """
+        Implement the Softmax relation function.
+
+        See also:
+            Official PyTorch Softmax documentation: 
+            `torch.nn.Softmax <https://pytorch.org/docs/stable/generated/torch.nn.Softmax.html>`_
+
+        :param obj: The relation stream.
+        :type obj: Stream 
+
+        Example:
+            >>> x = Softmax(x)
+    """
+    @enforce_types
+    def __init__(self, obj:Stream|Parameter|Constant|float|int) -> Stream:
+        obj = toStream(obj)
+        check(type(obj) is Stream, TypeError,
+              f"The type of {obj} is {type(obj)} and is not supported for Softmax operation.")
+        super().__init__(softmax_relation_name + str(Stream.count), obj.json, obj.dim)
+        self.json['Relations'][self.name] = [softmax_relation_name, [obj.name]]
+
+class Sigmoid(Stream, ToStream):
+    """
+        Implement the Sigmoid relation function.
+        The Sigmoid function is defined as:
+        
+        .. math::
+            \sigma(x) = \frac{1}{1 + e^{-x}}
+
+        :param obj: The relation stream.
+        :type obj: Stream 
+
+        Example:
+            >>> x = Sigmoid(x)
+    """
+    @enforce_types
+    def __init__(self, obj:Stream|Parameter|Constant|float|int) -> Stream:
+        obj = toStream(obj)
+        check(type(obj) is Stream, TypeError,
+              f"The type of {obj} is {type(obj)} and is not supported for {sigmoid_relation_name} operation.")
+        super().__init__(sigmoid_relation_name + str(Stream.count), obj.json, obj.dim)
+        self.json['Relations'][self.name] = [sigmoid_relation_name, [obj.name]]
+
+class Relu_Layer(nn.Module):
+    """
+     :noindex:
+    """
+    def __init__(self,):
+        super(Relu_Layer, self).__init__()
+    def forward(self, x):
+        return torch.relu(x)
+    
+def createRelu(self, *input):
+    """
+     :noindex:
+    """
+    return Relu_Layer()
+    
+
+def createELU(self, *input):
+    """
+     :noindex:
+    """
+    return nn.ELU()
+
+class Identity_Layer(nn.Module):
+    """
+     :noindex:
+    """
+    def __init__(self, *args):
+        super(Identity_Layer, self).__init__()
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x
+    
+def createIdentity(self, *input):
+    """
+     :noindex:
+    """
+    return Identity_Layer()
+
+
+class Sigmoid_Layer(nn.Module):
+    """
+     :noindex:
+    """
+    def __init__(self,):
+        super(Sigmoid_Layer, self).__init__()
+    def forward(self, x):
+        return 1/(1+torch.exp(-x))
+    
+def createSigmoid(self, *input):
+    """
+     :noindex:
+    """
+    return Sigmoid_Layer()
+
+def createSoftmax(self, *input):
+    """
+     :noindex:
+    """
+    return nn.Softmax(dim=-1)
+
+
+setattr(Model, relu_relation_name, createRelu)
+setattr(Model, elu_relation_name, createELU)
+setattr(Model, sigmoid_relation_name, createSigmoid)
+
+setattr(Model, identity_relation_name, createIdentity)
+
+setattr(Model, softmax_relation_name, createSoftmax)

{nnodely-0.25.0 → nnodely-1.2.3}/nnodely/arithmetic.py

@@ -3,8 +3,8 @@ import torch
 
 from nnodely.relation import ToStream, Stream, toStream
 from nnodely.model import Model
-from nnodely.utils import check, merge
-
+from nnodely.utils import check, merge, enforce_types
+from nnodely.parameter import Parameter, Constant
 
 # Binary operators
 add_relation_name = 'Add'
@@ -15,10 +15,11 @@ pow_relation_name = 'Pow'
 
 # Unary operators
 neg_relation_name = 'Neg'
-# square_relation_name = 'Square'
 
 # Merge operator
 sum_relation_name = 'Sum'
+
+
 class Add(Stream, ToStream):
     """
         Implement the addition function between two tensors. 
@@ -38,7 +39,8 @@ class Add(Stream, ToStream):
             or
             >>> add = relation1 + relation2
     """
-    def __init__(self, obj1:Stream, obj2:Stream) -> Stream:
+    @enforce_types
+    def __init__(self, obj1:Stream|Parameter|Constant, obj2:Stream|Parameter|Constant|int|float) -> Stream:
         obj1,obj2 = toStream(obj1),toStream(obj2)
         check(type(obj1) is Stream,TypeError,
               f"The type of {obj1} is {type(obj1)} and is not supported for add operation.")
@@ -65,7 +67,8 @@ class Sub(Stream, ToStream):
             or
             >>> sub = relation1 - relation2
     """
-    def __init__(self, obj1:Stream, obj2:Stream) -> Stream:
+    @enforce_types
+    def __init__(self, obj1:Stream|Parameter|Constant, obj2:Stream|Parameter|Constant|int|float) -> Stream:
         obj1, obj2 = toStream(obj1), toStream(obj2)
         check(type(obj1) is Stream,TypeError,
               f"The type of {obj1} is {type(obj1)} and is not supported for sub operation.")
@@ -91,7 +94,8 @@ class Mul(Stream, ToStream):
             or
             >>> mul = relation1 * relation2
     """
-    def __init__(self, obj1:Stream, obj2:Stream) -> Stream:
+    @enforce_types
+    def __init__(self, obj1:Stream|Parameter|Constant, obj2:Stream|Parameter|Constant|int|float) -> Stream:
         obj1, obj2 = toStream(obj1), toStream(obj2)
         check(type(obj1) is Stream, TypeError,
               f"The type of {obj1} is {type(obj1)} and is not supported for mul operation.")
@@ -117,7 +121,8 @@ class Div(Stream, ToStream):
             or
             >>> div = relation1 / relation2
     """
-    def __init__(self, obj1:Stream, obj2:Stream) -> Stream:
+    @enforce_types
+    def __init__(self, obj1:Stream|Parameter|Constant, obj2:Stream|Parameter|Constant|int|float) -> Stream:
         obj1, obj2 = toStream(obj1), toStream(obj2)
         check(type(obj1) is Stream, TypeError,
               f"The type of {obj1} is {type(obj1)} and is not supported for div operation.")
@@ -147,7 +152,8 @@ class Pow(Stream, ToStream):
             or
             >>> pow = relation1 ** relation2
     """
-    def __init__(self, obj1:Stream, obj2:Stream) -> Stream:
+    @enforce_types
+    def __init__(self, obj1:Stream|Parameter|Constant, obj2:Stream|Parameter|Constant|int|float) -> Stream:
         obj1, obj2 = toStream(obj1), toStream(obj2)
         check(type(obj1) is Stream, TypeError,
               f"The type of {obj1} is {type(obj1)} and is not supported for exp operation.")
@@ -168,22 +174,17 @@ class Neg(Stream, ToStream):
         Example:
             >>> x = Neg(x)
     """
-    def __init__(self, obj:Stream) -> Stream:
+    @enforce_types
+    def __init__(self, obj:Stream|Parameter|Constant) -> Stream:
         obj = toStream(obj)
         check(type(obj) is Stream, TypeError,
               f"The type of {obj} is {type(obj)} and is not supported for neg operation.")
         super().__init__(neg_relation_name+str(Stream.count), obj.json, obj.dim)
         self.json['Relations'][self.name] = [neg_relation_name,[obj.name]]
 
-# class Square(Stream, ToStream):
-#     def __init__(self, obj:Stream) -> Stream:
-#         check(type(obj) is Stream, TypeError,
-#               f"The type of {obj.name} is {type(obj)} and is not supported for neg operation.")
-#         super().__init__(square_relation_name+str(Stream.count), obj.json, obj.dim)
-#         self.json['Relations'][self.name] = [square_relation_name,[obj.name]]
-
 class Sum(Stream, ToStream):
-    def __init__(self, obj:Stream) -> Stream:
+    @enforce_types
+    def __init__(self, obj:Stream|Parameter|Constant) -> Stream:
         obj = toStream(obj)
         check(type(obj) is Stream, TypeError,
               f"The type of {obj} is {type(obj)} and is not supported for sum operation.")
@@ -196,7 +197,12 @@ class Add_Layer(nn.Module):
         super(Add_Layer, self).__init__()
 
     def forward(self, *inputs):
-        return torch.add(inputs[0], inputs[1])
+        results = inputs[0]
+        for input in inputs[1:]:
+            results = results + input
+        return results
+        #return torch.add(inputs[0],inputs[1]))
+        #return torch.sum(torch.stack(list(inputs)),dim=0)
 
 def createAdd(name, *inputs):
     #: :noindex:
@@ -209,7 +215,12 @@ class Sub_Layer(nn.Module):
 
     def forward(self, *inputs):
         # Perform element-wise subtraction
-        return torch.add(inputs[0],-inputs[1])
+        results = inputs[0]
+        for input in inputs[1:]:
+            results = results - input
+        return results
+        #return torch.add(inputs[0], -inputs[1])
+        #return torch.add(inputs[0],-torch.sum(torch.stack(list(inputs[1:])),dim=0))
 
 def createSub(self, *inputs):
     #: :noindex:
@@ -222,7 +233,13 @@ class Mul_Layer(nn.Module):
         super(Mul_Layer, self).__init__()
 
     def forward(self, *inputs):
-        return inputs[0] * inputs[1]
+        results = inputs[0]
+        for input in inputs[1:]:
+            results = results * input
+        return results
+        #return inputs[0] * inputs[1]
+        #return torch.prod(torch.stack(list(inputs)),dim=0)
+
 
 def createMul(name, *inputs):
     #: :noindex:
@@ -234,7 +251,12 @@ class Div_Layer(nn.Module):
         super(Div_Layer, self).__init__()
 
     def forward(self, *inputs):
-        return inputs[0] / inputs[1]
+        results = inputs[0]
+        for input in inputs[1:]:
+            results = results / input
+        return results
+        #return inputs[0] / inputs[1]
+        #return inputs[0] / torch.prod(torch.stack(list(inputs[1:])),dim=0)
 
 def createDiv(name, *inputs):
     #: :noindex:
@@ -276,6 +298,7 @@ def createSum(name, *inputs):
     #: :noindex:
     return Sum_Layer()
 
+
 setattr(Model, add_relation_name, createAdd)
 setattr(Model, sub_relation_name, createSub)
 setattr(Model, mul_relation_name, createMul)
@@ -283,7 +306,6 @@ setattr(Model, div_relation_name, createDiv)
 setattr(Model, pow_relation_name, createPow)
 
 setattr(Model, neg_relation_name, createNeg)
-# setattr(Model, square_relation_name, createSquare)
 
 setattr(Model, sum_relation_name, createSum)
 

nnodely-1.2.3/nnodely/equationlearner.py

@@ -0,0 +1,126 @@
+import inspect
+
+from nnodely.relation import NeuObj, Stream
+from nnodely.utils import check, enforce_types
+
+from nnodely.linear import Linear
+from nnodely.part import Select, Concatenate
+from nnodely.fuzzify import Fuzzify
+from nnodely.parametricfunction import ParamFun
+from nnodely.activation import Relu, ELU, Identity, Sigmoid
+from nnodely.trigonometric import Sin, Cos, Tan, Tanh, Cosh, Sech
+from nnodely.arithmetic import Add, Mul, Sub, Neg, Pow, Sum
+
+equationlearner_relation_name = 'EquationLearner'
+Available_functions = [Sin, Cos, Tan, Cosh, Tanh, Sech, Add, Mul, Sub, Neg, Pow, Sum, Concatenate, Relu, ELU, Identity, Sigmoid]
+Initialized_functions = [ParamFun, Fuzzify]
+
+class EquationLearner(NeuObj):
+    """
+    Represents a nnodely implementation of the Task-Parametrized Equation Learner block.
+
+    See also:
+        Task-Parametrized Equation Learner official paper: 
+        `Equation Learner <https://www.sciencedirect.com/science/article/pii/S0921889022001981>`_
+
+    Parameters
+    ----------
+    functions : list
+        A list of callable functions to be used as activation functions.
+    linear_in : Linear, optional
+        A Linear layer to process the input before applying the activation functions. If not provided a random initialized linear layer will be used instead.
+    linear_out : Linear, optional
+        A Linear layer to process the output after applying the activation functions. Can be omitted.
+
+    Attributes
+    ----------
+    relation_name : str
+        The name of the relation.
+    linear_in : Linear or None
+        The Linear layer to process the input.
+    linear_out : Linear or None
+        The Linear layer to process the output.
+    functions : list
+        The list of activation functions.
+    func_parameters : dict
+        A dictionary mapping function indices to the number of parameters they require.
+    n_activations : int
+        The total number of activation functions.
+
+    Examples
+    --------
+
+    Example - basic usage:
+        >>> x = Input('x')
+
+        >>> equation_learner = EquationLearner(functions=[Tan, Sin, Cos])
+        >>> out = Output('out',equation_learner(x.last()))
+
+    Example - passing a linear layer:
+        >>> x = Input('x')
+
+        >>> linear_layer = Linear(output_dimension=3, W_init=init_constant, W_init_params={'value':0})
+        >>> equation_learner = EquationLearner(functions=[Tan, Sin, Cos], linear_in=linear_layer)
+
+        >>> out = Output('out',equation_learner(x.last()))
+
+    Example - passing a custom parametric function and multiple inputs:
+        >>> x = Input('x')
+        >>> F = Input('F')
+
+        >>> def myFun(K1,p1):
+                return K1*p1
+
+        >>> K = Parameter('k', dimensions =  1, sw = 1,values=[[2.0]])
+        >>> parfun = ParamFun(myFun, parameters = [K] )
+
+        >>> equation_learner = EquationLearner([parfun])
+        >>> out = Output('out',equation_learner((x.last(),F.last())))
+    """
+    @enforce_types
+    def __init__(self, functions:list, linear_in:Linear|None = None, linear_out:Linear|None = None) -> Stream:
+        self.relation_name = equationlearner_relation_name
+        self.linear_in = linear_in
+        self.linear_out = linear_out
+
+        # input parameters
+        self.functions = functions
+        super().__init__(equationlearner_relation_name + str(NeuObj.count))
+
+        self.func_parameters = {}
+        for func_idx, func in enumerate(self.functions):
+            check(callable(func), TypeError, 'The activation functions must be callable')
+            if type(func) in Initialized_functions:
+                if type(func) == ParamFun:
+                    funinfo = inspect.getfullargspec(func.param_fun)
+                    num_args = len(funinfo.args) - len(func.parameters) if func.parameters else len(funinfo.args)
+                elif type(func) == Fuzzify:
+                    init_signature = inspect.signature(func.__call__)  
+                    parameters = list(init_signature.parameters.values())
+                    num_args = len([param for param in parameters if param.name != "self"])
+            else:
+                check(func in Available_functions, ValueError, f'The function {func} is not available for the EquationLearner operation')
+                init_signature = inspect.signature(func.__init__)  
+                parameters = list(init_signature.parameters.values())
+                num_args = len([param for param in parameters if param.name != "self"])
+            self.func_parameters[func_idx] = num_args
+
+        self.n_activations = sum(self.func_parameters.values())
+        check(self.n_activations > 0, ValueError, 'At least one activation function must be provided')
+
+    def __call__(self, inputs):
+        if type(inputs) is not tuple:
+            inputs = (inputs,)
+        check(len(set([x.dim['sw'] if 'sw' in x.dim.keys() else x.dim['tw'] for x in inputs])) == 1, ValueError, 'All inputs must have the same time dimension')
+        concatenated_input = inputs[0]
+        for inp in inputs[1:]:
+            concatenated_input = Concatenate(concatenated_input, inp)
+        linear_layer = self.linear_in(concatenated_input) if self.linear_in else Linear(output_dimension=self.n_activations, b=True)(concatenated_input)
+        idx, out = 0, None
+        for func_idx, func in enumerate(self.functions):
+            arguments = [Select(linear_layer,idx+arg_idx) for arg_idx in range(self.func_parameters[func_idx])]
+            idx += self.func_parameters[func_idx]
+            out = func(*arguments) if func_idx == 0 else Concatenate(out, func(*arguments))
+        if self.linear_out:
+            out = self.linear_out(out)
+        return out