"""Model loading and prediction functions for IF + LOF unsupervised detection.""" import joblib import numpy as np import pandas as pd import streamlit as st from .config import ( DATOS_CLIENTES_PATH, DATOS_COORDENADAS_PATH, DATOS_MODELO_PATH, PIPELINE_IF_PATH, PIPELINE_LOF_PATH, PIPELINE_PU_PATH, MODELO_REGRESION_PATH, VARIABLES_NUMERICAS, VARIABLES_CATEGORICAS, VARIABLES_TEMPORALES, VARIABLES_ESTATICAS, FEATURELIST, CAMPOS_DISPLAY, VENTANA_MESES, NIVELES_RIESGO, VENTANAS_PU, BASE_FEATURES_TEMPORALES_PU, NIVELES_RIESGO_PU, ) # ============================================= # CARGA DE DATOS Y MODELOS (cacheados) # ============================================= @st.cache_resource def cargar_pipelines(): """Carga los pipelines de IF, LOF y PU Bagging.""" try: pipeline_if = joblib.load(PIPELINE_IF_PATH) pipeline_lof = joblib.load(PIPELINE_LOF_PATH) pipelines = { 'if': { 'preprocessor': pipeline_if['preprocessor'], 'model': pipeline_if['model'], 'feature_importance': pipeline_if.get('feature_importance', {}), }, 'lof': { 'preprocessor': pipeline_lof['preprocessor'], 'pca_reducer': pipeline_lof['pca_reducer'], 'model': pipeline_lof['model'], 'feature_importance': pipeline_lof.get('feature_importance', {}), }, } # PU Bagging: pipeline opcional, no debe romper IF/LOF si falla. # Artefacto interno del proyecto (entrenado en models_unsuper_super_multivent.ipynb), # no es input externo no confiable. Si falla, se guarda el motivo en # 'pu_error' para que la UI lo muestre (en vez de fallar en silencio). try: pipelines['pu'] = joblib.load(PIPELINE_PU_PATH) pipelines['pu_error'] = None except Exception as e: pipelines['pu'] = None pipelines['pu_error'] = str(e) return pipelines, None except Exception as e: return None, str(e) @st.cache_resource def cargar_modelo(path): """Carga un modelo/pipeline de sklearn usando joblib.""" try: modelo = joblib.load(path) return modelo, None except Exception as e: return None, str(e) @st.cache_data def cargar_datos_clientes(): """Carga la base de clientes con historial y features.""" return pd.read_csv(DATOS_CLIENTES_PATH, low_memory=False) @st.cache_data def cargar_datos_modelo(): """Carga el CSV legacy con features para el modelo de regresion.""" try: return pd.read_csv(DATOS_MODELO_PATH) except Exception: return pd.DataFrame() @st.cache_data def cargar_datos_coordenadas(): """Carga el CSV con coordenadas de suministros.""" return pd.read_csv(DATOS_COORDENADAS_PATH) # ============================================= # FUNCIONES DE FEATURES TEMPORALES # ============================================= def recalcular_features(consumos_str, consumo_nuevo, ventana=VENTANA_MESES): """ Recalcula las 9 features temporales a partir del historial + consumo nuevo. Usa ventana movil para evitar que anomalias pasadas contaminen la prediccion. """ valores_completos = [float(x) for x in str(consumos_str).split(';') if x.strip()] valores_completos.append(float(consumo_nuevo)) if ventana and ventana > 0 and len(valores_completos) > ventana: valores = np.array(valores_completos[-ventana:]) else: valores = np.array(valores_completos) n = len(valores) features = {} if n > 1: x = np.arange(n) slope, _ = np.polyfit(x, valores, 1) features['ft_tendencia'] = slope cambios = np.diff(valores) features['ft_cambio_promedio'] = np.mean(cambios) features['ft_cambio_max_positivo'] = np.max(cambios) features['ft_cambio_max_negativo'] = np.min(cambios) cambios_pct = cambios / (valores[:-1] + 1) features['ft_caida_pct_maxima'] = np.min(cambios_pct) * 100 if n >= 3: ultimos_3 = np.mean(valores[-3:]) historico = np.mean(valores[:-3]) if n > 3 else np.mean(valores) features['ft_ratio_reciente_vs_historico'] = ultimos_3 / (historico + 1) else: features['ft_ratio_reciente_vs_historico'] = 1.0 caidas = (cambios < 0).astype(int) features['ft_n_caidas'] = float(np.sum(caidas)) features['ft_pct_caidas'] = np.sum(caidas) / len(cambios) * 100 else: for f in VARIABLES_TEMPORALES: features[f] = 0.0 features['ft_coef_variacion'] = (np.std(valores) / (np.mean(valores) + 1)) * 100 return features def parsear_historial(consumos_str): """Parsea el string de consumos separado por ; a lista de floats.""" return [float(x) for x in str(consumos_str).split(';') if x.strip()] def parsear_fechas(fechas_str): """Parsea el string de fechas separado por ; a lista de datetime.""" strs = [x.strip() for x in str(fechas_str).split(';') if x.strip()] return pd.to_datetime(strs, format='%d-%m-%Y', errors='coerce') # ============================================= # BUSQUEDA DE SUMINISTRO # ============================================= def buscar_suministro(nro_suministro): """Busca un suministro y retorna todos sus datos para prediccion y visualizacion.""" df_clientes = cargar_datos_clientes() cliente = df_clientes[df_clientes['nro_suministro'] == nro_suministro] if cliente.empty: return None row = cliente.iloc[0] # Historial de consumo consumos = parsear_historial(row['consumos_total']) fechas = parsear_fechas(row['fechas']) if pd.notna(row.get('fechas')) else [] # Datos base datos = { 'nro_suministro': int(row['nro_suministro']), 'cod_localidad': str(row.get('cod_localidad', '')), 'dir_suministro': str(row.get('dir_suministro', '')), 'CATE': str(row.get('CATE', 'DESCONOCIDO')) if pd.notna(row.get('CATE')) else 'DESCONOCIDO', 'ACT_ECO': str(row.get('ACT_ECO', 'DESCONOCIDO')) if pd.notna(row.get('ACT_ECO')) else 'DESCONOCIDO', 'consumos': consumos, 'fechas': fechas, 'consumos_total_str': str(row.get('consumos_total', '')), 'consumo_promedio': float(row.get('ft_consumo_promedio', np.mean(consumos))) if consumos else 0, } # Variables estaticas para el modelo datos['variables_estaticas'] = {} for var in VARIABLES_NUMERICAS: if var not in VARIABLES_TEMPORALES: datos['variables_estaticas'][var] = row.get(var, np.nan) # Campos display datos['display'] = {} for k, label in CAMPOS_DISPLAY.items(): val = row.get(k, np.nan) datos['display'][label] = val if pd.notna(val) else None # Coordenadas (buscar en base de coordenadas) df_coords = cargar_datos_coordenadas() coords = df_coords[df_coords['nro_suministro'] == nro_suministro] if not coords.empty: row_coords = coords.iloc[0] datos['latitud'] = float(row_coords['latitud']) datos['longitud'] = float(row_coords['longitud']) datos['direccion_sii'] = str(row_coords.get('direccion', '')) datos['nombrecomuna'] = str(row_coords.get('nombrecomuna', '')) else: datos['latitud'] = -33.0 datos['longitud'] = -71.0 datos['direccion_sii'] = '' datos['nombrecomuna'] = '' return datos # ============================================= # IMPUTACION GEOGRAFICA PARA CLIENTES NUEVOS # ============================================= def impute_features_from_location(lat, lon, k=10): """ Imputa variables estáticas de un cliente nuevo usando los K vecinos más cercanos por coordenadas (promedio ponderado por 1/distancia). """ df_coords = cargar_datos_coordenadas() df_clientes = cargar_datos_clientes() df_c = df_coords.dropna(subset=['latitud', 'longitud']).copy() if df_c.empty: return None, None distancias = np.sqrt((df_c['latitud'] - lat) ** 2 + (df_c['longitud'] - lon) ** 2) k_actual = min(k, len(df_c)) idx_top = distancias.nsmallest(k_actual).index dist_top = distancias[idx_top] nros_top = df_c.loc[idx_top, 'nro_suministro'].values vecinos = df_clientes[df_clientes['nro_suministro'].isin(nros_top)].copy() if vecinos.empty: return None, None # Pesos por distancia inversa (normalizar keys a str para evitar mismatch de dtype) nro_to_dist = {str(int(float(k))): v for k, v in zip(df_c.loc[idx_top, 'nro_suministro'].values, dist_top.values)} pesos = np.array([ 1.0 / (nro_to_dist.get(str(int(float(nro))), 1e-10) + 1e-10) for nro in vecinos['nro_suministro'] ]) pesos = pesos / pesos.sum() # Imputar variables numéricas con promedio ponderado feats = {} for var in VARIABLES_ESTATICAS + ['avaluo_total']: if var in vecinos.columns: vals = pd.to_numeric(vecinos[var], errors='coerce').values mask = ~np.isnan(vals) if mask.any(): w = pesos[mask] feats[var] = float(np.average(vals[mask], weights=w / w.sum())) else: feats[var] = np.nan # Imputar categóricas con moda de vecinos for var in ['CATE', 'ACT_ECO', 'cod_localidad']: col = vecinos[var].dropna() if var in vecinos.columns else pd.Series(dtype=str) moda = col.mode() feats[var] = str(moda.iloc[0]) if not moda.empty else 'DESCONOCIDO' # Comuna del vecino más cercano nearest_idx = dist_top.idxmin() nombrecomuna = str(df_c.loc[nearest_idx, 'nombrecomuna']) if 'nombrecomuna' in df_c.columns else '' meta = { 'n_vecinos': len(vecinos), 'nombrecomuna': nombrecomuna, } return feats, meta def predecir_cliente_nuevo(pipelines, nro_suministro, consumos_str, lat, lon): """ Predicción de riesgo para un cliente nuevo no existente en la base de datos. Imputa variables estáticas desde vecinos geográficos más cercanos. Retorna (resultado, datos_suministro, error_str). """ # Parsear historial de consumos consumos_lista = [ float(x.strip()) for x in consumos_str.replace(',', ';').split(';') if x.strip() ] if len(consumos_lista) < 3: return None, None, "Se necesitan al menos 3 lecturas de consumo" feats, meta = impute_features_from_location(lat, lon) if feats is None: return None, None, "No se encontraron vecinos cerca de esas coordenadas" # El último consumo es el actual; el resto es historial consumo_actual = consumos_lista[-1] consumos_hist = consumos_lista[:-1] consumos_hist_str = ';'.join(str(c) for c in consumos_hist) # Fechas sintéticas mensuales para el historial fechas_hist = list( pd.date_range( end=pd.Timestamp.now() - pd.DateOffset(months=1), periods=len(consumos_hist), freq='MS', ) ) datos_suministro = { 'nro_suministro': nro_suministro, 'cod_localidad': feats.get('cod_localidad', 'DESCONOCIDO'), 'dir_suministro': 'Cliente nuevo', 'CATE': feats.get('CATE', 'DESCONOCIDO'), 'ACT_ECO': feats.get('ACT_ECO', 'DESCONOCIDO'), 'consumos': consumos_hist, 'fechas': fechas_hist, 'consumos_total_str': consumos_hist_str, 'consumo_promedio': float(np.mean(consumos_hist)) if consumos_hist else 0.0, 'variables_estaticas': {v: feats.get(v, np.nan) for v in VARIABLES_ESTATICAS}, 'display': {label: feats.get(k) for k, label in CAMPOS_DISPLAY.items()}, 'latitud': lat, 'longitud': lon, 'direccion_sii': '', 'nombrecomuna': meta.get('nombrecomuna', ''), } resultado = predecir(pipelines, datos_suministro, consumo_actual, es_simulado=False) return resultado, datos_suministro, None # ============================================= # PREDICCION INDIVIDUAL (IF + LOF) # ============================================= def predecir(pipelines, datos_suministro, consumo_actual, es_simulado=False): """ Predice anomalia con IF + LOF para un suministro. Retorna dict con resultado completo. """ if es_simulado: return _predecir_simulado(datos_suministro) # Recalcular features temporales con el nuevo consumo nuevas_features = recalcular_features( datos_suministro['consumos_total_str'], consumo_actual ) # Construir fila de datos fila = {} for feat in nuevas_features: fila[feat] = nuevas_features[feat] for var, val in datos_suministro['variables_estaticas'].items(): fila[var] = val fila['CATE'] = datos_suministro['CATE'] fila['ACT_ECO'] = datos_suministro['ACT_ECO'] X = pd.DataFrame([fila])[VARIABLES_NUMERICAS + VARIABLES_CATEGORICAS] # Verificar nulos en numericas nulos = X[VARIABLES_NUMERICAS].isnull().sum().sum() if nulos > 0: st.warning(f"El suministro tiene {nulos} valores nulos en variables del modelo") # Predecir con IF pp_if = pipelines['if'] X_if = pp_if['preprocessor'].transform(X) pred_if = pp_if['model'].predict(X_if)[0] score_if = -pp_if['model'].decision_function(X_if)[0] # Predecir con LOF pp_lof = pipelines['lof'] X_lof = pp_lof['preprocessor'].transform(X) X_lof_pca = pp_lof['pca_reducer'].transform(X_lof) pred_lof = pp_lof['model'].predict(X_lof_pca)[0] score_lof = -pp_lof['model'].decision_function(X_lof_pca)[0] # Votos y prioridad votos = int(pred_if == -1) + int(pred_lof == -1) prioridad = 'ALTA' if votos == 2 else ('MEDIA' if votos == 1 else 'Normal') # Prediccion de regresion (solo como variable informativa) prediccion_regresion = _predecir_regresion(datos_suministro) resultado = { 'nro_suministro': datos_suministro['nro_suministro'], 'consumo_actual': consumo_actual, 'consumo_promedio': datos_suministro['consumo_promedio'], 'if_anomalia': int(pred_if == -1), 'if_score': round(float(score_if), 4), 'lof_anomalia': int(pred_lof == -1), 'lof_score': round(float(score_lof), 4), 'votos': votos, 'prioridad': prioridad, 'nivel': NIVELES_RIESGO[prioridad], # Features recalculadas 'features_recalculadas': {k: round(v, 4) for k, v in nuevas_features.items()}, # Regresion como variable informativa 'prediccion_regresion': prediccion_regresion, } # PU Bagging (multi-ventana): score adicional e informativo, no se mezcla # con los votos de IF/LOF. resultado.update(_predecir_pu(pipelines.get('pu'), datos_suministro, consumo_actual)) return resultado def _predecir_regresion(datos_suministro): """Prediccion con modelo de regresion (solo informativa).""" try: modelo, error = cargar_modelo(str(MODELO_REGRESION_PATH)) if modelo is None: return None df_modelo = cargar_datos_modelo() row = df_modelo[df_modelo['nro_suministro'] == datos_suministro['nro_suministro']] if row.empty: return None features = row[FEATURELIST].iloc[[0]] pred = modelo.predict(features) return round(float(pred[0]), 2) except Exception: return None def _predecir_simulado(datos_suministro): """Modelo demo con valores aleatorios.""" lat = datos_suministro.get('latitud', -33.0) lon = datos_suministro.get('longitud', -71.0) np.random.seed(int(abs(lat * 1000) + abs(lon * 1000)) % 2**31) votos = np.random.choice([0, 1, 2], p=[0.7, 0.2, 0.1]) prioridad = 'ALTA' if votos == 2 else ('MEDIA' if votos == 1 else 'Normal') return { 'nro_suministro': datos_suministro['nro_suministro'], 'consumo_actual': 0, 'consumo_promedio': datos_suministro.get('consumo_promedio', 0), 'if_anomalia': int(votos >= 1), 'if_score': round(np.random.uniform(0, 0.2), 4), 'lof_anomalia': int(votos >= 2), 'lof_score': round(np.random.uniform(0, 5), 4), 'votos': int(votos), 'prioridad': prioridad, 'nivel': NIVELES_RIESGO[prioridad], 'features_recalculadas': {v: 0.0 for v in VARIABLES_TEMPORALES}, 'prediccion_regresion': None, 'pu_score': None, 'pu_prioridad': None, 'pu_nivel': None, } # ============================================= # PREDICCION PU BAGGING (multi-ventana) # ============================================= # Modelo supervisado (PU Learning) ya entrenado: 100 clasificadores # (50 XGBoost + 30 Random Forest + 20 Logistic Regression) sobre 121 ilicitos # confirmados. Todo lo que sigue es inferencia pura (.transform()/.predict()/ # .predict_proba() sobre objetos ya fitted) - no se reentrena nada aqui. def _features_desde_lista_pu(valores): """Calcula las 9 features temporales base para una ventana de consumos. Retorna None si hay menos de 3 datos (igual criterio que el notebook de entrenamiento: ventanas cortas quedan en NaN y las imputa el pipeline).""" n = len(valores) if n < 3: return None features = {} x = np.arange(n) slope, _ = np.polyfit(x, valores, 1) features['ft_tendencia'] = slope cambios = np.diff(valores) features['ft_cambio_promedio'] = float(np.mean(cambios)) features['ft_cambio_max_positivo'] = float(np.max(cambios)) features['ft_cambio_max_negativo'] = float(np.min(cambios)) cambios_pct = cambios / (valores[:-1] + 1) features['ft_caida_pct_maxima'] = float(np.min(cambios_pct) * 100) ultimos_3 = np.mean(valores[-3:]) historico = np.mean(valores[:-3]) if n > 3 else np.mean(valores) features['ft_ratio_reciente_vs_historico'] = float(ultimos_3 / (historico + 1)) caidas = cambios < 0 features['ft_n_caidas'] = float(np.sum(caidas)) features['ft_pct_caidas'] = float(np.sum(caidas) / len(cambios) * 100) features['ft_coef_variacion'] = float((np.std(valores) / (np.mean(valores) + 1)) * 100) return features def calcular_features_multiventana_pu(fechas, consumos, fecha_corte, ventanas=VENTANAS_PU): """ Calcula las 9 features temporales del modelo PU para cada ventana (por defecto 3/6/12/24 meses), filtrando lecturas entre [fecha_corte - ventana, fecha_corte]. Ventanas con <3 lecturas quedan en NaN (las imputa el SimpleImputer ya entrenado dentro del pipeline PU). Retorna (features_dict, valores_por_ventana) - lo segundo lo usa el calculo del feature residual (ventana de 12m). """ result = {} valores_por_ventana = {} for v in ventanas: fecha_inicio = fecha_corte - pd.DateOffset(months=v) valores_ventana = [c for f, c in zip(fechas, consumos) if fecha_inicio <= f <= fecha_corte] valores_por_ventana[v] = valores_ventana if len(valores_ventana) < 3: for feat in BASE_FEATURES_TEMPORALES_PU: result[f'{feat}_{v}m'] = np.nan else: feats = _features_desde_lista_pu(np.array(valores_ventana)) for feat_name, val in feats.items(): result[f'{feat_name}_{v}m'] = val return result, valores_por_ventana def _calcular_residual_pu(pipeline_pu, datos_suministro, valores_ventana_12m): """Feature residual: diferencia entre consumo real (promedio ult. 12m) y el consumo esperado por perfil censal/satelital (GBR ya entrenado).""" vars_perfil = pipeline_pu['vars_perfil'] fila_perfil = {v: datos_suministro['variables_estaticas'].get(v, np.nan) for v in vars_perfil} X_perfil = pd.DataFrame([fila_perfil])[vars_perfil] X_perfil_imp = pipeline_pu['imp_perfil'].transform(X_perfil) consumo_esperado = float(np.expm1(pipeline_pu['reg_consumo'].predict(X_perfil_imp))[0]) consumo_real = float(np.mean(valores_ventana_12m)) if valores_ventana_12m else consumo_esperado return fila_perfil, { 'ft_residual': consumo_real - consumo_esperado, 'ft_residual_ratio': consumo_real / (consumo_esperado + 1), } def _asignar_prioridad_pu(pu_score): """Prioridad segun los umbrales operativos ya usados en las listas de terreno entregadas (lista_sospechosos_fraude_multivent.csv).""" for prioridad, info in NIVELES_RIESGO_PU.items(): if pu_score >= info['min']: return prioridad return 'BAJA' def _predecir_pu(pipeline_pu, datos_suministro, consumo_actual): """Prediccion con el modelo PU Bagging (multi-ventana, 100 clasificadores). Agrega el consumo_actual como una lectura hipotetica nueva (un mes despues de la ultima lectura conocida) y recalcula las features point-in-time con ese nuevo corte, igual que el flujo IF/LOF hace con recalcular_features().""" if pipeline_pu is None: return {'pu_score': None, 'pu_prioridad': None, 'pu_nivel': None} try: fechas_hist = list(datos_suministro.get('fechas', [])) consumos_hist = list(datos_suministro.get('consumos', [])) pares = sorted( ((f, c) for f, c in zip(fechas_hist, consumos_hist) if pd.notna(f)), key=lambda par: par[0], ) fechas = [f for f, c in pares] consumos = [c for f, c in pares] fecha_corte = (fechas[-1] + pd.DateOffset(months=1)) if fechas else pd.Timestamp.now() fechas = fechas + [fecha_corte] consumos = consumos + [float(consumo_actual)] ventanas = pipeline_pu.get('ventanas', VENTANAS_PU) features_temp, valores_por_ventana = calcular_features_multiventana_pu( fechas, consumos, fecha_corte, ventanas ) fila_perfil, features_residual = _calcular_residual_pu( pipeline_pu, datos_suministro, valores_por_ventana.get(12, []) ) fila = dict(features_temp) fila.update(fila_perfil) fila.update(features_residual) for var in pipeline_pu['vars_log']: fila[var] = datos_suministro['variables_estaticas'].get(var, np.nan) fila['cod_localidad'] = datos_suministro.get('cod_localidad', 'DESCONOCIDO') fila['CATE'] = datos_suministro.get('CATE', 'DESCONOCIDO') fila['ACT_ECO'] = datos_suministro.get('ACT_ECO', 'DESCONOCIDO') todas_features = pipeline_pu['config']['vars_numericas'] + pipeline_pu['vars_log'] + pipeline_pu['vars_cat'] X = pd.DataFrame([fila])[todas_features] X_t = pipeline_pu['preprocessor'].transform(X) probs = np.mean([c['clf'].predict_proba(X_t)[:, 1] for c in pipeline_pu['classifiers']], axis=0) pu_score = float(probs[0]) prioridad = _asignar_prioridad_pu(pu_score) return { 'pu_score': round(pu_score, 4), 'pu_prioridad': prioridad, 'pu_nivel': NIVELES_RIESGO_PU[prioridad], } except Exception as e: st.warning(f"No se pudo calcular el score PU Bagging: {e}") return {'pu_score': None, 'pu_prioridad': None, 'pu_nivel': None} # ============================================= # PREDICCION POR LOTE - CLIENTES NUEVOS # ============================================= def predecir_lote_nuevos(pipelines, df_entrada): """ Predicción por lote para clientes nuevos (sin historial en BD). Input: DataFrame con columnas nro_suministro, consumos, latitud, longitud. """ resultados = [] errores = [] for _, row in df_entrada.iterrows(): nro = row['nro_suministro'] consumos_str = str(row.get('consumos', '')) try: lat = float(row['latitud']) lon = float(row['longitud']) except (ValueError, KeyError): errores.append({'nro_suministro': nro, 'estado': 'Error', 'error': 'Latitud/longitud invalidas'}) continue resultado, datos, error = predecir_cliente_nuevo(pipelines, nro, consumos_str, lat, lon) if error: errores.append({'nro_suministro': nro, 'consumos': consumos_str, 'estado': 'Error', 'error': error}) continue resultado['latitud'] = lat resultado['longitud'] = lon resultado['nombrecomuna'] = datos.get('nombrecomuna', '') resultado['estado'] = 'Encontrado' for k, v in resultado.get('features_recalculadas', {}).items(): resultado[k] = v resultados.append(resultado) df_ok = pd.DataFrame(resultados) if resultados else pd.DataFrame() df_err = pd.DataFrame(errores) if errores else pd.DataFrame() df_result = pd.concat([df_ok, df_err], ignore_index=True) cols_base = ['nro_suministro', 'consumo_actual', 'votos', 'prioridad', 'if_anomalia', 'if_score', 'lof_anomalia', 'lof_score', 'pu_score', 'pu_prioridad', 'nombrecomuna', 'latitud', 'longitud', 'estado'] cols_out = [c for c in cols_base if c in df_result.columns] cols_excluidas = {'nivel', 'pu_nivel', 'features_recalculadas'} cols_extra = [c for c in df_result.columns if c not in cols_out and c not in cols_excluidas] return df_result[[*cols_out, *cols_extra]] # ============================================= # PREDICCION POR LOTE # ============================================= def predecir_lote(pipelines, df_entrada, es_simulado=False): """ Prediccion por lote. Input: CSV con nro_suministro y consumo_actual. Retorna DataFrame con resultados. """ df_clientes = cargar_datos_clientes() df_coords = cargar_datos_coordenadas() resultados = [] errores = [] for _, row in df_entrada.iterrows(): nro = row['nro_suministro'] consumo = row.get('consumo_actual', row.get('consumo_real', 0)) datos = buscar_suministro(nro) if datos is None: errores.append({ 'nro_suministro': nro, 'consumo_actual': consumo, 'estado': 'No encontrado', }) continue resultado = predecir(pipelines, datos, consumo, es_simulado) resultado['dir_suministro'] = datos.get('dir_suministro', '') resultado['direccion_sii'] = datos.get('direccion_sii', '') resultado['nombrecomuna'] = datos.get('nombrecomuna', '') resultado['cod_localidad'] = datos.get('cod_localidad', '') resultado['CATE'] = datos.get('CATE', '') resultado['ACT_ECO'] = datos.get('ACT_ECO', '') resultado['latitud'] = datos.get('latitud', np.nan) resultado['longitud'] = datos.get('longitud', np.nan) resultado['estado'] = 'Encontrado' # Aplanar features recalculadas for k, v in resultado.get('features_recalculadas', {}).items(): resultado[k] = v # Agregar campos display for label, val in datos.get('display', {}).items(): resultado[label] = val resultados.append(resultado) df_ok = pd.DataFrame(resultados) if resultados else pd.DataFrame() df_err = pd.DataFrame(errores) if errores else pd.DataFrame() df_resultado = pd.concat([df_ok, df_err], ignore_index=True) # Ordenar columnas cols_base = ['nro_suministro', 'consumo_actual', 'votos', 'prioridad', 'if_anomalia', 'if_score', 'lof_anomalia', 'lof_score', 'pu_score', 'pu_prioridad'] cols_ubicacion = ['dir_suministro', 'direccion_sii', 'nombrecomuna', 'cod_localidad', 'latitud', 'longitud'] cols_features = ['ft_tendencia', 'ft_ratio_reciente_vs_historico', 'ft_caida_pct_maxima', 'ft_coef_variacion'] cols_extra = ['CATE', 'ACT_ECO', 'consumo_promedio', 'prediccion_regresion', 'estado'] columnas_output = [] for col in cols_base + cols_ubicacion + cols_features + cols_extra: if col in df_resultado.columns: columnas_output.append(col) # Agregar columnas restantes que no estan en la lista cols_excluidas = {'nivel', 'pu_nivel', 'features_recalculadas'} for col in df_resultado.columns: if col not in columnas_output and col not in cols_excluidas: columnas_output.append(col) df_resultado = df_resultado[[c for c in columnas_output if c in df_resultado.columns]] return df_resultado # ============================================= # FUNCIONES DE RIESGO (compatibilidad) # ============================================= def asignar_nivel_riesgo(votos): """Asigna nivel de riesgo basado en votos (0-2).""" if votos >= 2: return 'ALTA' elif votos == 1: return 'MEDIA' return 'Normal' def calcular_score_riesgo(prediccion, consumo_real): """Legacy: score de riesgo del modelo de regresion.""" score = prediccion / (consumo_real + 1) return min(score, 5.0) def modelo_simulado(lat, lon): """Legacy: modelo demo.""" np.random.seed(int(abs(lat * 1000) + abs(lon * 1000)) % 2**31) return np.random.uniform(0.0, 1.0) def obtener_feature_importance(pipelines): """Retorna las importancias pre-calculadas de IF y LOF.""" if pipelines is None: return {}, {} fi_if = pipelines.get('if', {}).get('feature_importance', {}) fi_lof = pipelines.get('lof', {}).get('feature_importance', {}) return fi_if, fi_lof