mango 0.2.0__tar.gz → 0.2.1__tar.gz

{mango-0.2.0/mango.egg-info → mango-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mango
-Version: 0.2.0
+Version: 0.2.1
 Summary: Library with a collection of usefull classes and methods to DRY
 Author-email: baobab soluciones <mango@baobabsoluciones.es>
 License: Apache Software License
@@ -51,8 +51,8 @@ Requires-Dist: plotly<=5.17.0; extra == "plot"
 Provides-Extra: shap
 Requires-Dist: shap[plots]==0.43.0; extra == "shap"
 
-MANGO
------
+Mango
+------
 
 This a library containing several modules developed by the team at baobab soluciones. These functions, classes and methods are based on their experience, understanding and knowledge of the Python language and its ecosystem.
 

{mango-0.2.0 → mango-0.2.1}/README.rst

@@ -1,5 +1,5 @@
-MANGO
------
+Mango
+------
 
 This a library containing several modules developed by the team at baobab soluciones. These functions, classes and methods are based on their experience, understanding and knowledge of the Python language and its ecosystem.
 

mango-0.2.1/docs/source/conf.py

@@ -0,0 +1,46 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath("../../"))
+
+
+project = "mango"
+copyright = "2023, baobab soluciones"
+author = "baobab soluciones"
+# release = "0.2.0"
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = ["sphinx.ext.autodoc", "sphinx.ext.intersphinx", "sphinxcontrib.bibtex"]
+
+templates_path = ["templates"]
+exclude_patterns = ["build", "Thumbs.db", ".DS_Store"]
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = "shibuya"
+html_static_path = ["static"]
+
+# autodoc_mock_imports = ["mango"]
+autodoc_member_order = "bysource"
+autodoc_default_options = {"members": True, "inherited-members": True}
+
+import mango
+
+version = mango.__version__
+release = mango.__version__
+
+
+# Options for bibtex
+bibtex_bibfiles = ["./refs.bib"]
+bibtex_default_style = "plain"

mango-0.2.1/mango/__init__.py

@@ -0,0 +1,4 @@
+"""
+Main file
+"""
+__version__ = "0.2.1"

mango-0.2.1/mango/benchmark/__init__.py

@@ -0,0 +1 @@
+from .optimization import *

{mango-0.2.0 → mango-0.2.1}/mango/benchmark/optimization/ackley.py

@@ -7,15 +7,18 @@ def ackley(x: np.ndarray) -> float:
     General Ackley function.
 
     The Ackley function is widely used for testing optimization algorithms.
+
     In its two-dimensional form, it is characterized by a nearly flat outer region, and a large hole at the centre.
     The function poses a risk for optimization algorithms, particularly hillclimbing algorithms,
     to be trapped in one of its many local minima.
 
     The global minimum point of the function is: f(x) = 0, at x = (0, ..., 0)
 
-    :param :class:`np.ndarray` x: numpy array of floats. The values are evaluated in the range [-32.768, 32.768]
+    :param x: numpy array of floats. The values are evaluated in the range [-32.768, 32.768]
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
+    :doc-author: baobab soluciones
     """
     return (
         -20 * exp(-0.2 * sqrt(1 / len(x) * np.sum(np.square(x))))
@@ -29,7 +32,10 @@ def inverted_ackley(x: np.ndarray) -> float:
     """
     Inverted Ackley function.
 
-    :param :class:`np.ndarray` x: numpy array of floats
+    Some description of the function.
+
+    :param x: numpy array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.1}/mango/benchmark/optimization/bukin.py

@@ -11,7 +11,8 @@ def bukin_function_6(x: np.array) -> float:
 
     The global minima is at (-10, 1) with a value of 0.
 
-    :param :class:`np.array` x: array of floats. Values are between [-15, 5] for x1 and [-3, 3] for x2
+    :param x: array of floats. Values are between [-15, 5] for x1 and [-3, 3] for x2
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """
@@ -22,7 +23,8 @@ def inverted_bukin_function_6(x: np.array) -> float:
     """
     Inverted Bukin function N. 6.
 
-    :param :class:`np.array` x: array of floats. Values are between [-15, 5] for x1 and [-3, 3] for x2
+    :param x: array of floats. Values are between [-15, 5] for x1 and [-3, 3] for x2
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.1}/mango/benchmark/optimization/cross_in_tray.py

@@ -13,7 +13,8 @@ def cross_in_tray(x: np.array) -> float:
     The global mínima is located at x = (1.34941, 1.34941), (-1.34941, 1.34941), (1.34941, -1.34941)
     and (-1.34941, -1.34941) with a value of -2.06261
 
-    :param :class:`np.array` x: array of floats
+    :param x: array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """
@@ -36,7 +37,8 @@ def inverted_cross_in_tray(x: np.array) -> float:
     The Cross-in-tray function has many widespread local minima, which are regularly distributed
     This implementation inverts the function to test out the maximization
 
-    :param :class:`np.array` x: array of floats
+    :param x: array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.1}/mango/benchmark/optimization/dolan.py

@@ -9,7 +9,8 @@ def dolan_function_no2(x: np.array) -> float:
 
     The global minima is at [8.39045925, 4.81424707, 7.34574133, 68.88246895, 3.85470806] with a value of 10^-5
 
-    :param :class:`np.array` x: array of floats. Values are evaluated between [-100, 100]
+    :param x: array of floats. Values are evaluated between [-100, 100]
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """
@@ -27,7 +28,8 @@ def inverted_dolan_function_no2(x: np.array) -> float:
     """
     Inverted Dolan function No 2.
 
-    :param :class:`np.array` x: array of floats. Values are evaluated between [-100, 100]
+    :param x: array of floats. Values are evaluated between [-100, 100]
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.1}/mango/benchmark/optimization/drop_wave.py

@@ -11,7 +11,8 @@ def drop_wave(x: np.array) -> float:
 
     The global minima is located at x = (0, 0) with a value of -1
 
-    :param :class:`np.array` x: array of floats. Values usually are between -5.12 and 5.12.
+    :param x: array of floats. Values usually are between -5.12 and 5.12.
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """
@@ -29,7 +30,8 @@ def inverted_drop_wave(x: np.array) -> float:
 
     The global minima is located at x = (0, 0) with a value of -1
 
-    :param :class:`np.array` x: array of floats. Values usually are between -5.12 and 5.12.
+    :param x: array of floats. Values usually are between -5.12 and 5.12.
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.1}/mango/benchmark/optimization/egg_holder.py

@@ -12,7 +12,8 @@ def egg_holder(x: np.array) -> float:
     The function is usually evaluated on the square xi ∈ [-512, 512], for all i = 1, 2.
     The global mínima is located at x = (512, 404.2319) with a value of -959.6407
 
-    :param :class:`np.array` x: array of floats
+    :param x: array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """
@@ -28,7 +29,8 @@ def inverted_egg_holder(x: np.array) -> float:
     The Egg-holder function has many widespread local minima, which are regularly distributed
     This implementation inverts the function to test out the maximization
 
-    :param :class:`np.array` x: array of floats
+    :param x: array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.1}/mango/benchmark/optimization/griewank.py

@@ -9,7 +9,8 @@ def griewank(x: np.array) -> float:
 
     The Griewank function has many widespread local minima, which are regularly distributed
 
-    :param :class:`np.array` x: array of floats
+    :param x: array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """
@@ -27,7 +28,8 @@ def inverted_griewank(x: np.array) -> float:
     The Griewank function has many widespread local minima, which are regularly distributed
     This implementation inverts the function to test out the maximization
 
-    :param :class:`np.array` x: array of floats
+    :param x: array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.1}/mango/clients/aemet.py

@@ -87,6 +87,7 @@ class AEMETClient(RESTClient):
     def all_stations(self) -> List[dict]:
         """
         This property will return all the meteorological stations in Spain.
+
         :return: List of dictionaries with the meteorological stations
         :doc-author: baobab soluciones
         """
@@ -96,6 +97,7 @@ class AEMETClient(RESTClient):
     def municipios(self) -> List[dict]:
         """
         This property will return all the municipios in Spain.
+
         :return: List of dictionaries with the municipios
         :doc-author: baobab soluciones
         """
@@ -401,6 +403,15 @@ class AEMETClient(RESTClient):
         Main method of the class. This method will return the meteorological data from the meteorological stations in
         Spain.
 
+        :param str station_code: meteorological station code
+        :param float lat: latitude
+        :param float long: longitude
+        :param str province: province
+        :param datetime start_date: start date
+        :param datetime end_date: end date
+        :return: a list of dictionaries with the meteorological data
+        :doc-author: baobab soluciones
+
         Usage
         -----
 
@@ -432,14 +443,7 @@ class AEMETClient(RESTClient):
 
         >>> data = client.get_meteo_data(lat=40.4165, long=-3.70256, province="Madrid", output_format="df")
 
-        :param str station_code: meteorological station code
-        :param float lat: latitude
-        :param float long: longitude
-        :param str province: province
-        :param datetime start_date: start date
-        :param datetime end_date: end date
-        :return: a list of dictionaries with the meteorological data
-        :doc-author: baobab soluciones
+
         """
         # Check datatype
         if station_code and not isinstance(station_code, str):

mango-0.2.1/mango/models/activations.py

@@ -0,0 +1,32 @@
+import math
+
+
+# noinspection PyTypeChecker
+def sigmoid(x: float, factor: float = 1) -> float:
+    """
+    Sigmoid funtion with a factor to control the slope
+
+    :param x: the input value
+    :type x: float
+    :param factor: the factor to control the slope, defaults to 1
+    :type factor: float, optional
+    :return: the sigmoid value
+    :rtype: float
+    """
+    x = max(-60, min(60, factor * x))
+    return 1 / (1 + math.exp(-x))
+
+
+# noinspection PyTypeChecker
+def tanh(x: float, factor: float = 1) -> float:
+    """
+    Tanh funtion with a factor to control the slope
+
+    :param x: the input value
+    :type x: float
+    :param factor: the factor to control the slope, defaults to 1
+    :type factor: float, optional
+    :return: the tanh value
+    """
+    x = max(-60, min(60, factor * x))
+    return math.tanh(x)

mango-0.2.1/mango/models/genetic/config/__init__.py

@@ -0,0 +1 @@
+from .config import GeneticBaseConfig

{mango-0.2.0 → mango-0.2.1}/mango/models/genetic/config/config.py

@@ -51,7 +51,6 @@ class GeneticBaseConfig(BaseConfig):
             ),
         ],
         "crossover": [
-            ConfigParameter("morphology_parents", int, 3, required=False),
             ConfigParameter("offspring_size", int, 100, required=False),
             ConfigParameter("blend_expansion", float, 0.1, required=False),
         ],

{mango-0.2.0 → mango-0.2.1}/mango/models/genetic/const.py

@@ -11,7 +11,7 @@ CROSSOVER_METHODS = [
     "gaussian",
 ]
 
-MUTATION_CONTROL_METHODS = ["none", "adaptative", "gene-based", "population-based"]
+MUTATION_CONTROL_METHODS = ["static", "adaptative", "gene-based", "population-based"]
 
 REPLACEMENT_METHODS = [
     "elitist",

mango-0.2.1/mango/models/genetic/individual/base_individual.py

@@ -0,0 +1,270 @@
+from random import uniform, randint
+from mango.models.genetic.config import GeneticBaseConfig
+import numpy as np
+
+
+class Individual:
+    def __init__(self, genes=None, idx: int = 0, parents: tuple = None, config=None):
+        self.fitness = None
+        self.idx = idx
+        self.config = config
+        self.parents_idx = None
+        self.parents = parents
+
+        # Info to get from config file
+        self.encoding = self.config("encoding")
+        self.min_bound = self.config("gene_min_value")
+        self.max_bound = self.config("gene_max_value")
+        self.gene_length = self.config("gene_length")
+
+        self.genes = genes
+
+    @property
+    def genes(self) -> np.ndarray:
+        """
+        Property that stores the :class:`numpy.ndarray` of genes in the individual
+
+        If max_bound or min_bound are set, the genes values are clipped to the bounds.
+        After setting the value for the genes the hash is updated.
+
+        :param value: the new value for the genes (used on setting up the property)
+        :type value: :class:`numpy.ndarray`
+        :return: the genes value
+        """
+        return self._genes
+
+    @genes.setter
+    def genes(self, value: np.ndarray = None):
+        if (
+            value is not None
+            and self.max_bound is not None
+            and self.min_bound is not None
+        ):
+            value[np.greater(value, self.max_bound)] = self.max_bound
+            value[np.less(value, self.min_bound)] = self.min_bound
+        self._genes = value
+        if self._genes is not None:
+            self._hash = self.__hash__()
+
+    @property
+    def idx(self) -> int:
+        """
+        Property that stores the internal idx of the Individual. This value is just to help
+        distinguish between individuals.
+
+        :param value: the new value for the idx (used on setting up the property)
+        :type value: int
+        :return: the idx value
+        """
+        return self._idx
+
+    @idx.setter
+    def idx(self, value: int):
+        self._idx = value
+
+    @property
+    def config(self) -> GeneticBaseConfig:
+        """
+        Property that stores the config object for the individual
+
+        :param value: the new value for the config (used on setting up the property)
+        :type value: :class:`mango.models.genetic.config.GeneticBaseConfig`
+        :return: the config value
+        """
+        return self._config
+
+    @config.setter
+    def config(self, value: GeneticBaseConfig):
+        self._config = value
+
+    @property
+    def parents(self) -> tuple:
+        """
+        Property that stores the parents of the individual and their idx.
+
+        During the setter the value for attribute parents_idx
+        is updated as well as a tuple of the idx of all the parents
+
+        :param value: the new value for the parents (used on setting up the property)
+        :type value: tuple
+        :return: the parents value
+        """
+        return self._parents
+
+    @parents.setter
+    def parents(self, value: tuple):
+        self._parents = value
+        if self._parents is not None:
+            self.parents_idx = tuple([p.idx for p in self.parents])
+
+    @property
+    def encoding(self) -> str:
+        """
+        Property that stores the encoding type for the individual
+
+        :param value: the new value for the encoding (used on setting up the property)
+        :type value: str
+        :return: the encoding value
+        :rtype: str
+        """
+        return self._encoding
+
+    @encoding.setter
+    def encoding(self, value):
+        self._encoding = value
+
+    @property
+    def fitness(self) -> float:
+        """
+        Property that stores the fitness value for the individual
+
+        :param value: the new value for the fitness (used on setting up the property)
+        :type value: float
+        :return: the fitness value
+        """
+        return self._fitness
+
+    @fitness.setter
+    def fitness(self, value):
+        self._fitness = value
+
+    @classmethod
+    def create_random_individual(
+        cls, idx: int, config: GeneticBaseConfig
+    ) -> "Individual":
+        """
+        Class method that creates a new individual with random genes.
+
+        :param idx: the idx of the new individual
+        :type idx: int
+        :param config: the config object for the individual
+        :type config: :class:`mango.models.genetic.config.GeneticBaseConfig`
+        :return: the new individual
+        """
+        ind = cls(idx=idx, config=config)
+
+        ind.create_random_genes()
+        return ind
+
+    def create_random_genes(self):
+        """
+        Method to create random genes for an individual based on the encoding type.
+
+        The genes are stored in the :attr:`genes` attribute
+        """
+        if self.encoding == "real":
+            self.genes = np.random.uniform(
+                self.min_bound, self.max_bound, self.gene_length
+            )
+
+        elif self.encoding == "binary":
+            self.genes = np.random.randint(0, 2, self.gene_length)
+
+        elif self.encoding == "integer":
+            self.genes = np.random.randint(
+                self.min_bound, self.max_bound + 1, self.gene_length
+            )
+
+    def mutate(self, mutation_prob: float = None):
+        """
+        Method to mutate the individual based on the encoding type.
+
+        The mutation probability is used to determine if the individual will be mutated or not.
+        An individual can have more than one gene that gets mutated. The
+
+        :param mutation_prob: the probability of mutation
+        :type mutation_prob: float
+        """
+        keep = True
+        while keep:
+            chance = uniform(0, 1)
+            if chance <= mutation_prob:
+                if self.encoding == "real":
+                    self._mutate_real()
+                elif self.encoding == "binary":
+                    self._mutate_binary()
+                elif self.encoding == "integer":
+                    self._mutate_integer()
+                else:
+                    raise NotImplemented("Only real encoding is implemented for now")
+                self._hash = self.__hash__()
+            else:
+                keep = False
+
+    def _mutate_binary(self):
+        """
+        Mutation method for the binary values encoding.
+
+        This mutation is a simple bit flip on the calculated gene position
+        """
+        gene_position = randint(0, self.gene_length - 1)
+        self.genes[gene_position] = 1 - self.genes[gene_position]
+
+    def _mutate_integer(self):
+        """
+        Mutation method for the integer values encoding.
+
+        This mutation is a simple random value between the min and max bounds (randint)
+        """
+        gene_position = randint(0, self.gene_length - 1)
+        self.genes[gene_position] = randint(self.min_bound, self.max_bound)
+
+    def _mutate_real(self):
+        """
+        Mutation method for the real values encoding
+
+        This mutation is a simple random value between the min and max bounds
+        """
+        gene_position = randint(0, self.gene_length - 1)
+        self.genes[gene_position] = uniform(self.min_bound, self.max_bound)
+
+    def dominates(self, other):
+        """
+        This method should implement the logic to check if one individual dominates another one
+
+        The domination concept is mainly used in multiobjective optimization problems.
+        A solution dominates another when the first one is equal or better in all objectives and one objective
+        is at least better than the other solution
+        """
+        raise NotImplemented
+
+    def copy(self) -> "Individual":
+        """
+        Method to create a copy of the individual
+        """
+        return Individual(
+            genes=self.genes.copy(),
+            idx=self.idx,
+            config=self.config,
+            parents=self.parents,
+        )
+
+    def __hash__(self):
+        """
+        Method to calculate the hash of the individual and store it in the :attr:`_hash` attribute
+
+        The hash is calculated based on the byte representation of the genes of the individual so that only individuals
+        with the same genome have the hash
+        """
+        return hash(self.genes.tobytes())
+
+    def __eq__(self, other) -> bool:
+        """
+        Method to compare two individuals
+
+        In order to make this comparison as fast as possible it used the pre-generated hash to compare the individuals.
+        So the comparison is made on the genotype instead of the phenotype, as two individuals with different
+        genotypes can have the same phenotype, so they should be considered as not equal
+        for crossover and genetic diversity purposes.
+
+        :param other: the other individual to compare
+        :return: True if the individuals are equal, False otherwise
+        :rtype: bool
+        """
+        if isinstance(other, self.__class__):
+            return self._hash == other._hash
+
+        return False
+
+    def __repr__(self):
+        return f"Individual {self.idx}"

mango-0.2.1/mango/models/genetic/population/__init__.py

@@ -0,0 +1 @@
+from .base_population import Population