nnodely 0.14.0__py3-none-any.whl

mplplots/plots.py

@@ -0,0 +1,131 @@
+import numpy as np
+
+import matplotlib.colors as mcolors
+
+def plot_training(ax, title, key, data_train, data_val = None, last = None):
+    # Plot data
+    if last is not None:
+        ax.set_title(f'{title} - epochs last {last}')
+    else:
+        ax.set_title(f'{title}')
+
+    ax.plot([i + 1 for i in range(len(data_train))], data_train, label=f'Train loss {key}')
+    if data_val:
+        ax.plot([i + 1 for i in range(len(data_val))], data_val, '-.', label=f'Validation loss {key}')
+
+    ax.set_yscale('log')
+    ax.grid(True)
+    ax.legend(loc='best')
+    ax.set_xlabel('Epochs')
+    ax.set_ylabel('Loss')
+    # Set plot limits
+    data_train = np.nan_to_num(data_train, nan=np.nan, posinf=np.nan, neginf=np.nan)
+    if data_val:
+        data_val = np.nan_to_num(data_val, nan=np.nan, posinf=np.nan, neginf=np.nan)
+        min_val = min([min(data_val), min(data_train)])
+        max_val = max([max(data_val), max(data_train)])
+    else:
+        min_val = min(data_train)
+        max_val = max(data_train)
+    ax.set_ylim(min_val - min_val / 10, max_val + max_val / 10)
+
+
+def plot_results(ax, name_data, key, A, B, sample_time):
+    # Plot data
+    ax.set_title(f'{name_data} Data of {key}')
+    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]):
+            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')
+
+    ax.grid(True)
+    ax.legend(loc='best')
+    ax.set_xlabel('Time (s)')
+    ax.set_ylabel(f'Value {key}')
+
+    # min_val = min([min(A), min(B)])
+    # max_val = max([max(A), max(B)])
+    # plt.ylim(min_val - min_val / 10, max_val + max_val / 10)
+
+    # # Plot
+    # self.fig, self.ax = self.plt.subplots(2*len(output_keys), 2,
+    #                                 gridspec_kw={'width_ratios': [5, 1], 'height_ratios': [2, 1]*len(output_keys)})
+    # if len(self.ax.shape) == 1:
+    #     self.ax = np.expand_dims(self.ax, axis=0)
+    # #plotsamples = self.prediction.shape[1]s
+    # plotsamples = 200
+    # for i in range(0, nnodely.prediction.shape[0]):
+    #     # Zoomed test data
+    #     self.ax[2*i,0].plot(nnodely.prediction[i], linestyle='dashed')
+    #     self.ax[2*i,0].plot(nnodely.label[i])
+    #     self.ax[2*i,0].grid('on')
+    #     self.ax[2*i,0].set_xlim((performance['max_se_idxs'][i]-plotsamples, performance['max_se_idxs'][i]+plotsamples))
+    #     self.ax[2*i,0].vlines(performance['max_se_idxs'][i], nnodely.prediction[i][performance['max_se_idxs'][i]], nnodely.label[i][performance['max_se_idxs'][i]],
+    #                             colors='r', linestyles='dashed')
+    #     self.ax[2*i,0].legend(['predicted', 'test'], prop={'family':'serif'})
+    #     self.ax[2*i,0].set_title(output_keys[i], family='serif')
+    #     # Statitics
+    #     self.ax[2*i,1].axis("off")
+    #     self.ax[2*i,1].invert_yaxis()
+    #     if performance:
+    #         text = "Rmse test: {:3.6f}\nFVU: {:3.6f}".format(#\nAIC: {:3.6f}
+    #             nnodely.performance['rmse_test'][i],
+    #             #nnodely.performance['aic'][i],
+    #             nnodely.performance['fvu'][i])
+    #         self.ax[2*i,1].text(0, 0, text, family='serif', verticalalignment='top')
+    #     # test data
+    #     self.ax[2*i+1,0].plot(nnodely.prediction[i], linestyle='dashed')
+    #     self.ax[2*i+1,0].plot(nnodely.label[i])
+    #     self.ax[2*i+1,0].grid('on')
+    #     self.ax[2*i+1,0].legend(['predicted', 'test'], prop={'family':'serif'})
+    #     self.ax[2*i+1,0].set_title(output_keys[i], family='serif')
+    #     # Empty
+    #     self.ax[2*i+1,1].axis("off")
+    # self.fig.tight_layout()
+    # self.plt.show()
+
+
+def plot_fuzzy(ax, name, x, y, chan_centers):
+    tableau_colors = mcolors.TABLEAU_COLORS
+    num_of_colors = len(list(tableau_colors.keys()))
+    for ind in range(len(y)):
+        ax.axvline(x=chan_centers[ind], color=tableau_colors[list(tableau_colors.keys())[ind % num_of_colors]],
+                   linestyle='--')
+        ax.plot(x, y[ind], label=f'Channel {int(ind) + 1}', linewidth=2)
+    ax.legend(loc='best')
+    ax.set_xlabel('Input')
+    ax.set_ylabel('Value')
+    ax.set_title(f'Function {name}')
+
+
+def plot_3d_function(plt, name, x0, x1, params, output, input_names):
+    fig = plt.figure()
+    # Clear the current plot
+    plt.clf()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot_surface(np.array(x0), np.array(x1), np.array(output), cmap='viridis')
+    ax.set_xlabel(input_names[0])
+    ax.set_ylabel(input_names[1])
+    ax.set_zlabel(f'{name} output')
+    for ind in range(len(input_names) - 2):
+        fig.text(0.01, 0.9 - 0.05 * ind, f"{input_names[ind + 2]} ={params[ind]}", fontsize=10, color='blue',
+                 style='italic')
+    plt.title(f'Function {name}')
+
+def plot_2d_function(plt, name, x, params, output, input_names):
+    fig = plt.figure()
+    # Clear the current plot
+    plt.clf()
+    plt.plot(np.array(x), np.array(output), linewidth=2)
+    plt.xlabel(input_names[0])
+    plt.ylabel(f'{name} output')
+    for ind in range(len(input_names) - 1):
+        fig.text(0.01, 0.9 - 0.05 * ind, f"{input_names[ind + 1]} ={params[ind]}", fontsize=10, color='blue',
+                 style='italic')
+    plt.title(f'Function {name}')

nnodely/__init__.py

@@ -0,0 +1,42 @@
+
+__version__ = '0.14.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.6 for "+__package__+".")
+elif minor < 10:
+    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.input import Input, State, Connect, ClosedLoop
+from nnodely.parameter import Parameter, Constant
+from nnodely.output import Output
+
+# Network elements
+from nnodely.activation import Relu, Tanh
+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.parametricfunction import ParamFun
+from nnodely.fuzzify import Fuzzify
+from nnodely.part import TimePart, TimeSelect, SamplePart, SampleSelect, Part, Select
+from nnodely.localmodel import LocalModel
+
+# Main nnodely classes
+from nnodely.nnodely import nnodely, Modely
+from nnodely.visualizer import Visualizer, TextVisualizer, MPLVisualizer, MPLNotebookVisualizer
+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

nnodely/activation.py

@@ -0,0 +1,85 @@
+import torch.nn as nn
+
+from nnodely.relation import Stream, ToStream, toStream
+from nnodely.model import Model
+from nnodely.utils import check
+import torch
+
+relu_relation_name = 'ReLU'
+tanh_relation_name = 'Tanh'
+elu_relation_name = 'ELU'
+
+class Relu(Stream, ToStream):
+    """
+    Relu activation function for the stream object.
+    Example:
+        >>> x = Relu(x)
+    """
+    def __init__(self, obj:Stream) -> 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 Tanh(Stream, ToStream):
+    """
+    Tanh activation function for the stream object.
+    Example:
+        >>> x = Tanh(x)
+    """
+    def __init__(self, obj:Stream) -> 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__(tanh_relation_name + str(Stream.count),obj.json,obj.dim)
+        self.json['Relations'][self.name] = [tanh_relation_name,[obj.name]]
+
+class ELU(Stream, ToStream):
+    """
+    ELU activation function for the stream object.
+    Example:
+        >>> x = ELU(x)
+    """
+    def __init__(self, obj:Stream) -> 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 Tanh_Layer(nn.Module):
+    #: :noindex:
+    def __init__(self,):
+        super(Tanh_Layer, self).__init__()
+    def forward(self, x):
+        return torch.tanh(x)
+
+def createTanh(self, *input):
+    """
+     :noindex:
+    """
+    return Tanh_Layer()
+
+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()
+
+setattr(Model, relu_relation_name, createRelu)
+setattr(Model, tanh_relation_name, createTanh)
+setattr(Model, elu_relation_name, createELU)

nnodely/arithmetic.py

@@ -0,0 +1,203 @@
+import torch.nn as nn
+import torch
+
+from nnodely.relation import ToStream, Stream, toStream
+from nnodely.model import Model
+from nnodely.utils import check, merge
+
+
+# Binary operators
+add_relation_name = 'Add'
+sub_relation_name = 'Sub'
+mul_relation_name = 'Mul'
+div_relation_name = 'Div'
+pow_relation_name = 'Pow'
+
+# Unary operators
+neg_relation_name = 'Neg'
+# square_relation_name = 'Square'
+
+# Merge operator
+sum_relation_name = 'Sum'
+class Add(Stream, ToStream):
+    def __init__(self, obj1:Stream, obj2:Stream) -> 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.")
+        check(type(obj2) is Stream,TypeError,
+              f"The type of {obj2} is {type(obj2)} and is not supported for add operation.")
+        check(obj1.dim == obj2.dim or obj1.dim == {'dim':1} or obj2.dim == {'dim':1}, ValueError,
+              f"For addition operators (+) the dimension of {obj1.name} = {obj1.dim} must be the same of {obj2.name} = {obj2.dim}.")
+        super().__init__(add_relation_name + str(Stream.count),merge(obj1.json,obj2.json),obj1.dim)
+        self.json['Relations'][self.name] = [add_relation_name,[obj1.name,obj2.name]]
+
+## TODO: check the scalar dimension, helpful for the offset
+class Sub(Stream, ToStream):
+    def __init__(self, obj1:Stream, obj2:Stream) -> 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.")
+        check(type(obj2) is Stream,TypeError,
+              f"The type of {obj2} is {type(obj2)} and is not supported for sub operation.")
+        check(obj1.dim == obj2.dim or obj1.dim == {'dim':1} or obj2.dim == {'dim':1}, ValueError,
+              f"For subtraction operators (-) the dimension of {obj1.name} = {obj1.dim} must be the same of {obj2.name} = {obj2.dim}.")
+        super().__init__(sub_relation_name + str(Stream.count),merge(obj1.json,obj2.json),obj1.dim)
+        self.json['Relations'][self.name] = [sub_relation_name,[obj1.name,obj2.name]]
+
+class Mul(Stream, ToStream):
+    def __init__(self, obj1:Stream, obj2:Stream) -> 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.")
+        check(type(obj2) is Stream, TypeError,
+              f"The type of {obj2} is {type(obj2)} and is not supported for mul operation.")
+        check(obj1.dim == obj2.dim or obj1.dim == {'dim':1} or obj2.dim == {'dim':1}, ValueError,
+              f"For multiplication operators (*) the dimension of {obj1.name} = {obj1.dim} must be the same of {obj2.name} = {obj2.dim}.")
+        super().__init__(mul_relation_name + str(Stream.count),merge(obj1.json,obj2.json),obj1.dim)
+        self.json['Relations'][self.name] = [mul_relation_name,[obj1.name,obj2.name]]
+
+class Div(Stream, ToStream):
+    def __init__(self, obj1:Stream, obj2:Stream) -> 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.")
+        check(type(obj2) is Stream, TypeError,
+              f"The type of {obj2} is {type(obj2)} and is not supported for div operation.")
+        check(obj1.dim == obj2.dim or obj1.dim == {'dim':1} or obj2.dim == {'dim':1}, ValueError,
+              f"For division operators (*) the dimension of {obj1.name} = {obj1.dim} must be the same of {obj2.name} = {obj2.dim}.")
+        super().__init__(div_relation_name + str(Stream.count),merge(obj1.json,obj2.json),obj1.dim)
+        self.json['Relations'][self.name] = [div_relation_name,[obj1.name,obj2.name]]
+
+class Pow(Stream, ToStream):
+    def __init__(self, obj1:Stream, obj2:Stream) -> 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.")
+        check(type(obj2) is Stream, TypeError,
+              f"The type of {obj2} is {type(obj2)} but must be int or float and is not supported for exp operation.")
+        check(obj1.dim == obj2.dim or obj1.dim == {'dim':1} or obj2.dim == {'dim':1}, ValueError,
+              f"For division operators (*) the dimension of {obj1.name} = {obj1.dim} must be the same of {obj2.name} = {obj2.dim}.")
+        super().__init__(pow_relation_name + str(Stream.count),merge(obj1.json,obj2.json),obj1.dim)
+        self.json['Relations'][self.name] = [pow_relation_name,[obj1.name,obj2.name]]
+
+class Neg(Stream, ToStream):
+    def __init__(self, obj:Stream) -> 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:
+        obj = toStream(obj)
+        check(type(obj) is Stream, TypeError,
+              f"The type of {obj} is {type(obj)} and is not supported for sum operation.")
+        super().__init__(sum_relation_name + str(Stream.count),obj.json,obj.dim)
+        self.json['Relations'][self.name] = [sum_relation_name,[obj.name]]
+
+class Add_Layer(nn.Module):
+    #: :noindex:
+    def __init__(self):
+        super(Add_Layer, self).__init__()
+
+    def forward(self, *inputs):
+        return torch.add(inputs[0], inputs[1])
+
+def createAdd(name, *inputs):
+    #: :noindex:
+    return Add_Layer()
+
+class Sub_Layer(nn.Module):
+    #: :noindex:
+    def __init__(self):
+        super(Sub_Layer, self).__init__()
+
+    def forward(self, *inputs):
+        # Perform element-wise subtraction
+        return torch.add(inputs[0],-inputs[1])
+
+def createSub(self, *inputs):
+    #: :noindex:
+    return Sub_Layer()
+
+
+class Mul_Layer(nn.Module):
+    #: :noindex:
+    def __init__(self):
+        super(Mul_Layer, self).__init__()
+
+    def forward(self, *inputs):
+        return inputs[0] * inputs[1]
+
+def createMul(name, *inputs):
+    #: :noindex:
+    return Mul_Layer()
+
+class Div_Layer(nn.Module):
+    #: :noindex:
+    def __init__(self):
+        super(Div_Layer, self).__init__()
+
+    def forward(self, *inputs):
+        return inputs[0] / inputs[1]
+
+def createDiv(name, *inputs):
+    #: :noindex:
+    return Div_Layer()
+
+class Pow_Layer(nn.Module):
+    #: :noindex:
+    def __init__(self):
+        super(Pow_Layer, self).__init__()
+
+    def forward(self, *inputs):
+        return torch.pow(inputs[0], inputs[1])
+
+def createPow(name, *inputs):
+    #: :noindex:
+    return Pow_Layer()
+
+class Neg_Layer(nn.Module):
+    #: :noindex:
+    def __init__(self):
+        super(Neg_Layer, self).__init__()
+
+    def forward(self, x):
+        return -x
+
+def createNeg(self, *inputs):
+    #: :noindex:
+    return Neg_Layer()
+
+class Sum_Layer(nn.Module):
+    #: :noindex:
+    def __init__(self):
+        super(Sum_Layer, self).__init__()
+
+    def forward(self, inputs):
+        return torch.sum(inputs, dim = 2)
+
+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)
+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/earlystopping.py

@@ -0,0 +1,81 @@
+# Early stopping functions:
+# The functions return True if the training should stop
+
+# "Classical" early stopping based on the validation loss:
+# Stop if the validation loss has not improved for a certain number of epochs
+def early_stop_patience(train_losses, val_losses, params):
+  patience = params['patience'] if 'patience' in params.keys() else 50
+  if val_losses:
+    losses = val_losses
+  else:
+    # if there is no validation set, use the training losses
+    losses = train_losses
+
+  if 'error' in params.keys():
+    # if the type of loss to be used is provided by the user
+    losses_use = losses[params['error']]
+  else:
+    # take the mean of all the losses for all the keys of the dictionary
+    import numpy as np
+    losses_use = [np.mean([losses[key][index] for key in losses.keys()]) for index in range(len(losses[list(losses.keys())[0]]))]
+  if len(losses_use) > patience:
+    # index of the minimum validation loss
+    min_val_loss_index = losses_use.index(min(losses_use))
+    # check if the patience has been exceeded
+    if min_val_loss_index < len(losses_use) - patience:
+      return True
+  return False
+
+
+def select_best_model(train_losses, val_losses, params):
+    if val_losses:
+        losses = val_losses
+    else:
+        # if there is no validation set, use the training losses
+        losses = train_losses
+    import numpy as np
+    losses_use = [np.mean([losses[key][index] for key in losses.keys()]) for index in
+                  range(len(losses[list(losses.keys())[0]]))]
+    if len(losses_use)-1 == losses_use.index(min(losses_use)):
+        return True
+    else:
+        return False
+
+
+def mean_stopping(train_losses, val_losses, params):
+    tol = params['tol'] if 'tol' in params.keys() else 0.001
+    if val_losses:
+        for (train_loss_name, train_loss_value), (val_loss_name, val_loss_value) in zip(train_losses.items(), val_losses.items()):
+            if abs(train_loss_value[-1] - val_loss_value[-1]) < tol:
+                return True
+    else:
+        for loss_name, loss_value in train_losses.items():
+            if loss_value[-1] < tol:
+                return True
+    return False
+
+def standard_early_stopping(train_losses, val_losses, params):
+    n = params['tol'] if 'tol' in params.keys() else 10
+    if val_losses:
+        for (_, train_loss_value), (_, val_loss_value) in zip(train_losses.items(), val_losses.items()):
+            if (len(train_loss_value) <= n) and (len(val_loss_value) <= n):
+                return False
+            
+            tol = 0.0
+            for train_loss, val_loss in zip(train_loss_value[-n:], val_loss_value[-n:]):
+                if abs(train_loss - val_loss) > tol:
+                    tol = abs(train_loss - val_loss)
+                else:
+                    return False
+    else:
+        for _, loss_value in train_losses.items():
+            if (len(loss_value) <= n):
+                return False
+            
+            tol = loss_value[-n]
+            for loss in loss_value[-n+1:]:
+                if loss < tol:
+                    return False
+                
+    return True
+            

nnodely/exporter/__init__.py

@@ -0,0 +1,3 @@
+from nnodely.exporter.export import save_model, load_model, export_python_model
+from nnodely.exporter.exporter import Exporter
+from nnodely.exporter.standardexporter import StandardExporter