nnodely 0.14.0__py3-none-any.whl

nnodely/exporter/export.py

@@ -0,0 +1,275 @@
+import sys, os, torch, importlib
+
+from torch.fx import symbolic_trace
+
+from pprint import PrettyPrinter
+
+class JsonPrettyPrinter(PrettyPrinter):
+    def _format(self, object, *args):
+        if isinstance(object, str):
+            width = self._width
+            self._width = sys.maxsize
+            try:
+                super()._format(object.replace('\'','_"_'), *args)
+            finally:
+                self._width = width
+        else:
+            super()._format(object, *args)
+
+def save_model(model, model_path):
+    # Export the dictionary as a JSON file
+    with open(model_path, 'w') as json_file:
+        # json.dump(self.model_def, json_file, indent=4)
+        json_file.write(JsonPrettyPrinter().pformat(model)
+                        .replace('\'', '\"')
+                        .replace('_"_', '\'')
+                        .replace('None', 'null')
+                        .replace('False', 'false')
+                        .replace('True', 'true'))
+        # json_file.write(JsonPrettyPrinter().pformat(model).replace('None','null'))
+        # data = json.dumps(self.model_def)
+        # json_file.write(pformat(data).replace('\\\\n', '\\n').replace('\'', '').replace('(','').replace(')',''))
+        # json_file.write(pformat(data).replace('\'', '\"'))
+
+def load_model(model_path):
+    import json
+    with open(model_path, 'r', encoding='UTF-8') as file:
+        model_def = json.load(file)
+    return model_def
+
+def export_python_model(model_def, model, model_path):
+    package_name = __package__.split('.')[0]
+
+    # Get the symbolic tracer
+    with torch.no_grad():
+        trace = symbolic_trace(model)
+
+    ## Standard way to modify the graph
+    # # Replace all _tensor_constant variables with their constant values
+    # for node in trace.graph.nodes:
+    #     if node.op == 'get_attr' and node.target.startswith('_tensor_constant'):
+    #         constant_value = getattr(model, node.target).item()
+    #         with trace.graph.inserting_after(node):
+    #             new_node = trace.graph.create_node('call_function', torch.tensor, (constant_value,))
+    #         node.replace_all_uses_with(new_node)
+    #         trace.graph.erase_node(node)
+    #
+    # # Recompile the graph
+    # trace.recompile()
+    ## Standard way to modify the graph
+
+    attributes = sorted(set([line for line in trace.code.split() if 'self.' in line]))
+    saved_functions = []
+
+    with open(model_path, 'w') as file:
+        #file.write("import torch.nn as nn\n")
+        file.write("import torch\n\n")
+
+        for name in model_def['Functions'].keys():
+            if 'Fuzzify' in name:
+                if 'slicing' not in saved_functions:
+                    #file.write("@torch.fx.wrap\n")
+                    file.write(f"def {package_name}_fuzzify_slicing(res, i, x):\n")
+                    file.write("    res[:, :, i:i+1] = x\n\n")
+                    saved_functions.append('slicing')
+
+                function_name = model_def['Functions'][name]['names']
+                function_code = model_def['Functions'][name]['functions']
+                if isinstance(function_code, list):
+                    for i, fun_code in enumerate(function_code):
+                        if fun_code != 'Rectangular' and fun_code != 'Triangular':
+                            if function_name[i] not in saved_functions:
+                                fun_code = fun_code.replace(f'def {function_name[i]}',
+                                                            f'def {package_name}_fuzzify_{function_name[i]}')
+                                #file.write("@torch.fx.wrap\n")
+                                file.write(fun_code)
+                                file.write("\n")
+                                saved_functions.append(function_name[i])
+                else:
+                    if (function_name != 'Rectangular') and (function_name != 'Triangular') and (
+                            function_name not in saved_functions):
+                        function_code = function_code.replace(f'def {function_name}',
+                                                              f'def {package_name}_fuzzify_{function_name}')
+                        #file.write("@torch.fx.wrap\n")
+                        file.write(function_code)
+                        file.write("\n")
+                        saved_functions.append(function_name)
+
+
+            elif 'ParamFun' in name:
+                function_name = model_def['Functions'][name]['name']
+                # torch.fx.wrap(self.model_def['Functions'][name]['name'])
+                if function_name not in saved_functions:
+                    code = model_def['Functions'][name]['code']
+                    code = code.replace(f'def {function_name}', f'def {package_name}_parametricfunction_{function_name}')
+                    file.write(code)
+                    file.write("\n")
+                    saved_functions.append(function_name)
+
+        file.write("class TracerModel(torch.nn.Module):\n")
+        file.write("    def __init__(self):\n")
+        file.write("        super().__init__()\n")
+        file.write("        self.all_parameters = {}\n")
+        file.write("        self.all_constants = {}\n")
+        for attr in attributes:
+            if 'all_constant' in attr:
+                key = attr.split('.')[-1]
+                file.write(
+                    f"        self.all_constants[\"{key}\"] = torch.tensor({model.all_constants[key].tolist()})\n")
+                #file.write(f"        {attr} = torch.tensor({getattr(trace, attr.replace('self.', ''))})\n")
+            elif 'relation_forward' in attr:
+                key = attr.split('.')[2]
+                if 'Fir' in key or 'Linear' in key:
+                    if 'weights' in attr.split('.')[3]:
+                        param = model_def['Relations'][key][2]
+                        value = model.all_parameters[param] #.squeeze(0) if 'Linear' in key else model.all_parameters[param]
+                        file.write(
+                            f"        self.all_parameters[\"{param}\"] = torch.nn.Parameter(torch.tensor({value.tolist()}), requires_grad=True)\n")
+                    elif 'bias' in attr.split('.')[3]:
+                        param = model_def['Relations'][key][3]
+                        # value = model.all_parameters[param].data.squeeze(0) if 'Linear' in key else model.all_parameters[param].data
+                        # value = model.all_parameters[param].data
+                        file.write(
+                            f"        self.all_parameters[\"{param}\"] = torch.nn.Parameter(torch.tensor({model.all_parameters[param].tolist()}), requires_grad=True)\n")
+                    elif 'dropout' in attr.split('.')[3]:
+                        param = model_def['Relations'][key][4]
+                        file.write(f"        self.{key} = torch.nn.Dropout(p={param})\n")
+                    # param = model_def['Relations'][key][2] if 'weights' in attr.split('.')[3] else model_def['Relations'][key][3]
+                    # value = model.all_parameters[param].data.squeeze(0) if 'Linear' in key else model.all_parameters[param].data
+                    # file.write(f"        self.all_parameters[\"{param}\"] = torch.nn.Parameter(torch.{value}, requires_grad=True)\n")
+            elif 'all_parameters' in attr:
+                key = attr.split('.')[-1]
+                file.write(
+                    f"        self.all_parameters[\"{key}\"] = torch.nn.Parameter(torch.tensor({model.all_parameters[key].tolist()}), requires_grad=True)\n")
+            elif '_tensor_constant' in attr:
+                key = attr.split('.')[-1]
+                file.write(
+                    f"        {attr} = torch.tensor({getattr(model,key).item()})\n")
+
+        file.write("        self.all_parameters = torch.nn.ParameterDict(self.all_parameters)\n")
+        file.write("        self.all_constants = torch.nn.ParameterDict(self.all_constants)\n")
+        file.write("    def init_states(self, state_model, connect = {}, reset_states = False):\n")
+        file.write("        pass\n")
+        file.write("    def reset_connect_variables(self, connect, values = None, only = True):\n")
+        file.write("        pass\n")
+        file.write("    def reset_states(self, values = None, only = True):\n")
+        file.write("        pass\n")
+
+        for line in trace.code.split("\n")[len(saved_functions) + 1:]:
+            if 'self.relation_forward' in line:
+                if 'dropout' in line:
+                    attribute = line.split()[0]
+                    layer = attribute.split('_')[2].capitalize()
+                    old_line = f"self.relation_forward.{layer}.dropout"
+                    new_line = f"self.{layer}"
+                    file.write(f"    {line.replace(old_line, new_line)}\n")
+                else:
+                    attribute = line.split()[-1]
+                    relation = attribute.split('.')[2]
+                    relation_type = attribute.split('.')[3]
+                    param = model_def['Relations'][relation][2] if 'weights' == relation_type else \
+                    model_def['Relations'][relation][3]
+                    new_attribute = f'self.all_parameters.{param}'
+                    file.write(f"    {line.replace(attribute, new_attribute)}\n")
+            else:
+                file.write(f"    {line}\n")
+
+def export_pythononnx_model(input_order, outputs_order, model_path, model_onnx_path):
+    # Define the mapping dictionary input
+    trace_mapping_input = {}
+    forward = 'def forward(self,'
+    for i, key in enumerate(input_order):
+        value = f'kwargs[\'{key}\']'
+        trace_mapping_input[value] = key
+        forward = forward + f' {key}' + (',' if i < len(input_order) - 1 else '')
+    forward = forward + '):'
+    # Define the mapping dictionary output
+    outputs = '        return ('
+    for i, key in enumerate(outputs_order):
+        outputs += f'outputs[0][\'{key}\']' + (',' if i < len(outputs_order) - 1 else ')')
+
+    # Open and read the file
+    with open(model_path, 'r') as file:
+        file_content = file.read()
+    # Replace the forward header
+    file_content = file_content.replace('def forward(self, kwargs):', forward)
+    # Perform the substitution
+    for key, value in trace_mapping_input.items():
+        file_content = file_content.replace(key, value)
+    # Write the modified content back to a new file
+    # Replace the return statement
+    # Trova l'ultima occorrenza di 'return'
+    last_return_index = file_content.rfind('return')
+    # Se 'return' è trovato, sostituiscilo con 'outputs ='
+    if last_return_index != -1:
+        file_content = file_content[:last_return_index] + 'outputs =' + file_content[last_return_index + len('return'):]
+    file_content += outputs
+    with open(model_onnx_path, 'w') as file:
+        file.write(file_content)
+
+def import_python_model(name, model_folder):
+    sys.path.insert(0, model_folder)
+    module_name = os.path.basename(name)
+    if module_name in sys.modules:
+        # Reload the module if it is already loaded
+        module = importlib.reload(sys.modules[module_name])
+    else:
+        # Import the module if it is not loaded
+        module = importlib.import_module(module_name)
+    return module.TracerModel()
+
+def export_onnx_model(model_def, model, input_order, output_order, model_path):
+    dummy_inputs = []
+    input_names = []
+    dynamic_axes = {}
+    for key in input_order:
+        input_names.append(key)
+        window_size = model_def['Inputs'][key]['ntot']
+        dummy_inputs.append(torch.randn(size=(1, window_size, model_def['Inputs'][key]['dim'])))
+        dynamic_axes[key] = {0: 'batch_size'}
+    output_names = output_order
+    dummy_inputs = tuple(dummy_inputs)
+
+    torch.onnx.export(
+        model,                            # The model to be exported
+        dummy_inputs,                          # Tuple of inputs to match the forward signature
+        model_path,                             # File path to save the ONNX model
+        export_params = True,                    # Store the trained parameters in the model file
+        opset_version = 12,                      # ONNX version to export to (you can use 11 or higher)
+        do_constant_folding=True,              # Optimize constant folding for inference
+        input_names = input_names,               # Name each input as they will appear in ONNX
+        output_names = output_names,             # Name the output
+        dynamic_axes = dynamic_axes
+    )
+
+def import_onnx_model(name, model_folder):
+    import onnxruntime as ort
+    model_path = os.path.join(model_folder, name + '.onnx')
+    return ort.InferenceSession(model_path)
+
+    # import numpy as np
+    # ort_sess = ort.InferenceSession("./TODO/mauro/net.onnx")
+    # prova = {'Vo': np.array([[20.0]], dtype=np.float32),
+    #          'VL': np.array([[[50.0], [50.0], [50.2], [30.1], [15.0]]], dtype=np.float32)}
+    # # ortvalue = ort.OrtValue.ortvalue_from_numpy(prova)
+    # outputs = ort_sess.run(None, prova)
+    # # Print Result
+    # print(outputs)
+    #
+    # session = onnxruntime.InferenceSession(onnx_path)
+    # # Get input and output names
+    # input_names = [item.name for item in session.get_inputs()]
+    # output_names = [item.name for item in session.get_outputs()]
+    # # input_name = session.get_inputs()#[0].name
+    # # output_name = session.get_outputs()[0].name
+    #
+    # print('input_name: ', input_names)
+    # print('output_name: ', output_names)
+    #
+    # # Run inference
+    # result = session.run([output_names], {input_names: data})
+    # # Print the result
+    # print(result)
+    #
+    # import onnx
+

nnodely/exporter/exporter.py

@@ -0,0 +1,45 @@
+import os
+
+from datetime import datetime
+
+from nnodely.visualizer import  Visualizer
+
+class Exporter():
+
+    def __init__(self, workspace = None, visualizer = None, save_history = False):
+        # Export parameters
+        if workspace is not None:
+            self.workspace = workspace
+            os.makedirs(self.workspace, exist_ok=True)
+            if save_history:
+                self.folder = datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
+                self.workspace_folder = os.path.join(self.workspace, self.folder)
+            else:
+                self.workspace_folder = self.workspace
+            os.makedirs(self.workspace_folder, exist_ok=True)
+
+        if visualizer is not None:
+            self.visualizer = visualizer
+        else:
+            self.visualizer = Visualizer()
+
+    def saveTorchModel(self, model, name = 'net', model_folder = None):
+        pass
+
+    def loadTorchModel(self, name = 'net', model_folder = None):
+        pass
+
+    def saveModel(self, model, name = 'net', model_folder = None):
+        pass
+
+    def loadModel(self, name = 'net', model_folder = None):
+        pass
+
+    def exportPythonModel(self, name = 'net', model_folder = None):
+        pass
+
+    def importPythonModel(self, name = 'net', model_folder = None):
+        pass
+
+    def exportReport(self, name = 'net', model_folder = None):
+        pass

nnodely/exporter/reporter.py

@@ -0,0 +1,48 @@
+import io
+
+import matplotlib.pyplot as plt
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+from reportlab.lib.utils import ImageReader
+
+from mplplots import plots
+
+
+class Reporter:
+    def __init__(self, n4m):
+        self.n4m = n4m
+
+    def exportReport(self, report_path):
+        c = canvas.Canvas(report_path, pagesize=letter)
+        width, height = letter
+
+        for key, value in self.n4m.model_def['Minimizers'].items():
+            fig = plt.figure(figsize=(10, 5))
+            ax = fig.add_subplot(111)
+            if 'val' in self.n4m.training[key]:
+                plots.plot_training(ax, f"Training Loss of {key}", key, self.n4m.training[key]['train'], self.n4m.training[key]['val'])
+            else:
+                plots.plot_training(ax, f"Training Loss of {key}", key, self.n4m.training[key]['train'])
+            training = io.BytesIO()
+            plt.savefig(training, format='png')
+            training.seek(0)
+            plt.close()
+            c.drawString(100, height - 30, f"Training Loss of {key}")
+            c.drawImage(ImageReader(training), 50, height - 290, width=500, height=250)
+            c.showPage()
+
+        for key in self.n4m.model_def['Minimizers'].keys():
+            c.drawString(100, height - 30, f"Prediction of {key}")
+            for ind, name_data in enumerate(self.n4m.prediction.keys()):
+                fig = plt.figure(figsize=(10, 5))
+                ax = fig.add_subplot(111)
+                plots.plot_results(ax, name_data, key, self.n4m.prediction[name_data][key]['A'],
+                               self.n4m.prediction[name_data][key]['B'], self.n4m.model_def['Info']["SampleTime"])
+                # Add a text box with correlation coefficient
+                results = io.BytesIO()
+                plt.savefig(results, format='png')
+                results.seek(0)
+                plt.close()
+                c.drawImage(ImageReader(results), 50, height - 290 - 245*ind, width=500, height=250)
+            c.showPage()
+        c.save()

nnodely/exporter/standardexporter.py

@@ -0,0 +1,108 @@
+import os, torch
+
+from nnodely.exporter.exporter import Exporter
+from nnodely.exporter.reporter import Reporter
+from nnodely.exporter.export import save_model, load_model, export_python_model, export_pythononnx_model, export_onnx_model, import_python_model, import_onnx_model
+from nnodely.utils import check
+
+class StandardExporter(Exporter):
+    def __init__(self, workspace=None, visualizer=None, save_history=False):
+        super().__init__(workspace, visualizer, save_history)
+
+    def getWorkspace(self):
+        return self.workspace_folder
+
+    def saveTorchModel(self, model, name = 'net', model_folder = None):
+        file_name = name + ".pt"
+        model_path = os.path.join(self.workspace_folder, file_name) if model_folder is None else os.path.join(model_folder,file_name)
+        torch.save(model.state_dict(), model_path)
+        self.visualizer.saveModel('Torch Model', model_path)
+
+    def loadTorchModel(self, model, name = 'net', model_folder = None): #TODO, model = None):
+        file_name = name + ".pt"
+        model_path = os.path.join(self.workspace_folder, file_name) if model_folder is None else os.path.join(model_folder,file_name)
+        model.load_state_dict(torch.load(model_path))
+        self.visualizer.loadModel('Torch Model',model_path)
+
+    def saveModel(self, model_def, name = 'net', model_folder = None):
+        # Combine the folder path and file name to form the complete file path
+        model_folder = self.workspace_folder if model_folder is None else model_folder
+        # Specify the JSON file name
+        file_name = name + ".json"
+        # Combine the folder path and file name to form the complete file path
+        model_path = os.path.join(model_folder, file_name)
+        save_model(model_def, model_path)
+        self.visualizer.saveModel('JSON Model', model_path)
+
+    def loadModel(self, name = 'net', model_folder = None):
+        # Combine the folder path and file name to form the complete file path
+        model_folder = self.workspace_folder if model_folder is None else model_folder
+        model_def = None
+        try:
+            file_name = name + ".json"
+            model_path = os.path.join(model_folder, file_name)
+            model_def = load_model(model_path)
+            self.visualizer.loadModel('JSON Model', model_path)
+        except Exception as e:
+            check(False, RuntimeError, f"The file {model_path} it is not found or not conformed.\n Error: {e}")
+        return model_def
+
+    def exportPythonModel(self, model_def, model, name = 'net', model_folder = None):
+        file_name = name + ".py"
+        model_path = os.path.join(self.workspace_folder, file_name) if model_folder is None else os.path.join(model_folder, file_name)
+        ## Export to python file
+        export_python_model(model_def.json, model, model_path)
+        self.visualizer.exportModel('Python Torch Model', model_path)
+
+    def importPythonModel(self, name = 'net', model_folder = None):
+        try:
+            model_folder = self.workspace_folder if model_folder is None else model_folder
+            model = import_python_model(name, model_folder)
+            self.visualizer.importModel('Python Torch Model', os.path.join(model_folder,name+'.py'))
+        except Exception as e:
+            model = None
+            check(False, RuntimeError, f"The module {name} it is not found in the folder {model_folder}.\nError: {e}")
+        return model
+
+    def exportONNX(self, model_def, model, inputs_order, outputs_order, name = 'net', model_folder = None, ):
+        check(set(inputs_order) == set(model_def['Inputs'].keys()), ValueError,
+              f'The inputs are not the same as the model inputs ({model_def["Inputs"].keys()}).')
+        check(set(outputs_order) == set(model_def['Outputs'].keys()), ValueError,
+              f'The outputs are not the same as the model outputs ({model_def["Outputs"].keys()}).')
+        file_name = name + ".py"
+        model_folder = self.workspace_folder if model_folder is None else model_folder
+        model_folder = os.path.join(model_folder, 'onnx')
+        os.makedirs(model_folder, exist_ok=True)
+        model_path = os.path.join(model_folder, file_name)
+        onnx_python_model_path = model_path.replace('.py', '_onnx.py')
+        onnx_model_path = model_path.replace('.py', '.onnx')
+        ## Export to python file (onnx compatible)
+        export_python_model(model_def, model, model_path)
+        self.visualizer.exportModel('Python Torch Model', model_path)
+        export_pythononnx_model(inputs_order, outputs_order, model_path, onnx_python_model_path)
+        self.visualizer.exportModel('Python Onnx Torch Model', onnx_python_model_path)
+        ## Export to onnx file (onnx compatible)
+        model = import_python_model(file_name.replace('.py', '_onnx'), model_folder)
+        export_onnx_model(model_def, model, inputs_order, outputs_order,  onnx_model_path)
+        self.visualizer.exportModel('Onnx Model', onnx_model_path)
+
+    def importONNX(self, name = 'net', model_folder = None):
+        try:
+            model_folder = self.workspace_folder if model_folder is None else model_folder
+            model = import_onnx_model(name, model_folder)
+            self.visualizer.importModel('Onnx Model', os.path.join(model_folder,name+'.py'))
+        except Exception as e:
+            log.warning(f"The module {name} it is not found in the folder {model_folder}.\nError: {e}")
+        return model
+
+    def exportReport(self, n4m, name = 'net', model_folder = None):
+        # Combine the folder path and file name to form the complete file path
+        model_folder = self.workspace_folder if model_folder is None else model_folder
+        # Specify the JSON file name
+        file_name = name + ".pdf"
+        # Combine the folder path and file name to form the complete file path
+        report_path = os.path.join(model_folder, file_name)
+        reporter = Reporter(n4m)
+        reporter.exportReport(report_path)
+        self.visualizer.exportReport('Training Results', report_path)
+

nnodely/fir.py

@@ -0,0 +1,150 @@
+import copy, inspect, textwrap, torch
+
+import torch.nn as nn
+
+from collections.abc import Callable
+
+from nnodely.relation import NeuObj, Stream, AutoToStream
+from nnodely.utils import check, merge, enforce_types
+from nnodely.model import Model
+from nnodely.parameter import Parameter
+from nnodely.input import Input
+
+fir_relation_name = 'Fir'
+
+class Fir(NeuObj, AutoToStream):
+    @enforce_types
+    def __init__(self, output_dimension:int|None = None,
+                 parameter_init:Callable|None = None,
+                 parameter_init_params:dict|None = None,
+                 bias_init:Callable|None = None,
+                 bias_init_params:dict|None = None,
+                 parameter:Parameter|str|None = None,
+                 bias:bool|str|Parameter|None = None,
+                 dropout:int|float = 0):
+
+        self.relation_name = fir_relation_name
+        self.parameter_init = parameter_init
+        self.parameter_init_params = parameter_init_params
+        self.parameter = parameter
+        self.bias_init = bias_init
+        self.bias_init_params = bias_init_params
+        self.bias = bias
+        self.pname = None
+        self.bname = None
+        self.dropout = dropout
+        super().__init__('P' + fir_relation_name + str(NeuObj.count))
+
+        if parameter is None:
+            self.output_dimension = 1 if output_dimension is None else output_dimension
+            self.pname = self.name + 'p'
+            self.json['Parameters'][self.pname] = {'dim': self.output_dimension}
+        elif type(parameter) is str:
+            self.output_dimension = 1 if output_dimension is None else output_dimension
+            self.pname = parameter
+            self.json['Parameters'][self.pname] = {'dim': self.output_dimension}
+        else:
+            check(type(parameter) is Parameter, TypeError, 'Input parameter must be of type Parameter')
+            check(len(parameter.dim) == 2,ValueError,f"The values of the parameters must be have two dimensions (tw/sample_rate or sw,output_dimension).")
+            if output_dimension is None:
+                check(type(parameter.dim['dim']) is int, TypeError, 'Dimension of the parameter must be an integer for the Fir')
+                self.output_dimension = parameter.dim['dim']
+            else:
+                self.output_dimension = output_dimension
+                check(parameter.dim['dim'] == self.output_dimension, ValueError, 'output_dimension must be equal to dim of the Parameter')
+            self.pname = parameter.name
+            self.json['Parameters'][self.pname] = copy.deepcopy(parameter.json['Parameters'][parameter.name])
+
+        if bias is not None:
+            check(type(bias) is Parameter or type(bias) is bool or type(bias) is str, TypeError, 'The "bias" must be of type Parameter, bool or str.')
+            if type(bias) is Parameter:
+                check(type(bias.dim['dim']) is int, ValueError, 'The "bias" dimensions must be an integer.')
+                if output_dimension is not None:
+                    check(bias.dim['dim'] == output_dimension, ValueError,
+                          'output_dimension must be equal to the dim of the "bias".')
+                self.bname = bias.name
+                self.json['Parameters'][bias.name] = copy.deepcopy(bias.json['Parameters'][bias.name])
+            elif type(bias) is str:
+                self.bname = bias
+                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 = fir_relation_name + str(Stream.count)
+        check(type(obj) is not Input, TypeError,
+              f"The type of {obj.name} is Input not a Stream create a Stream using the functions: tw, sw, z, last, next.")
+        check(type(obj) is Stream, TypeError,
+              f"The type of {obj} is {type(obj)} and is not supported for Fir operation.")
+        check('dim' in obj.dim and obj.dim['dim'] == 1, ValueError, f"Input dimension is {obj.dim['dim']} and not scalar")
+        window = 'tw' if 'tw' in obj.dim else ('sw' if 'sw' in obj.dim else None)
+        if window:
+            if type(self.parameter) is Parameter:
+                check(window in self.json['Parameters'][self.pname],
+                      KeyError,
+                      f"The window \'{window}\' of the input is not in the parameter")
+                check(self.json['Parameters'][self.pname][window] == obj.dim[window],
+                      ValueError,
+                      f"The window \'{window}\' of the input must be the same of the parameter")
+            else:
+                self.json['Parameters'][self.pname][window] = obj.dim[window]
+        else:
+            if type(self.parameter) is Parameter:
+                cond = 'sw' not in self.json['Parameters'][self.pname] and 'tw' not in self.json['Parameters'][self.nampe]
+                check(cond, KeyError,'The parameter have a time window and the input no')
+
+        if self.parameter_init is not None:
+            check('values' not in self.json['Parameters'][self.pname], ValueError, f"The parameter {self.pname} is already initialized.")
+            check(inspect.isfunction(self.parameter_init), ValueError,
+                  f"The parameter_init parameter must be a function.")
+            code = textwrap.dedent(inspect.getsource(self.parameter_init)).replace('\"', '\'')
+            self.json['Parameters'][self.pname]['init_fun'] = {'code' : code, 'name' : self.parameter_init.__name__}
+            if self.parameter_init_params is not None:
+                self.json['Parameters'][self.pname]['init_fun']['params'] = self.parameter_init_params
+
+        if self.bias_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.bias_init), ValueError,
+                  f"The bias_init parameter must be a function.")
+            code = textwrap.dedent(inspect.getsource(self.bias_init)).replace('\"', '\'')
+            self.json['Parameters'][self.bname]['init_fun'] = { 'code' : code, 'name' : self.bias_init.__name__ }
+            if self.bias_init_params is not None:
+                self.json['Parameters'][self.bname]['init_fun']['params'] = self.bias_init_params
+
+        stream_json = merge(self.json,obj.json)
+        stream_json['Relations'][stream_name] = [fir_relation_name, [obj.name], self.pname, self.bname, self.dropout]
+        return Stream(stream_name, stream_json,{'dim':self.output_dimension, 'sw': 1})
+
+
+class Fir_Layer(nn.Module):
+    def __init__(self, weights, bias=None, dropout=0):
+        super(Fir_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, 1]
+        batch_size = x.size(0)
+        output_features = self.weights.size(1)
+        # Remove the last dimension (1) to make x shape [batch, window]
+        x = x.squeeze(-1)
+        # Perform the linear transformation: y = xW^T
+        x = torch.matmul(x, self.weights)
+        # Reshape y to be [batch, 1, output_features]
+        x = x.view(batch_size, 1, output_features)
+        # Add bias if necessary
+        if self.bias is not None:
+            x += self.bias  # Add bias
+        # Add dropout if necessary
+        if self.dropout is not None:
+            x = self.dropout(x)
+        return x
+
+def createFir(self, *inputs):
+    return Fir_Layer(weights=inputs[0], bias=inputs[1], dropout=inputs[2])
+
+setattr(Model, fir_relation_name, createFir)