pyanfis 0.1__tar.gz

pyanfis-0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyanfis-0.1/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.1
+Name: pyanfis
+Version: 0.1
+Summary: An pytorch-based package to use ANFIS for AI
+Author-email: Vicente Feced Mas <vicente.feced.mas@gmail.com>
+Project-URL: Homepage, https://github.com/VicenteFecedMas/pyanfis
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# pyANFIS
+
+Welcome to pyANFIS! here you will be able to find a framework that will allow you to use **Fuzzy Logic** with usual pytorch layers.
+This framework is based on [Jang's](https://www.researchgate.net/publication/3113825_ANFIS_Adaptive-Network-based_Fuzzy_Inference_System?enrichId=rgreq-15825cac70a3ae795992310484420cab-XXX&enrichSource=Y292ZXJQYWdlOzMxMTM4MjU7QVM6MTU5MDc1MDY1MTQ3MzkyQDE0MTQ5Mzc4NTk3MzI%3D&el=1_x_2&_esc=publicationCoverPdf) original paper, although it is going to implement several more things (listed below).
+
+## 2024 Roadmap
+
+- [x] Jang's Original ANFIS.
+- [ ] Create documentation for each class and function.
+- [ ] Create an installation tutorial.
+- [x] Consequent parameters can be estimated using backpropagation.
+- [X] Type 1 (Tsukamoto) consequents can be used.
+- [ ] Type 2 (Lee) consequents can be used.
+- [ ] Functions inside a universe can merge when 2 functions cover a similar area.
+- [ ] Automatically not use rules when they are not relevant.
+- [X] Display what rules have been fired with a certain data.
+- [ ] Create a method to substitute a trained ANFIS with a surface like in [Matlab](https://www.mathworks.com/help/fuzzy/genfis.html#d126e35957).

pyanfis-0.1/README.md

@@ -0,0 +1,17 @@
+# pyANFIS
+
+Welcome to pyANFIS! here you will be able to find a framework that will allow you to use **Fuzzy Logic** with usual pytorch layers.
+This framework is based on [Jang's](https://www.researchgate.net/publication/3113825_ANFIS_Adaptive-Network-based_Fuzzy_Inference_System?enrichId=rgreq-15825cac70a3ae795992310484420cab-XXX&enrichSource=Y292ZXJQYWdlOzMxMTM4MjU7QVM6MTU5MDc1MDY1MTQ3MzkyQDE0MTQ5Mzc4NTk3MzI%3D&el=1_x_2&_esc=publicationCoverPdf) original paper, although it is going to implement several more things (listed below).
+
+## 2024 Roadmap
+
+- [x] Jang's Original ANFIS.
+- [ ] Create documentation for each class and function.
+- [ ] Create an installation tutorial.
+- [x] Consequent parameters can be estimated using backpropagation.
+- [X] Type 1 (Tsukamoto) consequents can be used.
+- [ ] Type 2 (Lee) consequents can be used.
+- [ ] Functions inside a universe can merge when 2 functions cover a similar area.
+- [ ] Automatically not use rules when they are not relevant.
+- [X] Display what rules have been fired with a certain data.
+- [ ] Create a method to substitute a trained ANFIS with a surface like in [Matlab](https://www.mathworks.com/help/fuzzy/genfis.html#d126e35957).

pyanfis-0.1/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "pyanfis"
+version = "0.1"
+authors = [
+  { name="Vicente Feced Mas", email="vicente.feced.mas@gmail.com" },
+]
+description = "An pytorch-based package to use ANFIS for AI"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/VicenteFecedMas/pyanfis"

pyanfis-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyanfis-0.1/src/pyanfis/__init__.py

@@ -0,0 +1,3 @@
+from main import ANFIS
+
+__all__ = ["ANFIS"]

pyanfis-0.1/src/pyanfis/algorithms/LSTSQ.py

@@ -0,0 +1,42 @@
+import torch
+
+# TO BE FINISHED
+class LSTSQ(torch.nn.Module):
+    """
+    Computes the vector x that approximately solves the equation a @ x = b
+
+    Attributes
+    ----------
+    n_vars : float
+        length of the "x" vector
+    shoulder : float
+        shoulder of the linear S function
+
+    Returns
+    -------
+    torch.tensor
+        a tensor of equal size to the input tensor
+    """
+    def __init__(self, n_vars, alpha=0.001, driver='gels') -> None:
+        super().__init__()
+
+        self.theta = torch.zeros((n_vars, 1))
+        self.alpha = alpha
+        self.driver = driver
+
+        self.step = -1
+        self.theta_dict = {}
+        
+    def forward(self, x, y=None):
+        if self.training: 
+            for _ in range(x.size(0)):
+                self.step += 1
+                theta = torch.linalg.lstsq(x, y, driver=self.driver).solution
+                
+                if theta.dim() > 2:
+                    theta = theta.mean(dim=0)
+                
+                self.theta = self.theta + theta * self.alpha
+                self.theta_dict[self.step] = self.theta
+
+        #return self.theta_dict[self.step]

pyanfis-0.1/src/pyanfis/algorithms/RLSE.py

@@ -0,0 +1,37 @@
+import torch
+
+class RLSE(torch.nn.Module):
+    """
+    Computes the vector x that approximately solves the equation a @ x = b
+    using a recursive approach
+
+    Attributes
+    ----------
+    n_vars : float
+        length of the "x" vector
+    initial_gamma : float
+        big number to initialise the "S" matrix
+
+    Returns
+    -------
+    torch.tensor
+        a tensor of equal size to the input tensor
+    """
+    def __init__(self, n_vars, initial_gamma=1000.):
+        super().__init__()
+        self.S = torch.eye(n_vars) * initial_gamma
+        self.theta = torch.zeros((n_vars, 1))
+        self.gamma = 1000
+
+    def forward(self, A, B,):
+        batch, row, _ = A.size()
+
+        for ba in range(batch):
+            for i in range(row):
+                a = A[ba, i, :].view(1, -1)  # Reshape a to match the dimensions for matrix operations
+                b = B[ba, i].unsqueeze(0)
+                
+                self.S = self.S - (torch.matmul(torch.matmul(torch.matmul(self.S, a.T), a), self.S)) / (1 + torch.matmul(torch.matmul(a, self.S), a.T))
+                self.theta =  self.theta + torch.matmul(self.S, torch.matmul(a.T, (b - torch.matmul(a, self.theta))))
+
+        #return self.theta

pyanfis-0.1/src/pyanfis/algorithms/__init__.py

@@ -0,0 +1,4 @@
+from .LSTSQ import LSTSQ
+from .RLSE import RLSE
+
+__all__ = ["LSTSQ", "RLSE"]

pyanfis-0.1/src/pyanfis/anfis.py

@@ -0,0 +1,416 @@
+import torch
+import math
+
+from antecedents import Antecedents
+from rules import Rules
+from consequents import Consequents
+
+class ANFIS(torch.nn.Module):
+    def __init__(self, num_inputs:int, num_outputs:int, system_type:str="Takagi-Sugeno", consequents_parameters_update:str = 'backward',):
+        super().__init__()
+        self.num_inputs = num_inputs
+        self.num_outputs = num_outputs
+        self.system_type = system_type
+
+        self.params_update = consequents_parameters_update
+
+        self.antecedents = Antecedents(num_inputs)
+        self.rules = Rules()
+        self.normalisation = torch.nn.functional.normalize
+        self.consequents = Consequents(num_inputs=num_inputs, num_outputs=num_outputs, parameters_update=self.params_update, system_type=self.system_type)
+
+        self.active_rules = None
+        self.active_rules_consequents = None
+        self.rules_relevancy = None
+        self.erase_irrelevant_rules = None
+
+
+        # The next to are pointers
+        self.inputs = self.antecedents.universes # To make renaming easier
+        self.outputs = self.consequents.consequents.universes # To make renaming easier
+
+        self.firing_strength = None
+
+    def _create_binari_rule_from_indexes(self, is_pairs, rule_index):
+        rule_list = []
+        for universe_name, function_name in is_pairs:
+            try:
+                index = rule_index.index(f"{universe_name} {function_name}")
+                rule_list.append(index)
+            except ValueError:
+                if universe_name in [i.name for i in self.inputs.values()]:
+                    raise ValueError(f"Function {function_name} not found in {universe_name}")
+                else:
+                    raise ValueError(f"Universe {universe_name} not found in universe list")
+
+        rule_tensor = torch.zeros(len(rule_index))
+        rule_tensor[rule_list] = 1
+        return rule_tensor.unsqueeze(0)
+
+    def _parse_rule(self, rule):
+        if self.system_type == "Takagi-Sugeno" and "then" in rule:
+            raise ValueError(f"Takagi-Sugeno systems only reference to the antecedent: 'If VAR1 is VALUE1 | If VAR2 is VALUE2 and VAR3 is VALUE3 | ...' the existance of a 'then' in the sencente does not make sense")
+
+        rule = rule.split()
+        antecedents_rule_index = [f"{item.name} {subkey}" for key, item in self.antecedents.universes.items() for subkey, _ in item.functions.items()]
+
+        is_word_pairs = [(rule[i-1], rule[i+1]) for i, word in enumerate(rule) if word == 'is']
+
+        if self.system_type != "Takagi-Sugeno":
+            consequets_rule_index = [f"{item.name} {subkey}" for key, item in self.consequents.consequents.universes.items() for subkey, _ in item.functions.items()]
+            
+            antecedent_rules = is_word_pairs[:-1]
+            consequent_rules = is_word_pairs[-1:]
+            then_word_index = [i for i, word in enumerate(rule) if word == 'then']
+
+            if rule[0] != "If" and "is" not in rule and "then" not in rule and len(then_word_index) != 1 and any(then_word_index[0] > num for num in is_word_pairs):
+                raise ValueError(f"Every string containing a rule must be formated as: 'If VAR1 is VALUE1 and ... then VAR2 is VALUE2'")
+            
+            antecedents_rules = self._create_binari_rule_from_indexes(antecedent_rules, antecedents_rule_index)
+            consequent_rules = self._create_binari_rule_from_indexes(consequent_rules, consequets_rule_index)
+
+            return antecedents_rules, consequent_rules
+        else:
+            antecedents_rules = self._create_binari_rule_from_indexes(is_word_pairs, antecedents_rule_index)
+            return antecedents_rules
+
+    def create_rules_base(self, rules):
+        if not isinstance(rules, torch.Tensor) and not isinstance(rules, list):
+            raise ValueError(f"The introduced rules must be either a torch.Tensor or a list")
+        
+        if self.system_type == "Takagi-Sugeno":
+            for rule in rules:
+                antecedent_part = self._parse_rule(rule)
+                if self.active_rules is None:
+                    self.active_rules = antecedent_part
+                else:
+                    self.active_rules = torch.cat((self.active_rules, antecedent_part), dim=0)
+
+            for algorithm in self.outputs.values():
+                algorithm.generate_theta(self.active_rules.size(0) * (self.num_inputs + 1))
+                
+        elif self.system_type == "Tsukamoto":
+            for rule in rules:
+                antecedent_part, consequent_part = self._parse_rule(rule)
+                if self.active_rules is None and self.active_rules_consequents is None:
+                    self.active_rules = antecedent_part
+                    self.active_rules_consequents = consequent_part
+                elif self.active_rules is not None and self.active_rules_consequents is not None:
+                    self.active_rules = torch.cat((self.active_rules, antecedent_part), dim=0)
+                    self.active_rules_consequents = torch.cat((self.active_rules_consequents, consequent_part), dim=0)
+                else:
+                    raise ValueError(f"Got {len(self.active_rules)} antecedent statements and {len(self.active_rules_consequents)} consequent statements")
+
+
+        elif self.system_type == "Lee":
+            pass
+
+        self.rules.active_antecedents_rules = self.active_rules
+
+    def parameters(self):
+        
+        parameters = []
+
+        # Antecedents parameters
+        for universe in self.antecedents.universes.values():
+            for function in universe.functions.values():
+                for param in function.parameters():
+                    parameters.append(param)
+
+        # Consequent parameters
+        if self.params_update == "backward":
+            for universe in self.consequents.consequents.universes.values():
+                if self.system_type == "Takagi-Sugeno":
+                    parameters.append(universe.theta)
+                else:
+                    for function in universe.functions.values():
+                        for param in function.parameters():
+                            parameters.append(param)
+        #print([round(param.data.item(), 2) for param in parameters])
+        return parameters
+
+    def smart_concat(self, tensor_list):
+        dimensions = tensor_list[0].dim()
+        shape = tensor_list[0].shape
+
+        tensor_list = torch.stack(tensor_list, dim=-1)
+        if dimensions == 0:
+            return tensor_list.view(1,1,-1)
+        elif dimensions == 1:
+            return tensor_list.view(1,shape[0],-1)
+        elif dimensions == 2:
+            return tensor_list.view(shape[0], shape[1],-1)
+        elif dimensions == 3:
+            return tensor_list.view(shape[0], shape[1] * shape[2] , -1) 
+        
+    def _prepare_input_matrices(self, **kwargs):
+        if len(kwargs) != len(self.antecedents.universes.items()):
+            
+        antecedents_tensor = []
+        for universe in self.antecedents.universes.values():
+            if universe.name not in list(kwargs.keys()):
+                raise ValueError(f"Universe name {universe.name} not present in input variables {list(kwargs.keys())}")
+            antecedents_tensor.append(kwargs[universe.name])
+            del kwargs[universe.name]
+        
+        if not kwargs and self.system_type == "Takagi-Sugeno" and self.training is True and self.params_update != "backward":
+            raise ValueError(f"If you use a {self.system_type} and do not update the system using backpropagation you need to feed the output values to train the system.")
+        elif not kwargs:
+            return self.smart_concat(antecedents_tensor), None
+         
+        consequents_tensor = []
+        for universe in self.consequents.consequents.universes.values():
+            if universe.name not in list(kwargs.keys()):
+                raise ValueError(f"Universe name {universe.name} not present in input variables {list(kwargs.keys())}")
+
+            consequents_tensor.append(kwargs[universe.name])
+            del kwargs[universe.name]
+
+        return self.smart_concat(antecedents_tensor), self.smart_concat(consequents_tensor)
+
+    def get_fired_rules(self, **kwargs):
+        self.training = False
+        X, _ = self._prepare_input_matrices(**kwargs)
+        if X.size(1) != 1:
+            raise ValueError(f"Only one row can be evaluated at a time")
+
+        f = self.antecedents(X)
+
+        self.rules.active_rules = self.active_rules
+        f, _ = self.rules(f) # col_indexes = rule place on each col
+        
+        f = self.normalisation(f, dim=2, p=1)
+
+        return {str(key.to(torch.int16).tolist()): float(strength) for key, strength in zip(self.active_rules,f[0, 0, :])}
+    
+    def state_dict(self):
+        params = {}
+
+        # Main
+        params["main"] = {}
+        params["main"]["num_inputs"] = self.num_inputs
+        params["main"]["num_outputs"] = self.num_outputs
+        params["main"]["system_type"] = self.system_type
+        params["main"]["params_update"] = self.params_update
+        params["main"]["active_rules"] = self.active_rules
+        params["main"]["rules_relevancy"] = self.rules_relevancy
+        params["main"]["active_rules_consequents"] = self.active_rules_consequents
+        params["main"]["erase_irrelevant_rules"] = self.erase_irrelevant_rules
+        params["main"]["firing_strength"] = self.firing_strength
+
+        # Antecedents
+        params["Antecedents"] = {}
+        params["Antecedents"]["universes"] = {}
+
+
+        # Each universe in the antecedents
+        for universe_name, universe in self.inputs.items():
+            params["Antecedents"]["universes"][universe_name] = {}
+            params["Antecedents"]["universes"][universe_name]["name"] = universe.name
+            params["Antecedents"]["universes"][universe_name]["min"] = universe.min
+            params["Antecedents"]["universes"][universe_name]["max"] = universe.max
+            params["Antecedents"]["universes"][universe_name]["merge"] = universe.merge
+            params["Antecedents"]["universes"][universe_name]["heaviside"] = universe.heaviside
+            params["Antecedents"]["universes"][universe_name]["functions"] = {}
+
+            for function_name, function in universe.functions.items():
+                params["Antecedents"]["universes"][universe_name]["functions"][function_name] = {}
+                params["Antecedents"]["universes"][universe_name]["functions"][function_name]["type"] = str(function)[:-2]
+                params["Antecedents"]["universes"][universe_name]["functions"][function_name]["parameters"] = {}
+                for name, value in vars(function)['_parameters'].items():
+                    params["Antecedents"]["universes"][universe_name]["functions"][function_name]["parameters"][name] = value
+
+        # Consequents
+        params["Consequents"] = {}
+        params["Consequents"]["universes"] = {}
+
+        for universe_name, universe in self.outputs.items():
+            params["Consequents"]["universes"][universe_name] = {}
+            params["Consequents"]["universes"][universe_name]["name"] = universe.name
+            params["Consequents"]["universes"][universe_name]["min"] = universe.min
+            params["Consequents"]["universes"][universe_name]["max"] = universe.max
+            params["Consequents"]["universes"][universe_name]["merge"] = universe.merge
+            params["Consequents"]["universes"][universe_name]["heaviside"] = universe.heaviside
+
+            # Takagi Sugeno
+            if self.system_type == "Takagi-Sugeno":
+                params["Consequents"]["universes"][universe_name][universe.algorithm_name] = {}
+                params["Consequents"]["universes"][universe_name][universe.algorithm_name]["name"] = universe.name
+                params["Consequents"]["universes"][universe_name][universe.algorithm_name]["theta"] = universe.theta
+                params["Consequents"]["universes"][universe_name][universe.algorithm_name]["algorithm"] = universe.algorithm
+                
+
+            # Tsukamoto and Lee
+            else:
+                params["Consequents"]["universes"][universe_name]["functions"] = {}
+                for function_name, function in universe.functions.items():
+                    params["Consequents"]["universes"][universe_name]["functions"][function_name] = {}
+                    params["Consequents"]["universes"][universe_name]["functions"][function_name]["type"] = str(function)[:-2]
+                    params["Consequents"]["universes"][universe_name]["functions"][function_name]["parameters"] = {}
+                    for name, value in vars(function)['_parameters'].items():
+                        params["Consequents"]["universes"][universe_name]["functions"][function_name]["parameters"][name] = value
+        return params
+    
+    def load_state_dict(self, state_dict):
+        # Load Main
+        if self.num_inputs != state_dict["main"]["num_inputs"]:
+            raise ImportError(f"Atempting to import a system with {state_dict['main']['num_inputs']} inputs into a created system of {self.num_inputs} inputs.")
+        
+        if self.num_outputs != state_dict["main"]["num_outputs"]:
+            raise ImportError(f"Atempting to import a system with {state_dict['main']['num_outputs']} outputs into a created system of {self.num_outputs} outputs.")
+        
+        self.system_type = state_dict["main"]["system_type"]
+        self.params_update = state_dict["main"]["params_update"]
+
+        self.antecedents = Antecedents(self.num_inputs)
+        self.rules = Rules()
+        self.normalisation = torch.nn.functional.normalize
+        self.consequents = Consequents(num_inputs=self.num_inputs, num_outputs=self.num_outputs, parameters_update=self.params_update, system_type=self.system_type)
+
+        self.active_rules = state_dict["main"]["active_rules"]
+        self.active_rules_consequents = state_dict["main"]["active_rules_consequents"]
+        self.rules_relevancy = state_dict["main"]["rules_relevancy"]
+        self.erase_irrelevant_rules = state_dict["main"]["erase_irrelevant_rules"]
+
+        self.firing_strength = state_dict["main"]["firing_strength"]
+
+        # Load Antecedents
+        for universe_name, universe in self.antecedents.universes.items():
+            universe.name = state_dict["Antecedents"]["universes"][universe_name]["name"]
+            universe.min = state_dict["Antecedents"]["universes"][universe_name]["min"]
+            universe.max = state_dict["Antecedents"]["universes"][universe_name]["max"]
+            universe.merge = state_dict["Antecedents"]["universes"][universe_name]["merge"]
+            universe.heaviside = state_dict["Antecedents"]["universes"][universe_name]["heaviside"]
+
+            # Loading functions
+            for function_name, function_params in state_dict["Antecedents"]["universes"][universe_name]["functions"].items():
+                function_type = function_params["type"]
+                function_params = function_params["parameters"]
+                try:
+                    module = __import__("functions", fromlist=[function_type])
+                    universe.functions[function_name] =  getattr(module, function_type)()
+                except ImportError:
+                    raise ImportError(f"Error: Class {function_type} not found in the 'functions' folder.")
+
+                for name, value in function_params.items():
+                    universe.functions[function_name][name] = value
+
+        # Load Consequents
+        for universe_name, universe in self.consequents.consequents.universes.items():
+            universe.name = state_dict["Consequents"]["universes"][universe_name]["name"]
+            universe.min = state_dict["Consequents"]["universes"][universe_name]["min"]
+            universe.max = state_dict["Consequents"]["universes"][universe_name]["max"]
+            universe.merge = state_dict["Consequents"]["universes"][universe_name]["merge"]
+            universe.heaviside = state_dict["Consequents"]["universes"][universe_name]["heaviside"]
+
+            # Takagi Sugeno
+            if self.system_type == "Takagi-Sugeno":
+                universe.name = state_dict["Consequents"]["universes"][universe_name][universe.algorithm_name]["name"]
+                universe.theta = state_dict["Consequents"]["universes"][universe_name][universe.algorithm_name]["theta"]
+                universe.algorithm = state_dict["Consequents"]["universes"][universe_name][universe.algorithm_name]["algorithm"]
+
+            # Tsukamoto and Lee
+            else:
+                # Loading functions
+                for function_name, function_params in state_dict["Consequents"]["universes"][universe_name]["functions"].items():
+                    function_type = function_params["type"]
+                    function_params = function_params["parameters"]
+
+                    try:
+                        module = __import__("functions", fromlist=[function_type])
+                        universe.functions[function_name] =  getattr(module, function_type)()
+                    except ImportError:
+                        raise ImportError(f"Error: Class {function_type} not found in the 'functions' folder.")
+
+                    for name, value in function_params.items():
+                        universe.functions[function_name][name] = value
+        
+        # The next to are pointers
+        self.inputs = self.antecedents.universes # To make renaming easier
+        self.outputs = self.consequents.consequents.universes # To make renaming easier
+
+    def _irrelevant_rules_check(self, f):
+        relevancy = torch.mean(torch.mean(f, dim=0), dim=0)
+        if self.rules_relevancy is None:
+            self.rules_relevancy = relevancy
+        else:
+            self.rules_relevancy += relevancy
+
+        self.rules_relevancy = torch.nn.functional.normalize(self.rules_relevancy, dim=0, p=1)
+
+    def get_conversion_number(self, x):
+        if x == 0:
+            return 1.0
+        
+        x = math.floor(math.log10(abs(x)))
+        if x > 0:
+            return float("1" + "0" * x)
+        else:
+            return float("0." + "0" * abs(x) + "1")
+
+    def forward(self, X, Y):
+        f = self.antecedents(X)
+
+        self.rules.active_rules = self.active_rules
+        f = self.rules(f)
+        
+        f = self.normalisation(f, dim=2, p=1)
+
+        self.consequents.consequents.active_rules = self.active_rules_consequents
+        output = self.consequents(f, X, Y)
+
+        return output
+    
+    
+    def __call__(self, *args, **kwargs):
+        '''
+        In the call step I will preprocess the data and discern if 
+        I am being asked a control/regression or a classification task.
+        '''
+
+        if args and kwargs:
+            raise ValueError("All the arguments must be either arguments or keyword arguments, but you cannot mix between both")
+
+        # I NEED TO DISCOVER HOW THE DATA ENTERS
+        if kwargs:
+            X, Y = self._prepare_input_matrices(**kwargs)
+        
+        else:
+            if len(args) > 2:
+                raise ValueError("Please provide as input either a matrix with the X arguments or two matrices, one with X arguments and one with Y arguments")
+            X, Y = args
+
+        print(X, Y)
+        return self.forward(X, Y)
+        
+
+from functions import LinearS, LinearZ
+import torch
+
+anfis = ANFIS(num_inputs=2, num_outputs=1)
+
+anfis.inputs['Input 1'].range = 0, 10
+anfis.inputs['Input 1'].name = 'X'
+anfis.inputs['Input 1'].functions["Token1"] = LinearS(0, 10)
+
+anfis.inputs['Input 2'].range = 0, 10
+anfis.inputs['Input 2'].name = 'Y'
+anfis.inputs['Input 2'].functions["Token2"] = LinearZ(0, 10)
+
+anfis.create_rules_base([
+    "If Token1",
+    "If Token2"
+])
+
+X = torch.rand(1, 1)
+Y = torch.rand(1, 1)
+print(' ')
+print('Pasando argumentos posicionales')
+anfis(X=X, Y=Y)
+print(' ')
+print('Pasando argumentos no posicionales')
+anfis(X, Y)
+print(' ')
+print('Pasando argumentos mix')
+anfis(X, Y, X)
+

pyanfis-0.1/src/pyanfis/antecedents/__init__.py

@@ -0,0 +1,3 @@
+from .antecedents import Antecedents
+
+__all__ = ["Antecedents"]

pyanfis-0.1/src/pyanfis/antecedents/antecedents.py

@@ -0,0 +1,50 @@
+import torch
+
+from functions import Universe
+
+class Antecedents(torch.nn.Module):
+    """
+    This class is used to define the range in which a variable
+    is going to be defined in a fuzzy way, it is composed of
+    several functions used to describe it. 
+
+    Attributes
+    ----------
+    x : torch.Tensor
+        input batched data
+    merge : bool
+        if True, the functions that cover similar area will merge
+    heaviside :
+        if True, the functions on the sides will become Heaviside
+    universes : dict
+        dict where all the universes are going to be stored
+    
+    Methods
+    -------
+    automf(n_func)
+        generate automatically gauss functions inside all universes
+        inside the antecedents
+
+    Returns
+    -------
+    torch.tensor
+        a tensor of size [n_batches, n_lines, total_functions_of_all_universes]
+    """
+    def __init__(self, num_inputs: int, heaviside: bool=False) -> None:
+        super(Antecedents, self).__init__()
+        self.num_inputs = num_inputs
+        self.heaviside = heaviside
+        self.universes = {f"Input {i+1}": Universe() for i in range(num_inputs)}
+
+    def automf(self, n_func: int=2) -> None:
+        for key in self.universes.keys():
+            self.universes[key].automf(n_func=n_func)
+
+    def forward(self , X: torch.Tensor) -> torch.Tensor:
+        width = len([function for key, universe in self.universes.items() for key, function in universe.functions.items()])
+        fuzzy = torch.zeros(X.size(0), X.size(1), width)
+        for i, (key, universe) in enumerate(self.universes.items()):
+            fuzzy[:, :, i*len(universe.functions):(i+1)*len(universe.functions)] = universe(X[:,:,i:i+1])
+        
+        fuzzy[torch.isnan(fuzzy)] = 1
+        return fuzzy

pyanfis-0.1/src/pyanfis/consequents/__init__.py

@@ -0,0 +1,7 @@
+from .types.takagi_sugeno import TakagiSugeno
+from .types.tsukamoto import Tsukamoto
+from .types.lee import Lee
+
+from .consequents import Consequents
+
+__all__ = ["Consequents", "TakagiSugeno", "Tsukamoto", "Lee"]