Update src/embeddings/llm_clasificador_HF_gem.py

src/embeddings/llm_clasificador_HF_gem.py

@@ -1,869 +1,870 @@
-# =============================================================================
-# CELDA 1: Instalar dependencias
-# =============================================================================
-# !pip install huggingface_hub pandas openpyxl
-
-# =============================================================================
-# CELDA 2: Configuración Gemini
-# =============================================================================
-from google import genai
-from google.genai import types
-import pandas as pd
-import re
-import time
-
-# Obtén tu API key en: https://aistudio.google.com/app/apikey
-
-
-client = genai.Client(api_key=GOOGLE_API_KEY)
-
-# Modelos gratuitos disponibles (de más potente a más ligero)
-MODELOS = [
-    "gemini-2.5-flash-lite", # Más económico, buena opción para pruebas rápidas
-    "gemini-2.5-flash",       # Más reciente, muy bueno
-    "gemini-2.0-flash",       # Estable
-    "gemini-2.0-flash-lite",  # Más económico
-]
-
-# =============================================================================
-# CELDA 3: Verificar modelos disponibles
-# =============================================================================
-def verificar_modelos():
-    """Lista modelos disponibles y verifica cuál funciona."""
-    print("Verificando modelos disponibles...\n")
-    
-    for modelo in MODELOS:
-        try:
-            response = client.models.generate_content(
-                model=modelo,
-                contents="Responde únicamente: OK"
-            )
-            print(f"✅ {modelo}: Disponible")
-            return modelo
-        except Exception as e:
-            print(f"❌ {modelo}: {str(e)[:60]}")
-    
-    return None
-
-MODELO_ACTIVO = verificar_modelos()
-
-if MODELO_ACTIVO:
-    print(f"\n🎯 Modelo seleccionado: {MODELO_ACTIVO}")
-else:
-    print("\n⚠️ Ningún modelo disponible. Verifica tu API key.")
-
-# =============================================================================
-# CELDA 4: Prompts por nivel
-# =============================================================================
-PROMPT_ODS = """Eres un experto en Objetivos de Desarrollo Sostenible (ODS) de las Naciones Unidas.
-
-Vincula entre 4 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 4 y 6 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 (dos niveles estrictos 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_META_TOP = """Eres un experto en Objetivos de Desarrollo Sostenible (ODS) de las Naciones Unidas.
-
-Identifica 2 Metas específicas del ODS {ods} que tengan relación directa con la siguiente iniciativa:
-
-"{iniciativa}"
-
-Para cada meta incluye:
-- Código de la meta (estructura de dos niveles estrictos 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,
-    "meta_top": PROMPT_META_TOP,
-    "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_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)
-            meta_codigo = f'{meta_codigo.split(".")[0]}.{meta_codigo.split(".")[1]}'
-            resto = match.group(2).strip()
-            ods_num = meta_codigo.split(".")[0]
-            items.append({
-                "ods_id": f"{ods_num}",
-                "meta_id": f"{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_num}",
-                "indicador_id": f"{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 llamar_modelo(prompt: str, intentos_maximos: int = 3) -> str:
-    """Llama a Gemini con reintentos."""
-    for intento in range(intentos_maximos):
-        try:
-            response = client.models.generate_content(
-                model=MODELO_ACTIVO,
-                contents=prompt,
-                config=types.GenerateContentConfig(
-                    max_output_tokens=1200,
-                    temperature=0.3
-                )
-            )
-            return response.text
-        except Exception as e:
-            error_msg = str(e).lower()
-            if "quota" in error_msg or "rate" in error_msg or "429" in error_msg:
-                wait_time = (intento + 1) * 10
-                print(f"   ⏳ Rate limit, esperando {wait_time}s...")
-                time.sleep(wait_time)
-            else:
-                raise e
-    
-    raise Exception("Máximo de intentos alcanzado")
-
-
-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)
-        }
-
-def clasificar_nivel_meta_top(iniciativa: str, ods: int, nivel: str) -> dict:
-    """Clasifica una iniciativa en metas específicas del ODS proporcionado."""
-    # Inicializar HF la primera vez que se usa
-    inicializar_hf()
-    
-    prompt = PROMPTS[nivel].format(ods=ods, iniciativa=iniciativa)
-    parser = PARSERS[nivel]
-    
-    try:
-        texto = llamar_modelo(prompt)
-        items = parser(texto)
-        
-        return {
-            "iniciativa": iniciativa,
-            "ods": ods,
-            "items": items,
-            "respuesta_raw": texto,
-            "error": None
-        }
-    except Exception as e:
-        return {
-            "iniciativa": iniciativa,
-            "ods": ods,
-            "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 '_normalized' para el rank normalizado.
-    
-    Maneja casos especiales:
-    - DataFrames vacíos
-    - Valores faltantes
-    - Un único valor único
-    """
-    # 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 df.empty:
-            print(f"⚠️  {df_name} está vacío")
-            df_actualizados[df_name] = df
-            continue
-            
-        df_temp = df.copy()
-        rank_column = None
-        
-        # Identificar la columna de rank
-        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(f"✅ Normalizando {df_name} usando {rank_column}")
-            
-            try:
-                # Asegurarse de que el rank_column es numérico
-                df_temp[rank_column] = pd.to_numeric(df_temp[rank_column], errors='coerce')
-                
-                # Contar valores no nulos antes de dropna
-                valores_validos = df_temp[rank_column].notna().sum()
-                
-                if valores_validos == 0:
-                    print(f"⚠️  {df_name}: Todos los valores de {rank_column} son NaN")
-                    # Crear columna de similaridad con valores por defecto
-                    nivel_name = rank_column.replace('_rank', '')
-                    df_temp[f"{nivel_name}_similaridad_cos_normalized"] = 0.5
-                else:
-                    # Eliminar solo los NaN, no resetear el índice aún
-                    df_temp = df_temp.dropna(subset=[rank_column])
-                    
-                    if df_temp.empty:
-                        print(f"⚠️  {df_name}: Vacío después de eliminar NaN")
-                        continue
-                    
-                    nivel_name = rank_column.replace('_rank', '')
-                    
-                    # Normalizar según el número de valores únicos
-                    if df_temp[rank_column].nunique() > 1:
-                        df_temp[f"{nivel_name}_similaridad_cos_normalized"] = scaler.fit_transform(df_temp[[rank_column]])
-                        df_temp[f"{nivel_name}_similaridad_cos_normalized"] = 1 - df_temp[f"{nivel_name}_similaridad_cos_normalized"]
-                    elif df_temp[rank_column].nunique() == 1:
-                        # Un único valor: asignar 0.5
-                        df_temp[f"{nivel_name}_similaridad_cos_normalized"] = 0.5
-                    else:
-                        # Sin valores válidos
-                        df_temp[f"{nivel_name}_similaridad_cos_normalized"] = 0.5
-                    
-            except Exception as e:
-                print(f"❌ Error normalizando {df_name}: {str(e)}")
-                # Crear columna con valor por defecto
-                nivel_name = rank_column.replace('_rank', '')
-                df_temp[f"{nivel_name}_similaridad_cos_normalized"] = 0.5
-
-        df_actualizados[df_name] = df_temp
-
-    return df_actualizados
-
-
-def score_creator(df_pareto, nivel, sim_prop = 0, rank_prop = 0.6):
-    """
-    Crea scores para ranking de ODS/Metas/Indicadores.
-    Maneja DataFrames vacíos y columnas faltantes de forma robusta.
-    """
-    # Verificar si el DataFrame está vacío
-    if df_pareto.empty:
-        print(f"⚠️  DataFrame vacío para nivel: {nivel}")
-        return df_pareto
-    
-    # Construir nombres de columnas esperadas
-    id_column = f'{nivel.upper()}_ID'
-    sim_column = f'{nivel}_similaridad_cos_normalized'
-    rank_column = f'{nivel}_rank'
-    
-    # Verificar que las columnas necesarias existan
-    columnas_faltantes = []
-    for col in [id_column, sim_column, rank_column, 'INICIATIVA_ID']:
-        if col not in df_pareto.columns:
-            columnas_faltantes.append(col)
-    
-    if columnas_faltantes:
-        print(f"⚠️  Columnas faltantes en {nivel}: {columnas_faltantes}")
-        print(f"   Columnas disponibles: {list(df_pareto.columns)}")
-        return df_pareto
-    
-    try:
-        stats = df_pareto.groupby(id_column).agg({
-            sim_column: 'mean',
-            rank_column: 'mean',
-            'INICIATIVA_ID': 'count'
-        })
-        
-        # Normalizar componentes
-        stats['sim_norm'] = stats[sim_column]
-        stats['rank_norm'] = 1 - (stats[rank_column] - stats[rank_column].min()) / (stats[rank_column].max() - stats[rank_column].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
-    
-    except Exception as e:
-        print(f"❌ Error en score_creator para {nivel}: {str(e)}")
-        print(f"   DataFrame shape: {df_pareto.shape}")
-        print(f"   Columnas: {list(df_pareto.columns)}")
-        return df_pareto
-# =============================================================================
-# CELDA 7: Función principal de procesamiento por lotes
-# =============================================================================
-
-
-def procesar_lote_llm(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
-    """
-    print("\n" + "="*70)
-    print("🚀 INICIANDO PROCESAMIENTO POR LOTES")
-    print("="*70)
-    print(f"Total iniciativas: {len(iniciativas)}")
-    print()
-    
-    niveles = ["ods", "meta"]
-    resultados = {nivel: [] for nivel in niveles}
-
-    total = len(iniciativas) * len(niveles)
-    contador = 0
-    errores_totales = 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]}...")
-
-            # Sistema de reintentos
-            max_reintentos = 3
-            intento = 0
-            resultado = None
-            
-            while intento < max_reintentos:
-                intento += 1
-                resultado = clasificar_nivel(iniciativa, nivel)
-                
-                # Éxito: tenemos respuesta sin error y con items
-                if not resultado["error"] and len(resultado["items"]) > 0:
-                    print(f"   ✅ {len(resultado['items'])} items encontrados (intento {intento})")
-                    break
-                
-                # Si hay error o sin items, reintenta (excepto en el último intento)
-                if intento < max_reintentos:
-                    if resultado["error"]:
-                        print(f"   ⚠️  Reintentando... (error: {resultado['error'][:40]}...)")
-                    else:
-                        print(f"   ⚠️  Reintentando... (sin items encontrados)")
-                    time.sleep(2)  # Espera antes de reintentar
-
-            # Procesar resultado final después de reintentos
-            if resultado["error"]:
-                errores_totales += 1
-                print(f"   ❌ Error persistente en {nivel.upper()} tras {max_reintentos} intentos: {resultado['error'][:60]}")
-                resultados[nivel].append({
-                    "INICIATIVA_ID": iniciativa_id,
-                    "ODS_ID": "ERROR",
-                    "OBJETIVO": resultado["error"],
-                    "ods_rank": 0,
-                    "iniciativa": iniciativa
-                })
-            else:
-                items_count = len(resultado["items"])
-                if items_count == 0:
-                    print(f"   ⚠️  Sin items encontrados en {nivel.upper()} tras {max_reintentos} intentos")
-                    print(f"      Raw response: {resultado['respuesta_raw'][:100]}")
-                
-                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)
-
-    # Mostrar resumen
-    print()
-    print("="*70)
-    print("📊 RESUMEN DE RESULTADOS")
-    print("="*70)
-    print(f"Total errores: {errores_totales}")
-    for nivel in niveles:
-        print(f"  - {nivel.upper()}: {len(resultados[nivel])} registros")
-    print()
-
-    # 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"]]
-        print(f"✅ df_ods: {len(df_ods)} registros")
-    else:
-        print(f"⚠️  df_ods está vacío - revisar respuestas del modelo")
-
-    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"]]
-        print(f"✅ df_metas: {len(df_metas)} registros")
-    else:
-        print(f"⚠️  df_metas está vacío - revisar respuestas del modelo")
-
-    df_indicadores = pd.DataFrame(columns=["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')
-    
-    print()
-    print("="*70)
-    print("✅ PROCESAMIENTO COMPLETADO")
-    print("="*70)
-    print()
-    
-    return dfs['df_ods'], dfs['df_metas'], dfs['df_indicadores'], 'Ejecución completada'
-
-def procesar_lote_llm_top(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"]
-    # niveles = ["ods", "meta"]
-    resultados = {nivel: [] for nivel in niveles}
-
-    total = len(iniciativas) * len(niveles)
-    
-
-    for nivel in niveles:
-        contador = 0
-        if nivel == "ods":
-            for idx, iniciativa in enumerate(iniciativas):
-                iniciativa_id = f"INI_{idx + 1:04d}" 
-            
-                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)
-                # 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"]]
-                
-        elif nivel == "meta":
-            for idx, iniciativa in enumerate(iniciativas):
-                iniciativa_id = f"INI_{idx + 1:04d}" 
-            
-                contador += 1
-                if mostrar_progreso:
-                    print(f"[{contador}/{total}] {iniciativa_id} - {nivel.upper()}: {iniciativa[:50]}...")
-    
-                
-                for ods in df_ods['ODS_ID'].unique().tolist():
-                    
-                    resultado = clasificar_nivel_meta_top(iniciativa, ods, 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):                    
-                            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)
-                    # Pausa para evitar rate limits
-                    time.sleep(1)
-            # Crear DataFrames
-            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"]]
-
-                            
-    #                       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)
-
-    
-
-    
-
-    df_indicadores = pd.DataFrame(columns=["INICIATIVA_ID", "ODS_ID", "INDICADOR_ID", "OBJETIVO", "indicador_rank", "iniciativa"])
-    # if not df_indicadores.empty:
-    #     df_indicadores = df_indicadores[["INICIATIVA_ID", "ODS_ID", "INDICADOR_ID", "OBJETIVO", "indicador_rank", "iniciativa"]]
-    #     print(df_indicadores.columns)
-
-    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')
-    print(dfs['df_indicadores'].columns)
-    dfs['df_indicadores'] = score_creator(dfs['df_indicadores'], 'indicador')
-    return dfs['df_ods'], dfs['df_metas'], dfs['df_indicadores'], 'Ejecución completada'
-
-# =============================================================================
-# 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  
+# =============================================================================
+# CELDA 1: Instalar dependencias
+# =============================================================================
+# !pip install huggingface_hub pandas openpyxl
+
+# =============================================================================
+# CELDA 2: Configuración Gemini
+# =============================================================================
+from google import genai
+from google.genai import types
+import pandas as pd
+import re
+import time
+
+# Obtén tu API key en: https://aistudio.google.com/app/apikey
+
+api_key = os.getenv("GOOGLE_API_KEY")
+client = genai.Client(api_key=api_key)
+# api_key = os.getenv("GOOGLE_API_KEY")
+
+# Modelos gratuitos disponibles (de más potente a más ligero)
+MODELOS = [
+    "gemini-2.5-flash-lite", # Más económico, buena opción para pruebas rápidas
+    "gemini-2.5-flash",       # Más reciente, muy bueno
+    "gemini-2.0-flash",       # Estable
+    "gemini-2.0-flash-lite",  # Más económico
+]
+
+# =============================================================================
+# CELDA 3: Verificar modelos disponibles
+# =============================================================================
+def verificar_modelos():
+    """Lista modelos disponibles y verifica cuál funciona."""
+    print("Verificando modelos disponibles...\n")
+    
+    for modelo in MODELOS:
+        try:
+            response = client.models.generate_content(
+                model=modelo,
+                contents="Responde únicamente: OK"
+            )
+            print(f"✅ {modelo}: Disponible")
+            return modelo
+        except Exception as e:
+            print(f"❌ {modelo}: {str(e)[:60]}")
+    
+    return None
+
+MODELO_ACTIVO = verificar_modelos()
+
+if MODELO_ACTIVO:
+    print(f"\n🎯 Modelo seleccionado: {MODELO_ACTIVO}")
+else:
+    print("\n⚠️ Ningún modelo disponible. Verifica tu API key.")
+
+# =============================================================================
+# CELDA 4: Prompts por nivel
+# =============================================================================
+PROMPT_ODS = """Eres un experto en Objetivos de Desarrollo Sostenible (ODS) de las Naciones Unidas.
+
+Vincula entre 4 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 4 y 6 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 (dos niveles estrictos 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_META_TOP = """Eres un experto en Objetivos de Desarrollo Sostenible (ODS) de las Naciones Unidas.
+
+Identifica 2 Metas específicas del ODS {ods} que tengan relación directa con la siguiente iniciativa:
+
+"{iniciativa}"
+
+Para cada meta incluye:
+- Código de la meta (estructura de dos niveles estrictos 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,
+    "meta_top": PROMPT_META_TOP,
+    "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_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)
+            meta_codigo = f'{meta_codigo.split(".")[0]}.{meta_codigo.split(".")[1]}'
+            resto = match.group(2).strip()
+            ods_num = meta_codigo.split(".")[0]
+            items.append({
+                "ods_id": f"{ods_num}",
+                "meta_id": f"{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_num}",
+                "indicador_id": f"{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 llamar_modelo(prompt: str, intentos_maximos: int = 3) -> str:
+    """Llama a Gemini con reintentos."""
+    for intento in range(intentos_maximos):
+        try:
+            response = client.models.generate_content(
+                model=MODELO_ACTIVO,
+                contents=prompt,
+                config=types.GenerateContentConfig(
+                    max_output_tokens=1200,
+                    temperature=0.3
+                )
+            )
+            return response.text
+        except Exception as e:
+            error_msg = str(e).lower()
+            if "quota" in error_msg or "rate" in error_msg or "429" in error_msg:
+                wait_time = (intento + 1) * 10
+                print(f"   ⏳ Rate limit, esperando {wait_time}s...")
+                time.sleep(wait_time)
+            else:
+                raise e
+    
+    raise Exception("Máximo de intentos alcanzado")
+
+
+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)
+        }
+
+def clasificar_nivel_meta_top(iniciativa: str, ods: int, nivel: str) -> dict:
+    """Clasifica una iniciativa en metas específicas del ODS proporcionado."""
+    # Inicializar HF la primera vez que se usa
+    inicializar_hf()
+    
+    prompt = PROMPTS[nivel].format(ods=ods, iniciativa=iniciativa)
+    parser = PARSERS[nivel]
+    
+    try:
+        texto = llamar_modelo(prompt)
+        items = parser(texto)
+        
+        return {
+            "iniciativa": iniciativa,
+            "ods": ods,
+            "items": items,
+            "respuesta_raw": texto,
+            "error": None
+        }
+    except Exception as e:
+        return {
+            "iniciativa": iniciativa,
+            "ods": ods,
+            "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 '_normalized' para el rank normalizado.
+    
+    Maneja casos especiales:
+    - DataFrames vacíos
+    - Valores faltantes
+    - Un único valor único
+    """
+    # 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 df.empty:
+            print(f"⚠️  {df_name} está vacío")
+            df_actualizados[df_name] = df
+            continue
+            
+        df_temp = df.copy()
+        rank_column = None
+        
+        # Identificar la columna de rank
+        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(f"✅ Normalizando {df_name} usando {rank_column}")
+            
+            try:
+                # Asegurarse de que el rank_column es numérico
+                df_temp[rank_column] = pd.to_numeric(df_temp[rank_column], errors='coerce')
+                
+                # Contar valores no nulos antes de dropna
+                valores_validos = df_temp[rank_column].notna().sum()
+                
+                if valores_validos == 0:
+                    print(f"⚠️  {df_name}: Todos los valores de {rank_column} son NaN")
+                    # Crear columna de similaridad con valores por defecto
+                    nivel_name = rank_column.replace('_rank', '')
+                    df_temp[f"{nivel_name}_similaridad_cos_normalized"] = 0.5
+                else:
+                    # Eliminar solo los NaN, no resetear el índice aún
+                    df_temp = df_temp.dropna(subset=[rank_column])
+                    
+                    if df_temp.empty:
+                        print(f"⚠️  {df_name}: Vacío después de eliminar NaN")
+                        continue
+                    
+                    nivel_name = rank_column.replace('_rank', '')
+                    
+                    # Normalizar según el número de valores únicos
+                    if df_temp[rank_column].nunique() > 1:
+                        df_temp[f"{nivel_name}_similaridad_cos_normalized"] = scaler.fit_transform(df_temp[[rank_column]])
+                        df_temp[f"{nivel_name}_similaridad_cos_normalized"] = 1 - df_temp[f"{nivel_name}_similaridad_cos_normalized"]
+                    elif df_temp[rank_column].nunique() == 1:
+                        # Un único valor: asignar 0.5
+                        df_temp[f"{nivel_name}_similaridad_cos_normalized"] = 0.5
+                    else:
+                        # Sin valores válidos
+                        df_temp[f"{nivel_name}_similaridad_cos_normalized"] = 0.5
+                    
+            except Exception as e:
+                print(f"❌ Error normalizando {df_name}: {str(e)}")
+                # Crear columna con valor por defecto
+                nivel_name = rank_column.replace('_rank', '')
+                df_temp[f"{nivel_name}_similaridad_cos_normalized"] = 0.5
+
+        df_actualizados[df_name] = df_temp
+
+    return df_actualizados
+
+
+def score_creator(df_pareto, nivel, sim_prop = 0, rank_prop = 0.6):
+    """
+    Crea scores para ranking de ODS/Metas/Indicadores.
+    Maneja DataFrames vacíos y columnas faltantes de forma robusta.
+    """
+    # Verificar si el DataFrame está vacío
+    if df_pareto.empty:
+        print(f"⚠️  DataFrame vacío para nivel: {nivel}")
+        return df_pareto
+    
+    # Construir nombres de columnas esperadas
+    id_column = f'{nivel.upper()}_ID'
+    sim_column = f'{nivel}_similaridad_cos_normalized'
+    rank_column = f'{nivel}_rank'
+    
+    # Verificar que las columnas necesarias existan
+    columnas_faltantes = []
+    for col in [id_column, sim_column, rank_column, 'INICIATIVA_ID']:
+        if col not in df_pareto.columns:
+            columnas_faltantes.append(col)
+    
+    if columnas_faltantes:
+        print(f"⚠️  Columnas faltantes en {nivel}: {columnas_faltantes}")
+        print(f"   Columnas disponibles: {list(df_pareto.columns)}")
+        return df_pareto
+    
+    try:
+        stats = df_pareto.groupby(id_column).agg({
+            sim_column: 'mean',
+            rank_column: 'mean',
+            'INICIATIVA_ID': 'count'
+        })
+        
+        # Normalizar componentes
+        stats['sim_norm'] = stats[sim_column]
+        stats['rank_norm'] = 1 - (stats[rank_column] - stats[rank_column].min()) / (stats[rank_column].max() - stats[rank_column].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
+    
+    except Exception as e:
+        print(f"❌ Error en score_creator para {nivel}: {str(e)}")
+        print(f"   DataFrame shape: {df_pareto.shape}")
+        print(f"   Columnas: {list(df_pareto.columns)}")
+        return df_pareto
+# =============================================================================
+# CELDA 7: Función principal de procesamiento por lotes
+# =============================================================================
+
+
+def procesar_lote_llm(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
+    """
+    print("\n" + "="*70)
+    print("🚀 INICIANDO PROCESAMIENTO POR LOTES")
+    print("="*70)
+    print(f"Total iniciativas: {len(iniciativas)}")
+    print()
+    
+    niveles = ["ods", "meta"]
+    resultados = {nivel: [] for nivel in niveles}
+
+    total = len(iniciativas) * len(niveles)
+    contador = 0
+    errores_totales = 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]}...")
+
+            # Sistema de reintentos
+            max_reintentos = 3
+            intento = 0
+            resultado = None
+            
+            while intento < max_reintentos:
+                intento += 1
+                resultado = clasificar_nivel(iniciativa, nivel)
+                
+                # Éxito: tenemos respuesta sin error y con items
+                if not resultado["error"] and len(resultado["items"]) > 0:
+                    print(f"   ✅ {len(resultado['items'])} items encontrados (intento {intento})")
+                    break
+                
+                # Si hay error o sin items, reintenta (excepto en el último intento)
+                if intento < max_reintentos:
+                    if resultado["error"]:
+                        print(f"   ⚠️  Reintentando... (error: {resultado['error'][:40]}...)")
+                    else:
+                        print(f"   ⚠️  Reintentando... (sin items encontrados)")
+                    time.sleep(2)  # Espera antes de reintentar
+
+            # Procesar resultado final después de reintentos
+            if resultado["error"]:
+                errores_totales += 1
+                print(f"   ❌ Error persistente en {nivel.upper()} tras {max_reintentos} intentos: {resultado['error'][:60]}")
+                resultados[nivel].append({
+                    "INICIATIVA_ID": iniciativa_id,
+                    "ODS_ID": "ERROR",
+                    "OBJETIVO": resultado["error"],
+                    "ods_rank": 0,
+                    "iniciativa": iniciativa
+                })
+            else:
+                items_count = len(resultado["items"])
+                if items_count == 0:
+                    print(f"   ⚠️  Sin items encontrados en {nivel.upper()} tras {max_reintentos} intentos")
+                    print(f"      Raw response: {resultado['respuesta_raw'][:100]}")
+                
+                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)
+
+    # Mostrar resumen
+    print()
+    print("="*70)
+    print("📊 RESUMEN DE RESULTADOS")
+    print("="*70)
+    print(f"Total errores: {errores_totales}")
+    for nivel in niveles:
+        print(f"  - {nivel.upper()}: {len(resultados[nivel])} registros")
+    print()
+
+    # 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"]]
+        print(f"✅ df_ods: {len(df_ods)} registros")
+    else:
+        print(f"⚠️  df_ods está vacío - revisar respuestas del modelo")
+
+    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"]]
+        print(f"✅ df_metas: {len(df_metas)} registros")
+    else:
+        print(f"⚠️  df_metas está vacío - revisar respuestas del modelo")
+
+    df_indicadores = pd.DataFrame(columns=["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')
+    
+    print()
+    print("="*70)
+    print("✅ PROCESAMIENTO COMPLETADO")
+    print("="*70)
+    print()
+    
+    return dfs['df_ods'], dfs['df_metas'], dfs['df_indicadores'], 'Ejecución completada'
+
+def procesar_lote_llm_top(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"]
+    # niveles = ["ods", "meta"]
+    resultados = {nivel: [] for nivel in niveles}
+
+    total = len(iniciativas) * len(niveles)
+    
+
+    for nivel in niveles:
+        contador = 0
+        if nivel == "ods":
+            for idx, iniciativa in enumerate(iniciativas):
+                iniciativa_id = f"INI_{idx + 1:04d}" 
+            
+                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)
+                # 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"]]
+                
+        elif nivel == "meta":
+            for idx, iniciativa in enumerate(iniciativas):
+                iniciativa_id = f"INI_{idx + 1:04d}" 
+            
+                contador += 1
+                if mostrar_progreso:
+                    print(f"[{contador}/{total}] {iniciativa_id} - {nivel.upper()}: {iniciativa[:50]}...")
+    
+                
+                for ods in df_ods['ODS_ID'].unique().tolist():
+                    
+                    resultado = clasificar_nivel_meta_top(iniciativa, ods, 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):                    
+                            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)
+                    # Pausa para evitar rate limits
+                    time.sleep(1)
+            # Crear DataFrames
+            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"]]
+
+                            
+    #                       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)
+
+    
+
+    
+
+    df_indicadores = pd.DataFrame(columns=["INICIATIVA_ID", "ODS_ID", "INDICADOR_ID", "OBJETIVO", "indicador_rank", "iniciativa"])
+    # if not df_indicadores.empty:
+    #     df_indicadores = df_indicadores[["INICIATIVA_ID", "ODS_ID", "INDICADOR_ID", "OBJETIVO", "indicador_rank", "iniciativa"]]
+    #     print(df_indicadores.columns)
+
+    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')
+    print(dfs['df_indicadores'].columns)
+    dfs['df_indicadores'] = score_creator(dfs['df_indicadores'], 'indicador')
+    return dfs['df_ods'], dfs['df_metas'], dfs['df_indicadores'], 'Ejecución completada'
+
+# =============================================================================
+# 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