InsideForest 0.2.4__tar.gz → 0.2.6__tar.gz

{insideforest-0.2.4 → insideforest-0.2.6}/InsideForest/regions.py

@@ -34,6 +34,36 @@ class regions:
     m_medios = [(df_p1.iloc[i] + df_p2.iloc[i]) / 2 for i in range(len(df_p1))]
     return pd.DataFrame(m_medios)
   
+  def mean_distance_ndim_fast(self, df_sep_dm_agg, verbose):
+      """
+      Versión optimizada de mean_distance_ndim que calcula (linf + lsup)/2
+      en forma vectorizada usando NumPy.
+
+      Parámetros:
+      - df_sep_dm_agg: DataFrame con índices multi-nivel que permiten extraer
+        'linf' y 'lsup' usando xs.
+
+      Retorna:
+      - DataFrame con la media de linf y lsup por fila y dimensión.
+      """
+
+      # Extraemos linf y lsup
+      df_p1 = df_sep_dm_agg.xs('linf', axis=1, level=0)
+      df_p2 = df_sep_dm_agg.xs('lsup', axis=1, level=0)
+
+      # Operación vectorizada con NumPy:
+      # (df_p1 + df_p2) / 2
+      m_medios_values = (df_p1.values + df_p2.values) / 2.0
+
+      # Reconstruimos el DataFrame con el mismo índice y columnas que df_p1
+      df_result = pd.DataFrame(
+          m_medios_values,
+          index=df_p1.index,
+          columns=df_p1.columns
+      )
+
+      return df_result
+
   def posiciones_valores_frecuentes(self, lista):
     frecuentes = Counter(lista).most_common()
     if len(set(lista)) == len(lista):
@@ -94,15 +124,78 @@ class regions:
                     (index[0], col_name)] = value
     return pd.concat([df_lilu, df_sep_dm[['ponderador']]], axis=1)
 
+  def fill_na_pond_fastest(self, df_sep_dm, df, features_val, verbose):
+      """
+      Versión ultra-optimizada de fill_na_pond para reemplazar -inf e inf usando operaciones vectorizadas avanzadas.
+      
+      Parámetros:
+      - df_sep_dm: DataFrame con columnas multi-nivel ('linf', 'lsup', 'ponderador', etc.).
+      - df: DataFrame original para extraer límites de cada dimensión.
+      - features_val: Lista de características/dimensiones presentes en df.
+      
+      Retorna:
+      - DataFrame con los mismos valores que el original, pero reemplazando -inf e inf
+        por los límites correspondientes en las columnas 'linf' y 'lsup'.
+        Incluye la columna 'ponderador'.
+      """
+      # Extraer las columnas 'linf' y 'lsup'
+      df_lilu = df_sep_dm[['linf', 'lsup']].copy()
+      
+      # Calcular los límites de reemplazo para cada dimensión
+      lsup_limit = df[features_val].max() + 1  # Límite superior
+      linf_limit = df[features_val].min() - 1  # Límite inferior
+      
+      # Asegurarse de que el orden de features_val coincide con el orden de las columnas
+      # Obtener los nombres de las dimensiones desde las columnas MultiIndex
+      linf_features = df_lilu['linf'].columns.tolist()
+      lsup_features = df_lilu['lsup'].columns.tolist()
+      
+      # Crear DataFrames de reemplazo alineados con las columnas
+      # Cada columna tendrá un único valor de reemplazo correspondiente
+      # Reemplazamos todos los -inf y inf en una sola operación vectorizada
+      
+      # Para 'linf' columns
+      linf_repl_df = pd.DataFrame(
+          np.tile(linf_limit.values, (df_lilu['linf'].shape[0], 1)),
+          columns=df_lilu['linf'].columns,
+          index=df_lilu.index
+      )
+      
+      # Para 'lsup' columns
+      lsup_repl_df = pd.DataFrame(
+          np.tile(lsup_limit.values, (df_lilu['lsup'].shape[0], 1)),
+          columns=df_lilu['lsup'].columns,
+          index=df_lilu.index
+      )
+      
+      # Crear máscaras para identificar dónde están los -inf y inf
+      mask_linf = np.isinf(df_lilu['linf'].values)
+      mask_lsup = np.isinf(df_lilu['lsup'].values)
+      
+      # Aplicar las máscaras y reemplazar los valores
+      # Usamos donde para asignar los valores de reemplazo donde la máscara es True
+      df_lilu['linf'] = np.where(mask_linf, linf_repl_df.values, df_lilu['linf'].values)
+      df_lilu['lsup'] = np.where(mask_lsup, lsup_repl_df.values, df_lilu['lsup'].values)
+      
+      # Concatenar la columna 'ponderador' de vuelta al DataFrame
+      df_replaced = pd.concat([df_lilu, df_sep_dm[['ponderador']]], axis=1)
+      
+      return df_replaced
+
+
     
   def get_agg_regions(self, df_eval, df, verbose=False):
     features_val = sorted(df_eval['dimension'].unique())
     aleatorio1 = features_val[0]
     df_sep_dm = pd.pivot_table(df_eval, index='rectangulo', columns='dimension')
 
-    df_sep_dm = self.fill_na_pond(df_sep_dm, df, features_val)
+    # df_sep_dm = self.fill_na_pond(df_sep_dm, df, features_val)
+
+    df_sep_dm = self.fill_na_pond_fastest(df_sep_dm, df, features_val,None)
     
-    df_m_medios = self.mean_distance_ndim(df_sep_dm)
+    # df_m_medios = self.mean_distance_ndim(df_sep_dm)
+    df_m_medios = self.mean_distance_ndim_fast(df_sep_dm, None)
+
     scaler = StandardScaler()
     X_feat = scaler.fit_transform(df_m_medios.values)
     epsil = self.get_eps_multiple_groups_opt(X_feat)
@@ -140,13 +233,18 @@ class regions:
       df_sep_outl.loc[:,'ponderador'] = df_sep_outl.loc[:,'ponderador'].values*max_l_val
       return pd.concat([df_sep_dm_agg,df_sep_outl])
   
-  def prio_ranges(self, separacion_dim, df):
+  def prio_ranges(self, separacion_dim, df, verbose=0):
     # aquí se usa DBS
+    if verbose==1:
+       print("Agregando regiones con DBSCAN")
     df_res = [self.get_agg_regions(df_, df) for df_ in separacion_dim]
+
     prio_ = [df_['ponderador'].values[0][0] for df_ in df_res]
+    
     df_reres = [x[0] for x in sorted([(a, b) for a,b in zip(df_res,prio_)],
                      key=lambda x: -x[1])]
-    cols_ = [df_['linf'].columns.tolist() for df_ in df_reres]
+    # cols_ = [df_['linf'].columns.tolist() for df_ in df_reres]
+
     return df_reres
 
 

{insideforest-0.2.4 → insideforest-0.2.6}/InsideForest/trees.py

@@ -249,6 +249,81 @@ class trees:
 
 
 
+  def get_summary_optimizado(self, data1, df_full_arboles, var_obj, no_branch_lim=100, verbose=0):
+      # 1) Calculamos el pivot que resume por N_regla, N_arbol, feature, operador, etc.
+      agrupacion = pd.pivot_table(
+          df_full_arboles,
+          index=['N_regla', 'N_arbol', 'feature', 'operador'],
+          values=['rangos', 'Importancia'],
+          aggfunc=['min', 'max', 'mean']
+      )
+      
+      # 2) Extraemos los valores de min, max y mean
+      agrupacion_min = agrupacion['min'].reset_index()
+      agrupacion_min = agrupacion_min[agrupacion_min['operador'] == '<=']
+
+      agrupacion_max = agrupacion['max'].reset_index()
+      agrupacion_max = agrupacion_max[agrupacion_max['operador'] == '>']
+
+      # (Podríamos usar agrupacion_mean si lo necesitas luego; en el ejemplo no se reusa directamente)
+      agrupacion_mean = agrupacion['mean'].reset_index()
+
+      # 3) Concatenamos las filas con operador <= y >, y ordenamos
+      agrupacion = pd.concat([agrupacion_min, agrupacion_max]).sort_values(['N_arbol', 'N_regla'])
+
+      # 4) Seleccionamos los top 100 árboles
+      top_100_arboles = agrupacion['N_arbol'].unique()[:no_branch_lim]
+
+      # 5) Iteramos por cada árbol y regla para construir una única máscara booleana por regla
+      reglas = []
+
+      for arbol_num in tqdm(top_100_arboles, disable=(verbose == 0), desc="Procesando ramas"):
+          # Imprimimos (opcional) según el valor de verbose
+          if arbol_num % 50 == 0 and verbose == 1:
+              print(f"Procesando rama del árbol: {arbol_num}")
+
+          # Subconjunto del pivot para este árbol
+          ag_arbol = agrupacion[agrupacion['N_arbol'] == arbol_num]
+
+          # Recorremos cada regla de ese árbol
+          for regla_num in ag_arbol['N_regla'].unique():
+              ag_regla = ag_arbol[ag_arbol['N_regla'] == regla_num]
+
+              # Obtenemos pares (feature, valor) según operador
+              men_ = ag_regla[ag_regla['operador'] == '<='][['feature', 'rangos']].values
+              may_ = ag_regla[ag_regla['operador'] == '>'][['feature', 'rangos']].values
+
+              # Construimos la máscara booleana para filtrar data1 en un único paso
+              mask = np.ones(len(data1), dtype=bool)
+
+              # Agregamos condiciones de <=
+              for col, val in men_:
+                  mask &= (data1[col] <= val)
+
+              # Agregamos condiciones de >
+              for col, val in may_:
+                  mask &= (data1[col] > val)
+
+              # Calculamos n_sample y ef_sample
+              n_sample = mask.sum()  # número de filas que cumplen todas las condiciones
+              # Evitamos error en caso de n_sample = 0
+              ef_sample = data1.loc[mask, var_obj].mean() if n_sample > 0 else 0
+
+              # Creamos una copia para esa regla, asignando los valores calculados
+              ag_regla_copy = ag_regla.copy()
+              ag_regla_copy['n_sample'] = n_sample
+              ag_regla_copy['ef_sample'] = ef_sample
+
+              reglas.append(ag_regla_copy)
+
+      # 6) Concatenamos todos los resultados y ordenamos por las métricas solicitadas
+      resultado = pd.concat(reglas, ignore_index=True)
+      resultado = resultado.sort_values(by=['ef_sample', 'n_sample'], ascending=False)
+      
+      return resultado
+
+
+
   def get_rect_coords(self, df):
     limits = {}
     for i, row in df.iterrows():
@@ -322,7 +397,7 @@ class trees:
     separacion_dim = self.get_dfs_dim(rectangles_)
     return separacion_dim
 
-  def get_branches(self, df, var_obj, regr, verbose=0):
+  def get_branches(self, df, var_obj, regr, no_trees_search=100, verbose=0):
     """
     Función principal para extraer los rectángulos (reglas) de los árboles.
     :param df: DataFrame original
@@ -346,11 +421,13 @@ class trees:
     if verbose==1:
        print("Obtenemos un resumen de los  árboles")
     
-    df_summ = self.get_summary(df, df_full_arboles, var_obj, verbose)
-
+    # df_summ = self.get_summary(df, df_full_arboles, var_obj, verbose)
+    df_summ = self.get_summary_optimizado(df, df_full_arboles, var_obj, no_trees_search, verbose)
+    
     if verbose==1:
        print("Generamos el df final con forma de rectángulo")
     # Extraemos las reglas (extract_rectangles)
     separacion_dim = self.extract_rectangles(df_summ)
 
-    return separacion_dim
+    return separacion_dim
+  

{insideforest-0.2.4 → insideforest-0.2.6}/InsideForest.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: InsideForest
-Version: 0.2.4
+Version: 0.2.6
 Summary: A comprehensive library for describing and analyzing data insights via AI
 Home-page: https://github.com/jcval94/InsideForest.git
 Author: [('Jose Carlos Del Valle', 'jcval94@gmail.com'), ('ChatGPT', 'chat.openai.com/chat')]

{insideforest-0.2.4 → insideforest-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: InsideForest
-Version: 0.2.4
+Version: 0.2.6
 Summary: A comprehensive library for describing and analyzing data insights via AI
 Home-page: https://github.com/jcval94/InsideForest.git
 Author: [('Jose Carlos Del Valle', 'jcval94@gmail.com'), ('ChatGPT', 'chat.openai.com/chat')]

{insideforest-0.2.4 → insideforest-0.2.6}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='InsideForest',
-    version='0.2.4',
+    version='0.2.6',
     packages=find_packages(),
     license='MIT',
     author=[('Jose Carlos Del Valle', 'jcval94@gmail.com'),