nnodely 0.14.0__py3-none-any.whl

nnodely/fuzzify.py

@@ -0,0 +1,221 @@
+import inspect, copy, textwrap, torch
+
+import numpy as np
+import torch.nn as nn
+
+from collections.abc import Callable
+
+from nnodely.relation import NeuObj, Stream
+from nnodely.model import Model
+from nnodely.utils import check, merge, enforce_types
+
+from nnodely.logger import logging, nnLogger
+log = nnLogger(__name__, logging.CRITICAL)
+
+fuzzify_relation_name = 'Fuzzify'
+
+
+class Fuzzify(NeuObj):
+    @enforce_types
+    def __init__(self, output_dimension: int | None = None,
+                 range: list | None = None,
+                 centers: list | None = None,
+                 functions: str | list | Callable = 'Triangular'):
+
+        self.relation_name = fuzzify_relation_name
+        super().__init__('F' + fuzzify_relation_name + str(NeuObj.count))
+        self.json['Functions'][self.name] = {}
+        if output_dimension is not None:
+            check(range is not None, ValueError, 'if "output_dimension" is not None, "range" must be not setted')
+            check(centers is None, ValueError,
+                  'if "output_dimension" and "range" are not None, then "centers" must be None')
+            self.output_dimension = {'dim': output_dimension}
+            interval = ((range[1] - range[0]) / (output_dimension - 1))
+            self.json['Functions'][self.name]['centers'] = np.arange(range[0], range[1] + interval, interval).tolist()
+        else:
+            check(centers is not None, ValueError, 'if "output_dimension" is None and "centers" must be setted')
+            self.output_dimension = {'dim': len(centers)}
+            self.json['Functions'][self.name]['centers'] = np.array(centers).tolist()
+        self.json['Functions'][self.name]['dim_out'] = copy.deepcopy(self.output_dimension)
+
+        if type(functions) is str:
+            self.json['Functions'][self.name]['functions'] = functions
+            self.json['Functions'][self.name]['names'] = functions
+        elif type(functions) is list:
+            self.json['Functions'][self.name]['functions'] = []
+            self.json['Functions'][self.name]['names'] = []
+            for func in functions:
+                code = textwrap.dedent(inspect.getsource(func)).replace('\"', '\'')
+                self.json['Functions'][self.name]['functions'].append(code)
+                self.json['Functions'][self.name]['names'].append(func.__name__)
+        else:
+            code = textwrap.dedent(inspect.getsource(functions)).replace('\"', '\'')
+            self.json['Functions'][self.name]['functions'] = code
+            self.json['Functions'][self.name]['names'] = functions.__name__
+
+    def __call__(self, obj: Stream) -> Stream:
+        stream_name = fuzzify_relation_name + str(Stream.count)
+        check(type(obj) is Stream, TypeError,
+              f"The type of {obj} is {type(obj)} and is not supported for Fuzzify operation.")
+        check('dim' in obj.dim and obj.dim['dim'] == 1, ValueError, 'Input dimension must be scalar')
+        output_dimension = copy.deepcopy(obj.dim)
+        output_dimension.update(self.output_dimension)
+        stream_json = merge(self.json, obj.json)
+        stream_json['Relations'][stream_name] = [fuzzify_relation_name, [obj.name], self.name]
+        return Stream(stream_name, stream_json, output_dimension)
+
+
+def return_fuzzify(json, xlim=None, num_points=1000):
+    if xlim is not None:
+        x = torch.from_numpy(np.linspace(xlim[0], xlim[1], num=num_points))
+    else:
+        x = torch.from_numpy(np.linspace(json['centers'][0] - 2, json['centers'][-1] + 2, num=num_points))
+    chan_centers = np.array(json['centers'])
+    activ_fun = {}
+    if isinstance(json['names'], list):
+        n_func = len(json['names'])
+    else:
+        n_func = 1
+    for i in range(len(chan_centers)):
+        if json['functions'] == 'Triangular':
+            activ_fun[i] = triangular(x, i, chan_centers).tolist()
+        elif json['functions'] == 'Rectangular':
+            activ_fun[i] = rectangular(x, i, chan_centers).tolist()
+        else:
+            if isinstance(json['names'], list):
+                if i >= n_func:
+                    func_idx = i - round(n_func * (i // n_func))
+                else:
+                    func_idx = i
+                exec(json['functions'][func_idx], globals())
+                function_to_call = globals()[json['names'][func_idx]]
+            else:
+                exec(json['functions'], globals())
+                function_to_call = globals()[json['names']]
+            activ_fun[i] = custom_function(function_to_call, x, i, chan_centers).tolist()
+    return x.tolist(), activ_fun
+
+
+def triangular(x, idx_channel, chan_centers):
+    # Compute the number of channels
+    num_channels = len(chan_centers)
+
+    # First dimension of activation
+    if idx_channel == 0:
+        if num_channels != 1:
+            ampl = chan_centers[1] - chan_centers[0]
+            act_fcn = torch.minimum(torch.maximum(-(x - chan_centers[0]) / ampl + 1, torch.tensor(0.0)),
+                                    torch.tensor(1.0))
+        else:
+            # In case the user only wants one channel
+            act_fcn = 1
+    elif idx_channel != 0 and idx_channel == (num_channels - 1):
+        ampl = chan_centers[-1] - chan_centers[-2]
+        act_fcn = torch.minimum(torch.maximum((x - chan_centers[-2]) / ampl, torch.tensor(0.0)), torch.tensor(1.0))
+    else:
+        ampl_1 = chan_centers[idx_channel] - chan_centers[idx_channel - 1]
+        ampl_2 = chan_centers[idx_channel + 1] - chan_centers[idx_channel]
+        act_fcn = torch.minimum(torch.maximum((x - chan_centers[idx_channel - 1]) / ampl_1, torch.tensor(0.0)),
+                                torch.maximum(-(x - chan_centers[idx_channel]) / ampl_2 + 1, torch.tensor(0.0)))
+
+    return act_fcn
+
+
+def rectangular(x, idx_channel, chan_centers):
+    ## compute number of channels
+    num_channels = len(chan_centers)
+
+    ## First dimension of activation
+    if idx_channel == 0:
+        if num_channels != 1:
+            width = abs(chan_centers[idx_channel + 1] - chan_centers[idx_channel]) / 2
+            act_fcn = torch.where(x < (chan_centers[idx_channel] + width), 1.0, 0.0)
+        else:
+            # In case the user only wants one channel
+            act_fcn = 1.0
+    elif idx_channel != 0 and idx_channel == (num_channels - 1):
+        width = abs(chan_centers[idx_channel] - chan_centers[idx_channel - 1]) / 2
+        act_fcn = torch.where(x >= chan_centers[idx_channel] - width, 1.0, 0.0)
+    else:
+        width_forward = abs(chan_centers[idx_channel + 1] - chan_centers[idx_channel]) / 2
+        width_backward = abs(chan_centers[idx_channel] - chan_centers[idx_channel - 1]) / 2
+        act_fcn = torch.where(
+            (x >= chan_centers[idx_channel] - width_backward) & (x < chan_centers[idx_channel] + width_forward), 1.0,
+            0.0)
+
+    return act_fcn
+
+
+def custom_function(func, x, idx_channel, chan_centers):
+    act_fcn = func(x - chan_centers[idx_channel])
+    return act_fcn
+
+
+class Fuzzify_Layer(nn.Module):
+    def __init__(self, params):
+        super().__init__()
+        self.centers = params['centers']
+        self.function = params['functions']
+        self.dimension = params['dim_out']['dim']
+        self.name = params['names']
+
+        if type(self.name) is list:
+            self.n_func = len(self.name)
+            for func, name in zip(self.function, self.name):
+                ## Add the function to the globals
+                try:
+                    code = 'import torch\n@torch.fx.wrap\n' + func
+                    exec(code, globals())
+                except Exception as e:
+                    check(False, RuntimeError, f"An error occurred when running the function '{name}':\n {e}")
+        else:
+            self.n_func = 1
+            if self.name not in ['Triangular', 'Rectangular']:  ## custom function
+                ## Add the function to the globals
+                try:
+                    code = 'import torch\n@torch.fx.wrap\n' + self.function
+                    exec(code, globals())
+                except Exception as e:
+                    check(False, RuntimeError, f"An error occurred when running the function '{self.name}':\n {e}")
+
+    def forward(self, x):
+        # res = torch.empty((x.size(0), x.size(1), self.dimension), dtype=torch.float32)
+        res = torch.zeros_like(x).repeat(1, 1, self.dimension)
+
+        if self.function == 'Triangular':
+            for i in range(len(self.centers)):
+                # res[:, :, i:i+1] = triangular(x, i, self.centers)
+                slicing(res, torch.tensor(i), triangular(x, i, self.centers))
+        elif self.function == 'Rectangular':
+            for i in range(len(self.centers)):
+                # res[:, :, i:i+1] = rectangular(x, i, self.centers)
+                slicing(res, torch.tensor(i), rectangular(x, i, self.centers))
+        else:  ## Custom_function
+            if self.n_func == 1:
+                # Retrieve the function object from the globals dictionary
+                function_to_call = globals()[self.name]
+                for i in range(len(self.centers)):
+                    # res[:, :, i:i+1] = custom_function(function_to_call, x, i, self.centers)
+                    slicing(res, torch.tensor(i), custom_function(function_to_call, x, i, self.centers))
+            else:  ## we have multiple functions
+                for i in range(len(self.centers)):
+                    if i >= self.n_func:
+                        func_idx = i - round(self.n_func * (i // self.n_func))
+                    else:
+                        func_idx = i
+                    function_to_call = globals()[self.name[func_idx]]
+                    # res[:, :, i:i+1] = custom_function(function_to_call, x, i, self.centers)
+                    slicing(res, torch.tensor(i), custom_function(function_to_call, x, i, self.centers))
+        return res
+
+
+@torch.fx.wrap
+def slicing(res, i, x):
+    res[:, :, i:i + 1] = x
+
+
+def createFuzzify(self, *params):
+    return Fuzzify_Layer(params[0])
+
+
+setattr(Model, fuzzify_relation_name, createFuzzify)

nnodely/initializer.py

@@ -0,0 +1,31 @@
+
+def init_constant(indexes, params_size, dict_param = {'value':1}):
+    return dict_param['value']
+
+def init_negexp(indexes, params_size, dict_param = {'size_index':0, 'first_value':1, 'lambda':3}):
+    import numpy as np
+    size_index = dict_param['size_index']
+    # check if the size of the list of parameters is 1, to avoid a division by zero
+    x = 1 if params_size[size_index]-1 == 0 else indexes[size_index]/(params_size[size_index]-1)
+    return dict_param['first_value']*np.exp(-dict_param['lambda']*(1-x))
+
+def init_exp(indexes, params_size, dict_param = {'size_index':0, 'max_value':1, 'lambda':3, 'monotonicity':'decreasing'}):
+    import numpy as np
+    size_index = dict_param['size_index']
+    monotonicity = dict_param['monotonicity']
+    if monotonicity == 'increasing':
+        # increasing exponential, the 'max_value' is the value at x=1, i.e, at the end of the range
+        x = 1 if params_size[size_index]-1 == 0 else indexes[size_index]/(params_size[size_index]-1)
+        out = dict_param['max_value']*np.exp(dict_param['lambda']*(x-1))
+    elif monotonicity == 'decreasing':
+        # decreasing exponential, the 'max_value' is the value at x=0, i.e, at the beginning of the range
+        x = 0 if params_size[size_index]-1 == 0 else indexes[size_index]/(params_size[size_index]-1)
+        out = dict_param['max_value']*np.exp(-dict_param['lambda']*x)
+    else:
+        raise ValueError('The parameter monotonicity must be either increasing or decreasing.')
+    return out
+
+def init_lin(indexes, params_size, dict_param = {'size_index':0, 'first_value':1, 'last_value':0}):
+    size_index = dict_param['size_index']
+    x = 0 if params_size[size_index]-1 == 0 else indexes[size_index]/(params_size[size_index]-1)
+    return (dict_param['last_value'] - dict_param['first_value']) * x + dict_param['first_value']

nnodely/input.py

@@ -0,0 +1,131 @@
+import copy
+
+from nnodely.relation import NeuObj, Stream, ToStream
+from nnodely.utils import check, merge
+from nnodely.part import SamplePart, TimePart
+
+class InputState(NeuObj, Stream):
+    def __init__(self, json_name, name, dimensions:int = 1):
+        NeuObj.__init__(self, name)
+        check(type(dimensions) == int, TypeError,"The dimensions must be a integer")
+        self.json_name = json_name
+        self.json[self.json_name][self.name] = {'dim': dimensions, 'tw': [0, 0], 'sw': [0,0] }
+        self.dim = {'dim': dimensions}
+        Stream.__init__(self, name, self.json, self.dim)
+
+    def tw(self, tw, offset = None):
+        dim = copy.deepcopy(self.dim)
+        json = copy.deepcopy(self.json)
+        if type(tw) is list:
+            json[self.json_name][self.name]['tw'] = tw
+            tw = tw[1] - tw[0]
+        else:
+            json[self.json_name][self.name]['tw'][0] = -tw
+        check(tw > 0, ValueError, "The time window must be positive")
+        dim['tw'] = tw
+        if offset is not None:
+            check(json[self.json_name][self.name]['tw'][0] <= offset < json[self.json_name][self.name]['tw'][1],
+                  IndexError,
+                  "The offset must be inside the time window")
+        return TimePart(Stream(self.name, json, dim), json[self.json_name][self.name]['tw'][0], json[self.json_name][self.name]['tw'][1], offset)
+
+    # Select a sample window
+    # Example T = [-3,-2,-1,0,1,2]       # 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 time step in the past
+    # If sw is a list [#1,#2] the numbers represent the time index in the vector 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]
+    # 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]
+    def sw(self, sw, offset = None):
+        dim = copy.deepcopy(self.dim)
+        json = copy.deepcopy(self.json)
+        if type(sw) is list:
+            check(type(sw[0]) == int and type(sw[1]) == int, TypeError, "The sample window must be integer")
+            json[self.json_name][self.name]['sw'] = sw
+            sw = sw[1] - sw[0]
+        else:
+            check(type(sw) == int, TypeError, "The sample window must be integer")
+            json[self.json_name][self.name]['sw'][0] = -sw
+        check(sw > 0, ValueError, "The sample window must be positive")
+        dim['sw'] = sw
+        if offset is not None:
+            check(json[self.json_name][self.name]['sw'][0] <= offset < json[self.json_name][self.name]['sw'][1],
+                  IndexError,
+                  "The offset must be inside the sample window")
+        return SamplePart(Stream(self.name, json, dim), json[self.json_name][self.name]['sw'][0], json[self.json_name][self.name]['sw'][1], offset)
+
+    # Select the unitary delay
+    # Example T = [-3,-2,-1,0,1,2] # time vector 0 represent the last passed instant
+    # T.z(-1) = 1
+    # T.z(0)  = 0 #the last passed instant
+    # T.z(2)  = -2
+    def z(self, delay):
+        dim = copy.deepcopy(self.dim)
+        json = copy.deepcopy(self.json)
+        sw = [(-delay) - 1, (-delay)]
+        json[self.json_name][self.name]['sw'] = sw
+        dim['sw'] = sw[1] - sw[0]
+        return SamplePart(Stream(self.name, json, dim), json[self.json_name][self.name]['sw'][0], json[self.json_name][self.name]['sw'][1], None)
+
+    def last(self):
+        return self.z(0)
+
+    def next(self):
+        return self.z(-1)
+
+    # def s(self, derivate):
+    #     return Stream((self.name, {'s':derivate}), self.json, self.dim)
+
+
+class Input(InputState):
+    def __init__(self, name, dimensions:int = 1):
+        InputState.__init__(self, 'Inputs', name, dimensions)
+
+class State(InputState):
+    def __init__(self, name, dimensions:int = 1):
+        InputState.__init__(self, 'States', name, dimensions)
+
+
+# connect operation
+connect_name = 'connect'
+closedloop_name = 'closedLoop'
+
+
+# class Connect(Stream, ToStream):
+#     def __init__(self, obj1: Stream, obj2: State) -> Stream:
+#         check(type(obj1) is Stream, TypeError,
+#               f"The {obj1} must be a Stream or Output and not a {type(obj1)}.")
+#         obj1.connect(obj2)
+#
+# class ClosedLoop(Stream, ToStream):
+#     def __init__(self, obj1: Stream, obj2: State) -> Stream:
+#         check(type(obj1) is Stream, TypeError,
+#               f"The {obj1} must be a Stream or Output and not a {type(obj1)}.")
+#         obj1.closedloop(obj2)
+
+class Connect(Stream, ToStream):
+    def __init__(self, obj1:Stream, obj2:State) -> Stream:
+        check(type(obj1) is Stream, TypeError,
+              f"The {obj1} must be a Stream and not a {type(obj1)}.")
+        check(type(obj2) is State, TypeError,
+              f"The {obj2} must be a State and not a {type(obj2)}.")
+        super().__init__(obj1.name,merge(obj1.json, obj2.json),obj1.dim)
+        check(closedloop_name not in self.json['States'][obj2.name] or connect_name not in self.json['States'][obj2.name],
+              KeyError,f"The state variable {obj2.name} is already connected.")
+        self.json['States'][obj2.name][connect_name] = obj1.name
+
+class ClosedLoop(Stream, ToStream):
+    def __init__(self, obj1:Stream, obj2: State) -> Stream:
+        check(type(obj1) is Stream, TypeError,
+              f"The {obj1} must be a Stream and not a {type(obj1)}.")
+        check(type(obj2) is State, TypeError,
+              f"The {obj2} must be a State and not a {type(obj2)}.")
+        super().__init__(obj1.name, merge(obj1.json, obj2.json), obj1.dim)
+        check(closedloop_name not in self.json['States'][obj2.name] or connect_name not in self.json['States'][obj2.name],
+              KeyError, f"The state variable {obj2.name} is already connected.")
+        self.json['States'][obj2.name][closedloop_name] = obj1.name

nnodely/linear.py

@@ -0,0 +1,130 @@
+import copy, inspect, textwrap, torch
+
+import torch.nn as nn
+
+from collections.abc import Callable
+
+from nnodely.relation import NeuObj, Stream, AutoToStream
+from nnodely.model import Model
+from nnodely.parameter import Parameter
+from nnodely.utils import check, merge, enforce_types
+
+from nnodely.logger import logging, nnLogger
+log = nnLogger(__name__, logging.CRITICAL)
+
+linear_relation_name = 'Linear'
+class Linear(NeuObj, AutoToStream):
+
+    @enforce_types
+    def __init__(self, output_dimension:int|None = None,
+                 W_init:Callable|None = None,
+                 W_init_params:dict|None = None,
+                 b_init:Callable|None = None,
+                 b_init_params:dict|None = None,
+                 W:Parameter|str|None = None,
+                 b:bool|str|Parameter|None = None,
+                 dropout:int|float = 0):
+
+        self.relation_name = linear_relation_name
+        self.W_init = W_init
+        self.W_init_params = W_init_params
+        self.b_init = b_init
+        self.b_init_params = b_init_params
+        self.W = W
+        self.b = b
+        self.bname = None
+        self.Wname = None
+        self.dropout = dropout
+        super().__init__('P' + linear_relation_name + str(NeuObj.count))
+
+        if W is None:
+            self.output_dimension = 1 if output_dimension is None else output_dimension
+            self.Wname = self.name + 'W'
+        elif type(W) is str:
+            self.output_dimension = 1 if output_dimension is None else output_dimension
+            self.Wname = W
+        else:
+            check(type(W) is Parameter or type(W) is str, TypeError, 'The "W" must be of type Parameter or str.')
+            window = 'tw' if 'tw' in W.dim else ('sw' if 'sw' in W.dim else None)
+            check(window == None or W.dim['sw'] == 1, ValueError, 'The "W" must not have window dimension.')
+            check(len(W.dim['dim']) == 2, ValueError,'The "W" dimensions must be a list of 2.')
+            self.output_dimension = W.dim['dim'][1]
+            if output_dimension is not None:
+                check(W.dim['dim'][1] == output_dimension, ValueError, 'output_dimension must be equal to the second dim of "W".')
+            self.Wname = W.name
+            self.json['Parameters'][W.name] = copy.deepcopy(W.json['Parameters'][W.name])
+
+        if b is not None:
+            check(type(b) is Parameter or type(b) is bool or type(b) is str, TypeError, 'The "b" must be of type Parameter, bool or str.')
+            if type(b) is Parameter:
+                check(type(b.dim['dim']) is int, ValueError, 'The "b" dimensions must be an integer.')
+                if output_dimension is not None:
+                    check(b.dim['dim'] == output_dimension, ValueError,
+                          'output_dimension must be equal to the dim of the "b".')
+                self.bname = b.name
+                self.json['Parameters'][b.name] = copy.deepcopy(b.json['Parameters'][b.name])
+            elif type(b) is str:
+                self.bname = b
+                self.json['Parameters'][self.bname] = { 'dim': self.output_dimension }
+            else:
+                self.bname = self.name + 'b'
+                self.json['Parameters'][self.bname] = { 'dim': self.output_dimension }
+
+    def __call__(self, obj:Stream) -> Stream:
+        stream_name = linear_relation_name + str(Stream.count)
+        check(type(obj) is Stream, TypeError,
+              f"The type of {obj} is {type(obj)} and is not supported for Linear operation.")
+        window = 'tw' if 'tw' in obj.dim else ('sw' if 'sw' in obj.dim else None)
+
+        if type(self.W) is Parameter:
+            check(self.W.dim['dim'][0] == obj.dim['dim'], ValueError,
+                  'the input dimension must be equal to the first dim of the parameter')
+        else:
+            self.json['Parameters'][self.Wname] = { 'dim': [obj.dim['dim'],self.output_dimension,] }
+
+        if self.W_init is not None:
+            check('values' not in self.json['Parameters'][self.Wname], ValueError, f"The parameter {self.Wname} is already initialized.")
+            check(inspect.isfunction(self.W_init), ValueError,
+                  f"The W_init parameter must be a function.")
+            code = textwrap.dedent(inspect.getsource(self.W_init)).replace('\"', '\'')
+            self.json['Parameters'][self.Wname]['init_fun'] = { 'code' : code, 'name' : self.W_init.__name__}
+            if self.W_init_params is not None:
+                self.json['Parameters'][self.Wname]['init_fun']['params'] = self.W_init_params
+
+        if self.b_init is not None:
+            check(self.bname is not None, ValueError,f"The bias is missing.")
+            check('values' not in self.json['Parameters'][self.bname], ValueError, f"The parameter {self.bname} is already initialized.")
+            check(inspect.isfunction(self.b_init), ValueError,
+                  f"The b_init parameter must be a function.")
+            code = textwrap.dedent(inspect.getsource(self.b_init)).replace('\"', '\'')
+            self.json['Parameters'][self.bname]['init_fun'] = { 'code' : code, 'name' : self.b_init.__name__ }
+            if self.b_init_params is not None:
+                self.json['Parameters'][self.bname]['init_fun']['params'] = self.b_init_params
+
+        stream_json = merge(self.json,obj.json)
+        stream_json['Relations'][stream_name] = [linear_relation_name, [obj.name], self.Wname, self.bname, self.dropout]
+        return Stream(stream_name, stream_json,{'dim': self.output_dimension, window:obj.dim[window]})
+
+
+class Linear_Layer(nn.Module):
+    def __init__(self, weights, bias=None, dropout=0):
+        super(Linear_Layer, self).__init__()
+        self.dropout = nn.Dropout(p=dropout) if dropout > 0 else None
+        self.weights = weights
+        self.bias = bias
+
+    def forward(self, x):
+        # x is expected to be of shape [batch, window, input_dimension]
+        # Using torch.einsum for batch matrix multiplication
+        y = torch.einsum('bwi,io->bwo', x, self.weights[0])  # y will have shape [batch, window, output_features]
+        if self.bias is not None:
+            y += self.bias  # Add bias
+        # Add dropout if necessary
+        if self.dropout is not None:
+            y = self.dropout(y)
+        return y
+
+def createLinear(self, *inputs):
+    return Linear_Layer(weights=inputs[0], bias=inputs[1], dropout=inputs[2])
+
+setattr(Model, linear_relation_name, createLinear)

nnodely/localmodel.py

@@ -0,0 +1,82 @@
+import inspect
+
+from collections.abc import Callable
+
+from nnodely.relation import NeuObj
+from nnodely.part import Select
+from nnodely.utils import check, enforce_types
+
+localmodel_relation_name = 'LocalModel'
+
+class LocalModel(NeuObj):
+    @enforce_types
+    def __init__(self, input_function:Callable|None = None,
+                 output_function:Callable|None = None,
+                 pass_indexes:bool = False):
+
+        self.relation_name = localmodel_relation_name
+        self.pass_indexes = pass_indexes
+        super().__init__(localmodel_relation_name + str(NeuObj.count))
+        self.json['Functions'][self.name] = {}
+        if input_function is not None:
+            check(callable(input_function), TypeError, 'The input_function must be callable')
+        self.input_function = input_function
+        if output_function is not None:
+            check(callable(output_function), TypeError, 'The output_function must be callable')
+        self.output_function = output_function
+
+
+    def __call__(self, inputs, activations):
+        self.out_sum = []
+        if type(activations) is not tuple:
+            activations = (activations,)
+        self.___activations_matrix(activations,inputs)
+
+        out = self.out_sum[0]
+        for ind in range(1,len(self.out_sum)):
+            out = out + self.out_sum[ind]
+        return out
+
+    # Definisci una funzione ricorsiva per annidare i cicli for
+    def ___activations_matrix(self, activations, inputs, idx=0, idx_list=[]):
+        if idx != len(activations):
+            for i in range(activations[idx].dim['dim']):
+                self.___activations_matrix(activations, inputs, idx+1, idx_list+[i])
+        else:
+            if self.input_function is not None:
+                if len(inspect.getfullargspec(self.input_function).args) == 0:
+                    if type(inputs) is tuple:
+                        out_in = self.input_function()(*inputs)
+                    else:
+                        out_in = self.input_function()(inputs)
+                else:
+                    if self.pass_indexes:
+                        if type(inputs) is tuple:
+                            out_in = self.input_function(idx_list)(*inputs)
+                        else:
+                            out_in = self.input_function(idx_list)(inputs)
+                    else:
+                        if type(inputs) is tuple:
+                            out_in = self.input_function(*inputs)
+                        else:
+                            out_in = self.input_function(inputs)
+            else:
+                check(type(inputs) is not tuple, TypeError, 'The input cannot be a tuple without input_function')
+                out_in = inputs
+
+            act = Select(activations[0], idx_list[0])
+            for ind, i  in enumerate(idx_list[1:]):
+                act = act * Select(activations[ind+1], i)
+
+            prod = out_in * act
+
+            if self.output_function is not None:
+                if len(inspect.getfullargspec(self.output_function).args) == 0:
+                    self.out_sum.append(self.output_function()(prod))
+                else:
+                    if self.pass_indexes:
+                        self.out_sum.append(self.output_function(idx_list)(prod))
+                    else:
+                        self.out_sum.append(self.output_function(prod))
+            else:
+                self.out_sum.append(prod)