GRating 0.0.1__tar.gz

grating-0.0.1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: GRating
+Version: 0.0.1
+Summary: Algorithm ranking library based on Bradley-Terry models
+Author: Oscar A. Gonzalez Sanchez
+Project-URL: Homepage, https://github.com/OscarAGonzalezSanchez/GRating
+Keywords: optimization,ranking,metaheuristics
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+
+# readme = "README.md"

grating-0.0.1/README.md

@@ -0,0 +1 @@
+# readme = "README.md"

grating-0.0.1/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=80"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "GRating"
+version = "0.0.1"
+description = "Algorithm ranking library based on Bradley-Terry models"
+readme = "README.md"
+requires-python = ">=3.10"
+
+dependencies = [
+    "numpy",
+    "pandas",
+    "matplotlib",
+    "scipy"
+]
+
+authors = [
+    { name = "Oscar A. Gonzalez Sanchez" }
+]
+
+keywords = [
+    "optimization",
+    "ranking",
+    "metaheuristics"
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+]
+
+[project.urls]
+Homepage = "https://github.com/OscarAGonzalezSanchez/GRating"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

grating-0.0.1/setup.cfg

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

grating-0.0.1/src/GRating.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: GRating
+Version: 0.0.1
+Summary: Algorithm ranking library based on Bradley-Terry models
+Author: Oscar A. Gonzalez Sanchez
+Project-URL: Homepage, https://github.com/OscarAGonzalezSanchez/GRating
+Keywords: optimization,ranking,metaheuristics
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+
+# readme = "README.md"

grating-0.0.1/src/GRating.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/GRating.egg-info/PKG-INFO
+src/GRating.egg-info/SOURCES.txt
+src/GRating.egg-info/dependency_links.txt
+src/GRating.egg-info/requires.txt
+src/GRating.egg-info/top_level.txt
+src/grating/__init__.py
+src/grating/grating.py
+tests/test_rating.py

grating-0.0.1/src/GRating.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

grating-0.0.1/src/GRating.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy
+pandas
+matplotlib
+scipy

grating-0.0.1/src/GRating.egg-info/top_level.txt

@@ -0,0 +1 @@
+grating

grating-0.0.1/src/grating/__init__.py

@@ -0,0 +1,7 @@
+from .grating import GRating, signif, create_scater_plot
+
+__all__ = [
+    "GRating",
+    "signif",
+    "create_scater_plot"
+]

grating-0.0.1/src/grating/grating.py

@@ -0,0 +1,431 @@
+from matplotlib.ticker import FuncFormatter
+from numpy.typing import NDArray
+import matplotlib.pyplot as plt
+from scipy.stats import gmean
+import pandas as pd
+import numpy as np
+import os
+
+class GRating():
+    def __init__(self):
+        pass
+    
+    def create_experimentation_table(
+            self, 
+            ruta: str, 
+            filt: list[str] | None = None, 
+            rettest: list[str] | None = None
+        ) -> None:
+        """
+        Crea una tabla de experimentación a partir de los archivos encontrados.
+
+        Parameters
+        ----------
+        ruta : str
+            Ruta raíz donde se buscarán los archivos.
+        filt : list[str], optional
+            Lista de filtros a aplicar durante la búsqueda.
+        rettest : list[str], optional
+            Lista de pruebas o resultados a retornar.
+
+        Returns
+        -------
+        None
+        """
+        # Algorithms names are extracted
+        self.algorithms = os.listdir(ruta)
+        for i, algo in enumerate(self.algorithms):
+            self.algorithms[i] = algo[:-4]
+        
+        self.algorithms = sorted(self.algorithms)
+        
+        # An array for loading the data is created
+        df = pd.DataFrame(pd.read_csv(f'{ruta}/{self.algorithms[0]}.csv'))
+        self.tests = df.columns
+        
+        if filt != None:
+            test = []
+            for value in self.tests:
+                for accepted in filt:
+                    if accepted in value:
+                        test.append(value)
+            self.tests = test
+        
+        if rettest != None:
+            test = []
+            for value in self.tests:
+                flag = True
+                for rejected in rettest:
+                    if rejected in value:
+                        flag = False
+                if flag:    
+                    test.append(value)
+            self.tests = test
+        
+        self.runs = len(df)
+        self.fit_data = np.zeros((len(self.algorithms), len(self.tests), self.runs))
+        
+        # Information is loaded in the structure
+        for i, algo in enumerate(self.algorithms):
+            print(f'cargando {algo} ... con {len(self.tests)} test')
+            df = pd.DataFrame(pd.read_csv(f'{ruta}/{algo}.csv'))
+            for j, test in enumerate(self.tests):
+                self.fit_data[i, j, :] = df[test]
+
+    def load_fit_data(
+            self, 
+            data: np.ndarray
+        ) -> None:
+        """
+        Carga directamente una matriz de resultados ya procesada.
+
+        Parameters
+        ----------
+        data : np.ndarray
+            Arreglo tridimensional con forma
+            (algoritmos, pruebas, ejecuciones), donde cada elemento
+            representa el valor obtenido por un algoritmo en una
+            prueba específica durante una ejecución determinada.
+
+        Returns
+        -------
+        None
+        """
+        self.fit_data = data
+        
+    def create_win_lose_table(
+            self, 
+            method: str='permutation', 
+            draw: bool = False, 
+            samples: int = 30
+        ) -> None:
+        """
+        Genera la matriz de victorias y derrotas entre algoritmos.
+
+        Cada posición [i, j] almacena el número de veces que el
+        algoritmo i supera al algoritmo j según el criterio de
+        comparación seleccionado.
+
+        Parameters
+        ----------
+        method : str, optional
+            Método utilizado para realizar las comparaciones.
+
+            - 'permutation': compara todas las combinaciones posibles
+            entre ejecuciones.
+            - 'subsample': realiza una muestra aleatoria de comparaciones.
+
+        draw : bool, optional
+            Si es True, los empates se contabilizan otorgando medio
+            punto a cada algoritmo.
+
+        samples : int, optional
+            Número de comparaciones aleatorias cuando se utiliza el
+            método 'subsample'.
+
+        Returns
+        -------
+        None
+        """
+        if method =='permutation':
+            # The size of the data is extracted
+            self.n_algorithms, self.n_test, self.runs = self.fit_data.shape
+            # A victory table is generated
+            self.vict_loss = np.zeros((self.n_algorithms, self.n_algorithms))
+            self.vict_loss[:] = np.nan
+            
+            # The complete combinatory of wins is extracted
+            for ia in range(self.n_algorithms):
+                for ib in range(self.n_algorithms):
+                    if ia!=ib:
+                        wins = 0
+                        for j in range(self.n_test):
+                            for m in range(self.runs):                                
+                                wins += (self.fit_data[ia, j, m] < self.fit_data[ib, j, :]).sum()
+                        self.vict_loss[ia, ib] = wins
+                             
+            if draw == True:
+                # A half point is given for draws
+                for ia in range(self.n_algorithms):
+                    for ib in range(self.n_algorithms):
+                        if ia!=ib:
+                            wins = 0
+                            for j in range(self.n_test):
+                                for m in range(self.runs):                                
+                                    wins += (self.fit_data[ia, j, m] == self.fit_data[ib, j, :]).sum()
+                            self.vict_loss[ia, ib] = wins/2
+                            self.vict_loss[ib, ia] = wins/2
+        
+        elif method =='subsample':
+            # The size of the data is extracted
+            self.n_algorithms, self.n_test, self.runs = self.fit_data.shape
+            # A victory table is generated
+            self.vict_loss = np.zeros((self.n_algorithms, self.n_algorithms))
+            self.vict_loss[:] = np.nan
+            
+            # The subsample of random comparisons of wins is extracted
+            for ia in range(self.n_algorithms):
+                for ib in range(self.n_algorithms):
+                    if ia!=ib:
+                        j = np.random.randint(0, self.n_test, size=samples)
+                        m1 = np.random.randint(0, self.runs, size=samples)
+                        m2 = np.random.randint(0, self.runs, size=samples)
+                        wins = (self.fit_data[ia, j, m1] < self.fit_data[ib, j, m2]).sum()
+                        self.vict_loss[ia, ib] = wins
+                             
+            if draw == True:
+                # A half point is given for draws
+                for ia in range(self.n_algorithms):
+                    for ib in range(self.n_algorithms):
+                        if ia!=ib:
+                            wins = 0
+                            for j in range(self.n_test):
+                                for m in range(self.runs):                                
+                                    wins += (self.fit_data[ia, j, m] == self.fit_data[ib, j, :]).sum()
+                            self.vict_loss[ia, ib] = wins/2
+                            self.vict_loss[ib, ia] = wins/2
+                            
+    
+    
+    def load_win_lose_table(
+            self, 
+            table: NDArray[np.float64]
+        ) -> None:
+        """
+        Carga una matriz de victorias y derrotas.
+
+        Parameters
+        ----------
+        table : NDArray[np.float64]
+            Matriz cuadrada donde la posición [i, j] indica las
+            victorias del algoritmo i sobre el algoritmo j.
+
+        Returns
+        -------
+        None
+        """
+        self.vict_loss = table
+    
+    
+    def train_bt_model(
+            self, 
+            resolution: float=6, 
+            max_iter: int = 10000
+        ) -> tuple[list[str], NDArray[np.float64]]:
+        """
+        Fits a Bradley-Terry model using an iterative maximum likelihood
+        estimation procedure.
+
+        The algorithm repeatedly updates the model parameters until
+        convergence is achieved or the maximum number of iterations is
+        reached.
+
+        Parameters
+        ----------
+        resolution : float, optional
+            Number of significant digits required to declare convergence.
+            The fitting process stops when the maximum relative parameter
+            change falls below 10^(-resolution). Default is 6.
+
+        max_iter : int, optional
+            Maximum number of iterations allowed during the fitting
+            procedure. Default is 10000.
+
+        Returns
+        -------
+        tuple[list[str], NDArray[np.float64]]
+            A tuple containing:
+
+            - The algorithm names.
+            - The estimated Bradley-Terry ratings, normalized by their
+            geometric mean.
+        """
+        self.n_algorithms = self.vict_loss.shape[0]
+        self.p = np.ones(self.n_algorithms)
+        
+        max_p_percent_change = np.inf
+        n = 0
+        p_old = np.ones(self.n_algorithms)
+        while max_p_percent_change>1/np.power(10, resolution) and n<max_iter:
+            n+=1
+            p_old[:] = self.p
+
+            for i in range(self.n_algorithms):
+                num = 0
+                den = 0
+                for j in range(self.n_algorithms):
+                    if i!=j:
+                        num+=self.vict_loss[i, j]*self.p[j]/(self.p[i]+self.p[j])
+                        den+=self.vict_loss[j, i]/(self.p[i]+self.p[j])
+                self.p[i]=num/den
+            
+            self.p /= gmean(self.p)
+            
+            delta = np.abs(1-self.p/p_old)
+            max_p_percent_change = np.max(delta)
+        return self.algorithms, self.p
+           
+    def __str__(self) -> str:
+        """
+        Devuelve una representación textual de los ratings calculados.
+
+        Returns
+        -------
+        str
+            Cadena con el nombre de cada algoritmo y su rating
+            correspondiente.
+        """
+        text=''
+        for i in range(len(self.algorithms)):
+            text += f'{self.algorithms[i]}: {self.p[i]}\n' 
+        return text
+    
+    def get_friedman_mean_rank(self) -> NDArray[np.float64]:
+        """
+        Calcula el ranking promedio de Friedman para cada algoritmo.
+
+        Primero se promedian las ejecuciones de cada prueba y después
+        se asigna un ranking relativo dentro de cada prueba. Finalmente
+        se obtiene el ranking medio de cada algoritmo.
+
+        Returns
+        -------
+        np.ndarray
+            Vector con el ranking promedio de Friedman para cada
+            algoritmo.
+        """
+        n_algorithms, n_test, n_runs = self.fit_data.shape
+        
+        self.friedman_mean_rank = np.zeros(n_algorithms)
+        self.test_rank = np.zeros((n_algorithms, n_test))
+        
+        self.mean_fit_data = self.fit_data.mean(axis=2)
+        
+        for j in range(n_test):
+            algorithm_data = self.mean_fit_data[:,j]
+            
+            #Getting the ranking of each algoritm
+            array = np.array(algorithm_data)
+            temp = array.argsort()
+            ranks = np.empty_like(temp)
+            ranks[temp] = np.arange(len(array))
+            
+            self.test_rank[:, j] = ranks+1
+        
+        self.friedman_mean_rank = self.test_rank.mean(axis=1)
+        return self.friedman_mean_rank
+
+    
+def create_scater_plot(
+        algorithms: list[str], 
+        ratings: NDArray[np.float64], 
+        rot: int | None = 45, 
+        new_figure: bool | None = True
+    ) -> None:
+    """
+    Genera un gráfico de dispersión de los ratings obtenidos.
+
+    Parameters
+    ----------
+    algorithms : list[str]
+        Nombres de los algoritmos.
+
+    ratings : NDArray[np.float64]
+        Ratings asociados a cada algoritmo.
+
+    rot : int, optional
+        Rotación de las etiquetas del eje X.
+
+    new_figure : bool, optional
+        Si es True, crea una nueva figura antes de dibujar.
+
+    Returns
+    -------
+    None
+    """
+    if new_figure:
+        plt.Figure()
+    
+    plt.scatter(ratings, np.arange(len(algorithms), 0, -1), c='Tab:Blue')
+    
+    plt.yticks(np.arange(len(algorithms), 0, -1), algorithms)
+    plt.xticks()
+    
+    plt.xscale('log')
+    
+    ax = plt.gca()
+    ax.xaxis.set_minor_formatter(FuncFormatter(custom_minor_formatter))
+    ax.xaxis.set_major_formatter(FuncFormatter(custom_minor_formatter))
+    
+    plt.tick_params(axis='x', which='both', bottom=True, labelbottom=True, rotation=rot) 
+    plt.tick_params(axis='y', which='major', left=False)
+    
+    plt.ylim(0, len(algorithms)+1)
+    plt.grid(True, axis='both', which='major', color='#BBBBBB', linestyle='--')
+    plt.ylabel('Algorithm')
+    plt.xlabel('G-Rating')
+    plt.tight_layout()
+    plt.show()
+
+def custom_minor_formatter(
+        x: float, 
+        pos: int
+    ) -> str | float:
+    """
+    Formateador personalizado para las marcas del eje logarítmico.
+
+    Muestra únicamente etiquetas para valores cuya mantisa sea
+    aproximadamente 1, 2, 3, 5 o 7.
+
+    Parameters
+    ----------
+    x : float
+        Valor de la marca.
+
+    pos : int
+        Posición de la marca dentro del eje.
+
+    Returns
+    -------
+    str | float
+        Texto que se mostrará en la etiqueta o cadena vacía
+        cuando la etiqueta deba ocultarse.
+    """
+    # Calculate the base coefficient (e.g., 200 -> 2, 0.5 -> 5)
+    # We do this to detect if the number 'starts' with 1, 2, or 5
+    base = np.log10(x)
+    decimal_part = base - np.floor(base)
+    coeff = 10 ** decimal_part
+    
+    # Allow a small margin of error for floating point comparison
+    # We check if the number is close to 1, 2, or 5
+    if np.any([np.isclose(coeff, n, atol=0.1) for n in [1, 2, 3, 5, 7]]):
+        if base<0:
+            return np.round(x, decimals=int(-base)+1)
+        else:
+            return f'{int(x)}'
+    else:
+        return "" # Return empty string to hide the label
+
+
+def signif(x: NDArray[np.float64], p: int) -> NDArray[np.float64]:
+    """
+    Redondea valores a una cantidad específica de cifras significativas.
+
+    Parameters
+    ----------
+    x : NDArray[np.float64]
+        Valor o conjunto de valores a redondear.
+
+    p : int
+        Número de cifras significativas deseadas.
+
+    Returns
+    -------
+    NDArray[np.float64]
+        Valores redondeados a p cifras significativas.
+    """
+    x = np.asarray(x)
+    x_positive = np.where(np.isfinite(x) & (x != 0), np.abs(x), 10**(p-1))
+    mags = 10 ** (p - 1 - np.floor(np.log10(x_positive)))
+    return np.round(x * mags) / mags

grating-0.0.1/tests/test_rating.py

@@ -0,0 +1,11 @@
+from grating import GRating
+
+route = "../../data/Original_30D/best_fit"
+model = GRating()
+model.create_experimentation_table(route, filt=['original_30D_Ackley'], rettest=['Perm_0DB', 'Perm_DB'])
+model.create_win_lose_table("permutation")
+algorithms, G_rating = model.train_bt_model()
+friedman_mean_rank = model.get_friedman_mean_rank()
+
+print(algorithms, G_rating)
+print(friedman_mean_rank)