waterpolice-test / src /models /predictor.py
Eduardo
update models and adding predictor new client
d82237e
Raw History Blame Contribute Delete
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)
# =============================================
@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