Upload llm_clasificador_HF.py

src/embeddings/llm_clasificador_HF.py

@@ -0,0 +1,548 @@
+# =============================================================================
+# CELDA 1: Instalar dependencias
+# =============================================================================
+# !pip install huggingface_hub pandas openpyxl
+
+# =============================================================================
+# CELDA 2: Login y configuración
+# =============================================================================
+from huggingface_hub import InferenceClient, login
+import pandas as pd
+import re
+import time
+
+# Login interactivo (ejecutar una vez, te pedirá el token)
+login()
+
+# Crear cliente
+client = InferenceClient()
+
+# Modelos en orden de preferencia (fallback automático)
+MODELOS = [
+    "Qwen/Qwen3-8B",
+    "meta-llama/Llama-3.1-8B-Instruct",
+    "Qwen/Qwen2.5-7B-Instruct",
+    "mistralai/Mistral-7B-Instruct-v0.2",
+]
+
+# =============================================================================
+# CELDA 3: Verificar modelos disponibles
+# =============================================================================
+def verificar_modelos():
+    """Verifica qué modelos están disponibles y retorna el primero funcional."""
+    for modelo in MODELOS:
+        try:
+            respuesta = client.chat_completion(
+                model=modelo,
+                messages=[{"role": "user", "content": "Responde únicamente: OK"}],
+                max_tokens=5
+            )
+            print(f"✅ {modelo}: Disponible")
+            return modelo
+        except Exception as e:
+            print(f"❌ {modelo}: {str(e)[:60]}")
+    return None
+
+print("Verificando modelos disponibles...\n")
+MODELO_ACTIVO = verificar_modelos()
+
+if MODELO_ACTIVO:
+    print(f"\n🎯 Modelo seleccionado: {MODELO_ACTIVO}")
+else:
+    print("\n⚠️ Ningún modelo disponible. Verifica tu token.")
+
+# =============================================================================
+# CELDA 4: Prompts por nivel
+# =============================================================================
+PROMPT_ODS = """Eres un experto en Objetivos de Desarrollo Sostenible (ODS) de las Naciones Unidas.
+
+Vincula entre 3 y 5 ODS que tengan relación directa con la siguiente iniciativa:
+
+"{iniciativa}"
+
+Para cada ODS incluye:
+- Número y nombre del ODS
+- Justificación breve del vínculo (impacto social, territorial, de paz, infraestructura o inclusión)
+
+FORMATO DE RESPUESTA (una línea por ODS, ordenados por relevancia):
+ODS [número]: [nombre] – [justificación]
+
+Responde ÚNICAMENTE con el listado, sin texto introductorio ni conclusiones."""
+
+
+PROMPT_META = """Eres un experto en Objetivos de Desarrollo Sostenible (ODS) de las Naciones Unidas.
+
+Identifica entre 3 y 5 Metas específicas de los ODS que tengan relación directa con la siguiente iniciativa:
+
+"{iniciativa}"
+
+Para cada meta incluye:
+- Código de la meta (ej: 4.2, 1.3, 16.10)
+- Descripción de la meta
+- Justificación breve del vínculo con la iniciativa
+
+FORMATO DE RESPUESTA (una línea por meta, ordenadas por relevancia):
+Meta [código]: [descripción] – [justificación]
+
+Responde ÚNICAMENTE con el listado, sin texto introductorio ni conclusiones."""
+
+
+PROMPT_INDICADOR = """Eres un experto en Objetivos de Desarrollo Sostenible (ODS) de las Naciones Unidas.
+
+Identifica entre 3 y 5 Indicadores de los ODS que permitan medir el impacto de la siguiente iniciativa:
+
+"{iniciativa}"
+
+Para cada indicador incluye:
+- Código del indicador (ej: 4.2.1, 1.3.1, 16.10.1)
+- Descripción del indicador
+- Justificación de cómo se relaciona con la medición de la iniciativa
+
+FORMATO DE RESPUESTA (una línea por indicador, ordenados por relevancia):
+Indicador [código]: [descripción] – [justificación]
+
+Responde ÚNICAMENTE con el listado, sin texto introductorio ni conclusiones."""
+
+PROMPTS = {
+    "ods": PROMPT_ODS,
+    "meta": PROMPT_META,
+    "indicador": PROMPT_INDICADOR
+}
+
+# =============================================================================
+# CELDA 5: Funciones de parsing por nivel
+# =============================================================================
+def parsear_ods(texto: str) -> list:
+    """Extrae ODS de la respuesta."""
+    items = []
+    for linea in texto.strip().split("\n"):
+        linea = linea.strip()
+        if not linea:
+            continue
+        match = re.match(r"(?:\d+[\.\)\-]?\s*)?ODS\s*(\d+):?\s*(.+)", linea, re.IGNORECASE)
+        if match:
+            ods_num = match.group(1)
+            resto = match.group(2).strip()
+            items.append({
+                "ods_id": f"ODS {ods_num}",
+                "objetivo": resto
+            })
+    return items
+
+
+def parsear_metas(texto: str) -> list:
+    """Extrae metas de la respuesta."""
+    items = []
+    for linea in texto.strip().split("\n"):
+        linea = linea.strip()
+        if not linea:
+            continue
+        match = re.match(r"(?:\d+[\.\)\-]?\s*)?Meta\s*([\d\.]+):?\s*(.+)", linea, re.IGNORECASE)
+        if match:
+            meta_codigo = match.group(1)
+            resto = match.group(2).strip()
+            ods_num = meta_codigo.split(".")[0]
+            items.append({
+                "ods_id": f"ODS {ods_num}",
+                "meta_id": f"Meta {meta_codigo}",
+                "objetivo": resto
+            })
+    return items
+
+
+def parsear_indicadores(texto: str) -> list:
+    """Extrae indicadores de la respuesta."""
+    items = []
+    for linea in texto.strip().split("\n"):
+        linea = linea.strip()
+        if not linea:
+            continue
+        match = re.match(r"(?:\d+[\.\)\-]?\s*)?Indicador\s*([\d\.]+):?\s*(.+)", linea, re.IGNORECASE)
+        if match:
+            ind_codigo = match.group(1)
+            resto = match.group(2).strip()
+            ods_num = ind_codigo.split(".")[0]
+            items.append({
+                "ods_id": f"ODS {ods_num}",
+                "indicador_id": f"Indicador {ind_codigo}",
+                "objetivo": resto
+            })
+    return items
+
+
+PARSERS = {
+    "ods": parsear_ods,
+    "meta": parsear_metas,
+    "indicador": parsear_indicadores
+}
+
+# =============================================================================
+# CELDA 6: Función de clasificación con fallback
+# =============================================================================
+def llamar_modelo(prompt: str, intentos_maximos: int = 3) -> str:
+    """Llama al modelo con reintentos y fallback."""
+    for modelo in MODELOS:
+        for intento in range(intentos_maximos):
+            try:
+                respuesta = client.chat_completion(
+                    model=modelo,
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=1200,
+                    temperature=0.3
+                )
+                return respuesta.choices[0].message.content
+            except Exception as e:
+                error_msg = str(e).lower()
+                # Si es rate limit, esperar y reintentar
+                if "rate" in error_msg or "limit" in error_msg or "429" in error_msg:
+                    wait_time = (intento + 1) * 5
+                    print(f"   ⏳ Rate limit, esperando {wait_time}s...")
+                    time.sleep(wait_time)
+                    continue
+                # Si es error de modelo, pasar al siguiente
+                elif "not supported" in error_msg or "not available" in error_msg:
+                    break
+                # Otros errores, reintentar
+                else:
+                    time.sleep(2)
+                    continue
+    
+    raise Exception("Todos los modelos fallaron")
+
+
+def clasificar_nivel(iniciativa: str, nivel: str) -> dict:
+    """Clasifica una iniciativa en un nivel específico (ods, meta, indicador)."""
+    prompt = PROMPTS[nivel].format(iniciativa=iniciativa)
+    parser = PARSERS[nivel]
+    
+    try:
+        texto = llamar_modelo(prompt)
+        items = parser(texto)
+        
+        return {
+            "iniciativa": iniciativa,
+            "items": items,
+            "respuesta_raw": texto,
+            "error": None
+        }
+    except Exception as e:
+        return {
+            "iniciativa": iniciativa,
+            "items": [],
+            "respuesta_raw": "",
+            "error": str(e)
+        }
+
+from sklearn.preprocessing import MinMaxScaler
+
+
+def normalizar_rank_df(dfs: dict) -> dict:
+    """
+    Normaliza las columnas de ranking ('ods_rank', 'meta_rank', 'indicador_rank')
+    en los DataFrames proporcionados en un diccionario usando Min-Max scaling.
+    Añade una nueva columna '_norm' para el rank normalizado.
+    """
+    # Ajustar el rango de normalización para evitar el 0
+    scaler = MinMaxScaler(feature_range=(0.0, 0.99))
+    df_actualizados = {}
+
+    for df_name, df in dfs.items():
+        if not df.empty:
+            df_temp = df.copy()
+            rank_column = None
+            if 'ods_rank' in df_temp.columns:
+                rank_column = 'ods_rank'
+            elif 'meta_rank' in df_temp.columns:
+                rank_column = 'meta_rank'
+            elif 'indicador_rank' in df_temp.columns:
+                rank_column = 'indicador_rank'
+
+            if rank_column:
+                print(rank_column)
+                # Asegurarse de que el rank_column es numérico y no tiene NaN que puedan causar problemas
+                df_temp[rank_column] = pd.to_numeric(df_temp[rank_column], errors='coerce')
+                df_temp.dropna(subset=[rank_column], inplace=True)
+
+                if not df_temp.empty and df_temp[rank_column].nunique() > 1:
+                    df_temp[f'{rank_column.replace('_rank','')}_similaridad_cos_normalized'] = scaler.fit_transform(df_temp[[rank_column]])
+                    df_temp[f'{rank_column.replace('_rank','')}_similaridad_cos_normalized'] = 1 - df_temp[f'{rank_column.replace('_rank','')}_similaridad_cos_normalized']
+                elif not df_temp.empty and df_temp[rank_column].nunique() == 1:
+                    df_temp[f'{rank_column.replace('_rank','')}_similaridad_cos_normalized'] = 0.5 # Asigna un valor medio si solo hay un valor único
+                    df_temp[f'{rank_column.replace('_rank','')}_similaridad_cos_normalized'] = 1 - df_temp[f'{rank_column.replace('_rank','')}_similaridad_cos_normalized']
+                else:
+                    df_temp[f'{rank_column.replace('_rank','')}_similaridad_cos_normalized'] = None # No se puede normalizar si está vacío o no numérico
+                    df_temp[f'{rank_column.replace('_rank','')}_similaridad_cos_normalized'] = 1 - df_temp[f'{rank_column.replace('_rank','')}_similaridad_cos_normalized']
+
+            df_actualizados[df_name] = df_temp
+        else:
+            df_actualizados[df_name] = df # Devolver el DataFrame vacío sin cambios
+
+    return df_actualizados
+
+
+def score_creator(df_pareto, nivel, sim_prop = 0, rank_prop = 0.6):
+    stats = df_pareto.groupby(f'{nivel.upper()}_ID').agg({
+        f'{nivel}_similaridad_cos_normalized': 'mean',
+        f'{nivel}_rank': 'mean',
+        'INICIATIVA_ID': 'count'
+    })
+    
+    # Normalizar componentes
+    stats['sim_norm'] = stats[f'{nivel}_similaridad_cos_normalized']
+    stats['rank_norm'] = 1 - (stats[f'{nivel}_rank'] - stats[f'{nivel}_rank'].min()) / (stats[f'{nivel}_rank'].max() - stats[f'{nivel}_rank'].min())
+    stats['freq_norm'] = stats['INICIATIVA_ID'] / stats['INICIATIVA_ID'].max()
+    
+    # Score mixto
+    stats['score'] = (
+        sim_prop * stats['sim_norm'] +
+        rank_prop * stats['rank_norm'] +
+        (1 - sim_prop - rank_prop) * stats['freq_norm']
+    )
+    
+    resultado = stats[['score', 'INICIATIVA_ID']].reset_index()
+    resultado = resultado.sort_values('score', ascending=False).reset_index().rename(columns={'INICIATIVA_ID': 'frecuencia', 
+                                                                                'index': 'rank'})
+    resultado['rank'] = resultado.index + 1
+
+    # Crear columna ODS_ID de forma robusta para todos los niveles
+    if nivel == 'ods':
+        # Para ODS, el ID ya es el ODS_ID
+        resultado['ODS_ID'] = resultado['ODS_ID'].astype(str)
+    elif nivel == 'meta':
+        # Extraer ODS del META_ID (formato: "1.1", tomar el primer dígito)
+        def extraer_ods_de_meta(meta_id):
+            try:
+                if pd.isna(meta_id):
+                    return None
+                ods_num = str(meta_id).split('.')[0].strip()
+                return ods_num if ods_num else None
+            except:
+                return None
+        resultado['ODS_ID'] = resultado['META_ID'].apply(extraer_ods_de_meta)
+    elif nivel == 'indicador':
+        # Extraer ODS del INDICADOR_ID (formato: "1.1.1", tomar el primer dígito)
+        def extraer_ods_de_indicador(ind_id):
+            try:
+                if pd.isna(ind_id):
+                    return None
+                ods_num = str(ind_id).split('.')[0].strip()
+                return ods_num if ods_num else None
+            except:
+                return None
+        resultado['ODS_ID'] = resultado['INDICADOR_ID'].apply(extraer_ods_de_indicador)
+
+
+    return resultado
+# =============================================================================
+# CELDA 7: Función principal de procesamiento por lotes
+# =============================================================================
+
+
+def procesar_lote(iniciativas: list, mostrar_progreso: bool = True) -> dict:
+    """
+    Procesa un listado de iniciativas y genera 3 DataFrames:
+    - df_ods: Clasificación a nivel ODS
+    - df_metas: Clasificación a nivel Meta
+    - df_indicadores: Clasificación a nivel Indicador
+
+    Columnas: INICIATIVA_ID, ODS_ID, OBJETIVO, ods_rank, iniciativa
+    """
+    niveles = ["ods", "meta", "indicador"]
+    resultados = {nivel: [] for nivel in niveles}
+
+    total = len(iniciativas) * len(niveles)
+    contador = 0
+
+    for idx, iniciativa in enumerate(iniciativas):
+        iniciativa_id = f"INI_{idx + 1:04d}"
+
+        for nivel in niveles:
+            contador += 1
+            if mostrar_progreso:
+                print(f"[{contador}/{total}] {iniciativa_id} - {nivel.upper()}: {iniciativa[:50]}...")
+
+            resultado = clasificar_nivel(iniciativa, nivel)
+
+            if resultado["error"]:
+                resultados[nivel].append({
+                    "INICIATIVA_ID": iniciativa_id,
+                    "ODS_ID": "ERROR",
+                    "OBJETIVO": resultado["error"],
+                    "ods_rank": 0,
+                    "iniciativa": iniciativa
+                })
+            else:
+                for rank, item in enumerate(resultado["items"], start=1):
+                  if nivel == "ods":
+                    fila = {
+                        "INICIATIVA_ID": iniciativa_id,
+                        "ODS_ID": item.get("ods_id", ""),
+                        "OBJETIVO": item.get("objetivo", ""),
+                        "ods_rank": rank,
+                        "iniciativa": iniciativa
+                    }
+                    resultados[nivel].append(fila)
+                  elif nivel == "meta":
+                    fila = {
+                        "INICIATIVA_ID": iniciativa_id,
+                        "ODS_ID": item.get("ods_id", ""),
+                        "META_ID": item.get("meta_id", ""),
+                        "OBJETIVO": item.get("objetivo", ""),
+                        "meta_rank": rank,
+                        "iniciativa": iniciativa
+                      }
+                    resultados[nivel].append(fila)
+                  elif nivel == "indicador":
+                    fila = {
+                        "INICIATIVA_ID": iniciativa_id,
+                        "ODS_ID": item.get("ods_id", ""),
+                        "INDICADOR_ID": item.get("indicador_id", ""),
+                        "OBJETIVO": item.get("objetivo", ""),
+                        "indicador_rank": rank,
+                        "iniciativa": iniciativa
+                      }
+                    resultados[nivel].append(fila)
+            # Pausa para evitar rate limits
+            time.sleep(1)
+
+    # Crear DataFrames
+    df_ods = pd.DataFrame(resultados["ods"])
+    if not df_ods.empty:
+        df_ods = df_ods[["INICIATIVA_ID", "ODS_ID", "OBJETIVO", "ods_rank", "iniciativa"]]
+
+    df_metas = pd.DataFrame(resultados["meta"])
+    if not df_metas.empty:
+        df_metas = df_metas[["INICIATIVA_ID", "ODS_ID", "META_ID","OBJETIVO", "meta_rank", "iniciativa"]]
+
+    df_indicadores = pd.DataFrame(resultados["indicador"])
+    if not df_indicadores.empty:
+        df_indicadores = df_indicadores[["INICIATIVA_ID", "ODS_ID", "INDICADOR_ID", "OBJETIVO", "indicador_rank", "iniciativa"]]
+
+    dfs = {
+            "df_ods": df_ods,
+            "df_metas": df_metas,
+            "df_indicadores": df_indicadores
+        }
+    dfs = normalizar_rank_df(dfs)
+    dfs['df_ods'] = score_creator(dfs['df_ods'], 'ods')
+    dfs['df_metas'] = score_creator(dfs['df_metas'], 'meta')
+    dfs['df_indicadores'] = score_creator(dfs['df_indicadores'], 'indicador')
+    return dfs['df_ods'], dfs['df_metas'], dfs['df_indicadores']
+
+# =============================================================================
+# CELDA 8: Prueba con listado de ejemplo
+# =============================================================================
+# iniciativas_prueba = [
+#     "Implementación de programas de atención integral a la primera infancia de manera itinerante en zona rural del municipio de Pradera, en función del cumplimiento de los derechos de la primera infancia",
+#     "Instalación de paneles solares en comunidades sin acceso a electricidad para garantizar energía limpia y sostenible",
+#     "Capacitación digital para mujeres emprendedoras rurales orientada a fortalecer sus habilidades tecnológicas y comerciales",
+#     "Construcción de viviendas dignas para familias víctimas del conflicto armado en proceso de reincorporación"
+# ]
+
+# print(f"Procesando {len(iniciativas_prueba)} iniciativas...\n")
+# resultado = procesar_lote(iniciativas_prueba)
+
+# =============================================================================
+# CELDA 9: Visualizar resultados
+# =============================================================================
+# print("\n" + "="*80)
+# print("📊 NIVEL ODS")
+# print("="*80)
+# display(resultado["df_ods"])
+
+# print("\n" + "="*80)
+# print("📊 NIVEL METAS")
+# print("="*80)
+# display(resultado["df_metas"])
+
+# print("\n" + "="*80)
+# print("📊 NIVEL INDICADORES")
+# print("="*80)
+# display(resultado["df_indicadores"])
+
+# =============================================================================
+# CELDA 10: Exportar a Excel
+# =============================================================================
+# output_file = "clasificacion_ods_por_niveles.xlsx"
+
+# with pd.ExcelWriter(output_file, engine="openpyxl") as writer:
+#     resultado["df_ods"].to_excel(writer, sheet_name="ODS", index=False)
+#     resultado["df_metas"].to_excel(writer, sheet_name="Metas", index=False)
+#     resultado["df_indicadores"].to_excel(writer, sheet_name="Indicadores", index=False)
+
+# print(f"\n✅ Archivo guardado: {output_file}")
+
+# Descargar en Colab
+# from google.colab import files
+# files.download(output_file)
+
+# =============================================================================
+# CELDA 11: Función para cargar desde archivo externo
+# =============================================================================
+# def procesar_desde_archivo(columna_iniciativa: str = None):
+#     """
+#     Carga iniciativas desde un archivo CSV/Excel subido y las procesa.
+    
+#     Uso:
+#         resultado = procesar_desde_archivo()
+#         # o especificando la columna:
+#         resultado = procesar_desde_archivo(columna_iniciativa="descripcion")
+#     """
+#     # from google.colab import files
+    
+#     print("📁 Sube tu archivo CSV o Excel...")
+#     uploaded = files.upload()
+    
+#     if not uploaded:
+#         print("No se subió ningún archivo.")
+#         return None
+    
+#     archivo = list(uploaded.keys())[0]
+#     print(f"Archivo cargado: {archivo}")
+    
+#     # Leer archivo
+#     if archivo.endswith(".csv"):
+#         df = pd.read_csv(archivo)
+#     else:
+#         df = pd.read_excel(archivo)
+    
+#     print(f"Columnas disponibles: {list(df.columns)}")
+    
+#     # Detectar columna si no se especifica
+#     if columna_iniciativa is None:
+#         for col in df.columns:
+#             if any(x in col.lower() for x in ["iniciativa", "descripcion", "nombre", "proyecto", "programa"]):
+#                 columna_iniciativa = col
+#                 break
+#         if columna_iniciativa is None:
+#             columna_iniciativa = df.columns[0]
+    
+#     print(f"Usando columna: '{columna_iniciativa}'")
+#     print(f"Total iniciativas: {len(df)}")
+    
+#     # Procesar
+#     iniciativas = df[columna_iniciativa].astype(str).tolist()
+#     return procesar_lote(iniciativas)
+
+
+# # Ejemplo de uso:
+# # resultado = procesar_desde_archivo()
+# ```
+
+# ## Características del código actualizado
+
+# | Característica | Descripción |
+# |----------------|-------------|
+# | **Fallback automático** | Si un modelo falla, prueba el siguiente |
+# | **Reintentos** | 3 intentos por modelo antes de cambiar |
+# | **Rate limit handling** | Espera progresiva si hay límites |
+# | **Verificación inicial** | Prueba qué modelos están disponibles |
+# | **Modelos ordenados** | De más potente a más ligero |
+
+# ## Estructura de salida
+
+# Los 3 DataFrames tendrán estas columnas:
+# ```
+# df_ods:         INICIATIVA_ID | ODS_ID | OBJETIVO | ods_rank | iniciativa
+# df_metas:       INICIATIVA_ID | ODS_ID | OBJETIVO | ods_rank | iniciativa  
+# df_indicadores: INICIATIVA_ID | ODS_ID | OBJETIVO | ods_rank | iniciativa