Spaces:
Sleeping
Sleeping
Download src/models/predictor.py from NextAI-cl/waterpolice-test: direct link, hf CLI and curl.
- Browser
- Download file 29.3 kB
-
https://huggingface.co/spaces/NextAI-cl/waterpolice-test/resolve/main/src/models/predictor.py
- Command line
-
hf download hf://spaces/NextAI-cl/waterpolice-test/src/models/predictor.py
-
curl -L -o predictor.py https://huggingface.co/spaces/NextAI-cl/waterpolice-test/resolve/main/src/models/predictor.py
29.3 kB
| """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) | |
| # ============================================= | |
| 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) | |
| 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) | |
| def cargar_datos_clientes(): | |
| """Carga la base de clientes con historial y features.""" | |
| return pd.read_csv(DATOS_CLIENTES_PATH, low_memory=False) | |
| 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() | |
| 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 | |