Resumen

• Fuentes integradas: consumo histórico, variables técnicas (VUPS), datos contractuales y resultados de inspecciones (ground truth).
• Decisión clave de integración: LEFT JOIN priorizando la serie de consumo para conservar el comportamiento temporal.
• Resultado: tabla analítica Cliente–Mes (>1M registros) lista para modelado.

Datasets de Origen (5 Archivos)

El proyecto parte de 5 fuentes de datos heterogéneas que abarcan el periodo 2018-2020:

Estructura Detallada por Dataset

Registros: 826,463
Periodo: Año 2018 (lecturas bimestrales)
Tamaño: 63.1 MB

Columnas (10):
├─ cups                      (str, CUPS único)
├─ anyo_lectura              (float)
├─ mes_lectura               (int)
├─ dia_lectura               (int)
├─ fecha_lectura             (str, formato DD/MM/YYYY)
├─ integrador                (int)
├─ fecha_lectura_anterior    (str)
├─ v_consumo                 (str, kWh)
├─ v_lectura                 (str, lectura contador)
└─ v_lectura_anterior        (str)

Registros: 670,133
Periodo: 2019-2020 (lecturas bimestrales)
Tamaño: 51.1 MB

Columnas (10):
├─ cups                      (str)
├─ anyo_lectura              (float)
├─ mes_lectura               (int)
├─ dia_lectura               (int)
├─ fecha_lectura             (str)
├─ integrador                (int)
├─ fecha_lectura_anterior    (str)
├─ v_consumo                 (str, kWh)
├─ v_lectura                 (str)
└─ v_lectura_anterior        (str)

Registros: 20,313
Tamaño: 952.3 KB

Columnas (6):
├─ CUPS                      (str)
├─ D_AMBITO                  (str, ámbito)
├─ D_PCR                     (str)
├─ D_T_CONT                  (str, tipo contador)
├─ D_FASE                    (str, fase eléctrica)
└─ [otras características técnicas]

Registros: 20,135
Clientes únicos en dataset
Tamaño: 786.7 KB

Columnas (5):
├─ CUPS                      (str, PK)
├─ TARIFA                    (str, ej: '3.1A', '20DHA', '6.1')
├─ CNAE                      (float, código actividad)
├─ POTENCIA CONTRATADA       (float, kW)
└─ MUNICIPIO                 (str, ej: 'MALAGA')

Registros: 1,000
Ground truth: etiqueta por inspección (fraude_real)
Tamaño: 41.7 KB

Columnas (5):
├─ cups_id                 (str, identificador)
├─ probabilidad_fraude     (float, score)
├─ is_baja_registered      (int, indicador)
├─ fraude_real             (int, 0/1)
└─ ranking                 (int, 1..1000)

Proceso de Fusión Multi-Etapa

DataFrame Final (Post-Limpieza)

🔑 Identificador:
└─ cups_id

📅 Variables Temporales (7):
├─ fecha_lectura
├─ mes_lectura
├─ dia_lectura
├─ anio
├─ dia_semana
├─ es_fin_semana
└─ trimestre

Variables de Consumo (5):
├─ v_consumo (kWh)
├─ integrador
├─ dias_entre_lecturas
├─ consumo_diario
└─ [estadísticos derivados]

Variables Contractuales (4):
├─ tarifa
├─ cnae
├─ potencia_contratada
└─ municipio

🔧 Variables Técnicas VUPS (4):
├─ d_ambito
├─ d_pcr
├─ d_t_cont
└─ d_fase

🎯 Target:
└─ fraude (0/1)

Diagnóstico de Calidad: Tratamiento de Valores Nulos

Análisis exhaustivo de missing values y aplicación de técnicas específicas según tipología:

df['v_consumo'] = df.groupby('cups_id')['v_consumo'].transform(
    lambda x: x.interpolate(method='linear', limit=3)
)

Detección y Tratamiento de Outliers

Q1 = df['v_consumo'].quantile(0.25)
Q3 = df['v_consumo'].quantile(0.75)
IQR = Q3 - Q1

lower_bound = Q1 - 3 * IQR
upper_bound = Q3 + 3 * IQR

outliers = (df['v_consumo'] < lower_bound) | \
           (df['v_consumo'] > upper_bound)

Análisis de Desbalanceo de Clases

Análisis Exploratorio de Datos (EDA)

Análisis Univariado: Variables Clave

Análisis Bivariado: Correlaciones con Target

Variables Creadas: Diccionario Completo

Variables de Lag y Rolling Windows

Se crearon variables temporales para capturar la evolución del comportamiento:

df['consumo_lag_1m'] = df.groupby('cups_id')['consumo'].shift(1)
df['consumo_lag_3m'] = df.groupby('cups_id')['consumo'].shift(3)
df['consumo_lag_6m'] = df.groupby('cups_id')['consumo'].shift(6)

df['rolling_mean_3m'] = df.groupby('cups_id')['consumo']\
    .rolling(window=3, min_periods=1).mean().reset_index(0, drop=True)

df['rolling_std_6m'] = df.groupby('cups_id')['consumo']\
    .rolling(window=6, min_periods=1).std().reset_index(0, drop=True)

Selección de Variables: Tests Estadísticos

Test Chi-Cuadrado (χ²) para Variables Categóricas

Se aplicó el test χ² de independencia para validar la asociación entre variables categóricas y el target:

Mutual Information para Variables Numéricas

Se calculó la Información Mutua para medir dependencia no lineal:

from sklearn.feature_selection import mutual_info_classif

mi_scores = mutual_info_classif(X_train, y_train, random_state=42)
mi_scores = pd.Series(mi_scores, index=X_train.columns).sort_values(ascending=False)

Top 5 Variables por MI Score:

1. baja_registrada: 0.187
2. ratio_ceros: 0.143
3. potencia_contratada: 0.129
4. diff_media_movil: 0.118
5. factor_utilizacion: 0.095

Interpretabilidad: SHAP Values

Top 10 Variables por SHAP Importance (Global)

Interpretación: potencia_contratada domina con SHAP importance de 0.54, casi 3× superior a la segunda variable. Esto indica que la potencia contratada es el factor más determinante para identificar patrones de fraude en el modelo.

Resumen metodológico

• Validación temporal: entrenamiento con pasado y evaluación con futuro para simular operación real.
• Separación por cliente: todas las observaciones de un mismo CUPS quedan en el mismo split (evita fuga por cliente).
• Anti-leakage: preprocesado encapsulado en Pipeline y CV controlada.

Pipeline de Preprocesamiento (sklearn)

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from xgboost import XGBClassifier

# Definir transformadores por tipo de variable
numeric_features = ['potencia_contratada', 'consumo_mensual_mean', ...]
categorical_features = ['provincia', 'cod_tarifa', 'tipo_cliente']

numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
    ('onehot', OneHotEncoder(handle_unknown='ignore', sparse=False))
])

# Combinar transformadores
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ]
)

# Pipeline completo
model_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', XGBClassifier(
        scale_pos_weight=234,
        max_depth=4,
        learning_rate=0.05,
        n_estimators=200,
        subsample=0.8,
        colsample_bytree=0.8,
        min_child_weight=10,
        reg_alpha=1.0,
        reg_lambda=1.0,
        random_state=42
    ))
])

# Entrenamiento (fit solo con train)
model_pipeline.fit(X_train, y_train)

# Predicción en test (aplica automáticamente las transformaciones)
y_pred_proba = model_pipeline.predict_proba(X_test)[:, 1]

# ❌ INCORRECTO
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)  # Aprende de train
X_test_scaled = scaler.fit_transform(X_test)   # ❌ Re-aprende de test!

# ✅ CORRECTO (Pipeline lo hace automáticamente)
X_test_scaled = scaler.transform(X_test)  # Usa parámetros de train

Estrategia de Split: Prevención de Data Leakage

1. Data Leakage Temporal (Validación Cronológica)

# ❌ INCORRECTO: Split aleatorio (ignora temporalidad)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# ✅ CORRECTO: Split temporal estricto
train_mask = df['year'] < 2020
test_mask = df['year'] == 2020

X_train, y_train = df[train_mask][features], df[train_mask]['fraude']
X_test, y_test = df[test_mask][features], df[test_mask]['fraude']

2. Data Leakage por Cliente (GroupShuffleSplit)

from sklearn.model_selection import GroupShuffleSplit

# Asegurar que TODOS los registros de un cliente estén en el mismo split
gss = GroupShuffleSplit(n_splits=1, test_size=0.2, random_state=42)

for train_idx, test_idx in gss.split(X, y, groups=df['cups_id']):
    X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
    y_train, y_test = y.iloc[train_idx], y.iloc[test_idx]

Resultado: En test hay clientes completamente "nuevos" que el modelo nunca vio en train, simulando el escenario de producción real.

Validación Cruzada: TimeSeriesSplit

Para evaluar la estabilidad del modelo a lo largo del tiempo, se implementó validación cruzada temporal con expansión progresiva usando TimeSeriesSplit(n_splits=3).

Fold 1:
Train: [T1-T2]  → Val: [T3]

Fold 2:
Train: [T1-T3]  → Val: [T4]

Fold 3:
Train: [T1-T4]  → Val: [T5]

Algoritmo Seleccionado: XGBoost

Modelo_Final = Árbol_1 + η·Árbol_2 + η·Árbol_3 + ... + η·Árbol_N

L(θ) = Σ loss(y_i, ŷ_i) + Σ Ω(f_k)
       \_________________/   \________/
        Error predicción    Regularización

Configuración de Hiperparámetros

Curva de Aprendizaje y Convergencia

Matriz de Confusión (Threshold = 0.35)

Curvas ROC y Precision-Recall

Curva de Ganancia Acumulada (Lift Curve)

Análisis de Threshold Óptimo

El threshold por defecto (0.5) no es óptimo para este problema. Se analizó el trade-off Precision-Recall a diferentes umbrales:

Robustez del modelo: Bootstrap (IC 95%)

Para responder a esta cuestión, se ha aplicado un análisis Bootstrap sobre la métrica de negocio (Precisión Top-K), estimando su intervalo de confianza al 95%.

Enfoque de Dos Fases

El sistema implementado no es un modelo puro de ML, sino una estrategia secuencial que combina interpretabilidad con capacidad predictiva:

FASE 1: Reglas de Negocio (Business Rules)

Reglas Implementadas

FASE 2: Modelo de Machine Learning (XGBoost)

Para clientes que no activaron ninguna regla, se aplica el modelo XGBoost que asigna una probabilidad de fraude [0, 1]. Se priorizan casos con score > 0.70.

Flujo de Decisión

ENTRADA: Cliente con datos de consumo del último año

PASO 1: Evaluar Reglas de Negocio
├─ SI alguna regla se activa → FRAUDE CONFIRMADO (prioridad máxima)
└─ SI ninguna regla se activa → PASO 2

PASO 2: Aplicar Modelo XGBoost
├─ Score ≥ 0.70 → Alta Sospecha (incluir en Top-K)
├─ 0.35 ≤ Score < 0.70 → Sospecha Moderada (monitorear)
└─ Score < 0.35 → Bajo Riesgo (sin acción)

SALIDA: Lista ordenada de clientes por riesgo total

Resultados Comparativos: Estrategias Puras vs Híbrida

Implementación en Código

def detectar_fraude_hibrido(cliente_df):
    """
    Sistema de detección híbrido: Reglas + ML
    
    Returns:
        score: float [0, 1] - Probabilidad final de fraude
        source: str - Origen de la detección ('Modelo' o 'Modelo')
        explanation: str - Justificación de la predicción
    """
    
    # FASE 1: Evaluar Reglas Determinísticas
    if (cliente_df['baja_registrada'] == True) and (cliente_df['consumo'] > 0):
        return 1.0, 'Modelo', 'R1: Consumo post-baja registrada'
    
    if (cliente_df['ratio_ceros'] > 0.95) and (cliente_df['potencia_contratada'] > 10):
        return 1.0, 'Modelo', 'R2: Manipulación de contador (95% lecturas = 0)'
    
    if (cliente_df['factor_utilizacion'] < 0.01) and (cliente_df['consumo_historico_6m'] > 500):
        return 1.0, 'Modelo', 'R3: Puente directo a red (caída abrupta)'
    
    if cliente_df['diff_year_over_year'] < -0.80:
        return 1.0, 'Modelo', 'R4: Caída interanual > 80%'
    
    # FASE 2: Aplicar Modelo XGBoost
    X = preparar_features(cliente_df)
    score_ml = model_pipeline.predict_proba(X)[0, 1]
    
    # Explicación con SHAP
    shap_values = explainer.shap_values(X)
    top_feature = feature_names[np.argmax(np.abs(shap_values))]
    
    return score_ml, 'Modelo', f'XGBoost Score: {score_ml:.2f} | Top Feature: {top_feature}'

# Uso
for cliente in dataset_test:
    score, source, explanation = detectar_fraude_hibrido(cliente)
    if score > 0.70:
        print(f"Cliente {cliente['id']} - Score: {score:.2f} [{source}] - {explanation}")

Modelo de Negocio Subyacente

if inspecciones <= 100:
    fraudes = inspecciones × 0.29      # 29% precision en top-100
elif inspecciones <= 500:
    fraudes = 29 + (inspecciones - 100) × 0.16   # 16% en tramo 101-500
else:
    fraudes = 93 + (inspecciones - 500) × 0.10   # 10% en cola (501+)

Conclusiones Principales del TFM

Líneas de Trabajo Futuro

Reflexión Final

Este TFM demuestra que la aplicación rigurosa de técnicas de Ciencia de Datos puede transformar un problema de negocio crítico (pérdidas millonarias por fraude) en una oportunidad de valor (ROI > 700%). El éxito no radica solo en la complejidad algorítmica, sino en la comprensión profunda del dominio, la rigurosidad metodológica, y el balance entre interpretabilidad y potencia predictiva.

La estrategia híbrida (Reglas + ML) presentada es directamente desplegable en producción, utilizando datos ya disponibles en la compañía, sin inversión en nueva infraestructura. Representa un caso de uso ejemplar de cómo la Inteligencia Artificial puede generar valor tangible en entornos industriales complejos.