Modelo Predictivo en IA Para Detección Phishing

12 de mayo de 2025 5 minutos de lectura 388 visualizacionesSin categoría

En el artículo de hoy, vamos a desarrollar un modelo predictivo de IA para la detección de phishing bancario, utilizando técnicas de procesamiento de lenguaje natural (NLP) y aprendizaje automático. El objetivo es clasificar correos electrónicos o mensajes como «phishing» o «legítimos» basándose en su contenido. A continuación, os reproduzco el código fuente, sobre cómo implementar este modelo, en Python.

Código: Modelo predictivo para detección de phishing bancario

# Importar librerías necesarias
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, accuracy_score, confusion_matrix, roc_auc_score, roc_curve
from imblearn.over_sampling import SMOTE  # Para balancear datos
import matplotlib.pyplot as plt
import seaborn as sns
import joblib  # Para guardar y cargar el modelo

# 1. Cargar el conjunto de datos
# Supongamos que tienes un archivo CSV con correos electrónicos etiquetados
# Las columnas podrían ser: text (contenido del correo), label (0: legítimo, 1: phishing)
url = "https://example.com/phishing_dataset.csv"  # Reemplaza con la URL o ruta de tu dataset
data = pd.read_csv(url)

# 2. Preprocesamiento de datos
# Verificar valores nulos
if data.isnull().sum().any():
    data = data.dropna()  # Eliminar filas con valores nulos

# Separar características (X) y etiquetas (y)
X = data["text"]  # Contenido del correo
y = data["label"]  # Etiquetas (0: legítimo, 1: phishing)

# Balancear los datos (si están desbalanceados)
smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(pd.DataFrame(X), y)
X = X_resampled["text"]
y = y_resampled

# Dividir los datos en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 3. Vectorización del texto
# Convertir el texto en características numéricas usando TF-IDF
vectorizer = TfidfVectorizer(max_features=5000, stop_words="english")
X_train_tfidf = vectorizer.fit_transform(X_train)
X_test_tfidf = vectorizer.transform(X_test)

# 4. Entrenar el modelo con optimización de hiperparámetros
# Definir el modelo
model = RandomForestClassifier(random_state=42)

# Definir la cuadrícula de hiperparámetros para GridSearchCV
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20],
    'min_samples_split': [2, 5, 10]
}

# Usar GridSearchCV para encontrar los mejores hiperparámetros
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=5, scoring='accuracy', n_jobs=-1)
grid_search.fit(X_train_tfidf, y_train)

# Mejor modelo encontrado
best_model = grid_search.best_estimator_
print("Mejores hiperparámetros:", grid_search.best_params_)

# 5. Evaluar el modelo
# Predicciones en el conjunto de prueba
y_pred = best_model.predict(X_test_tfidf)
y_pred_proba = best_model.predict_proba(X_test_tfidf)[:, 1]  # Probabilidades para la curva ROC

# Métricas de evaluación
print("\nPrecisión del modelo:", accuracy_score(y_test, y_pred))
print("\nReporte de clasificación:\n", classification_report(y_test, y_pred))
print("\nMatriz de confusión:\n", confusion_matrix(y_test, y_pred))
print("\nAUC-ROC:", roc_auc_score(y_test, y_pred_proba))

# 6. Visualización de métricas
# Matriz de confusión
sns.heatmap(confusion_matrix(y_test, y_pred), annot=True, fmt='d', cmap='Blues')
plt.title("Matriz de Confusión")
plt.xlabel("Predicho")
plt.ylabel("Real")
plt.show()

# Curva ROC
fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)
plt.plot(fpr, tpr, label="Curva ROC (AUC = {:.2f})".format(roc_auc_score(y_test, y_pred_proba)))
plt.plot([0, 1], [0, 1], linestyle='--', color='gray')
plt.xlabel("Tasa de Falsos Positivos")
plt.ylabel("Tasa de Verdaderos Positivos")
plt.title("Curva ROC")
plt.legend()
plt.show()

# 7. Guardar el modelo y el vectorizador
joblib.dump(best_model, "phishing_detection_model.pkl")
joblib.dump(vectorizer, "tfidf_vectorizer.pkl")

# 8. Cargar el modelo y hacer predicciones en tiempo real (simulación)
# Cargar el modelo y el vectorizador
loaded_model = joblib.load("phishing_detection_model.pkl")
loaded_vectorizer = joblib.load("tfidf_vectorizer.pkl")

# Simular un nuevo correo electrónico
new_email = ["Estimado cliente, su cuenta bancaria ha sido suspendida. Por favor, haga clic en este enlace para verificar su información."]
new_email_tfidf = loaded_vectorizer.transform(new_email)
prediction = loaded_model.predict(new_email_tfidf)

if prediction[0] == 1:
    print("¡Alerta! Correo identificado como phishing.")
else:
    print("Correo legítimo.")

Explicación del código

  1. Carga de datos:
    • Se carga un conjunto de datos de correos electrónicos etiquetados como «phishing» o «legítimos».
  2. Preprocesamiento:
    • Se eliminan filas con valores nulos.
    • Se balancean los datos usando SMOTE para manejar posibles desequilibrios entre clases.
  3. Vectorización del texto:
    • Se utiliza TF-IDF para convertir el texto en características numéricas que el modelo puede procesar.
  4. Entrenamiento del modelo:
    • Se entrena un clasificador Random Forest con optimización de hiperparámetros usando GridSearchCV.
  5. Evaluación del modelo:
    • Se evalúa el modelo con métricas como precisión, recall, F1-score y AUC-ROC.
    • Se visualiza la matriz de confusión y la curva ROC.
  6. Guardar y cargar el modelo:
    • Se guardan el modelo entrenado y el vectorizador para su uso futuro.
  7. Predicción en tiempo real:
    • Se simula la detección de un nuevo correo electrónico y se predice si es phishing o legítimo.

Características clave para detectar phishing bancario

  • Palabras clave sospechosas: «cuenta suspendida», «verifique su información», «clic aquí».
  • Dominios de remitentes sospechosos: Correos que no provienen de dominios oficiales del banco.
  • Errores gramaticales: Frases mal redactadas o con errores ortográficos.
  • Enlaces maliciosos: URLs que no coinciden con el dominio oficial del banco.

Resultados esperados

  • El modelo debería predecir con alta precisión si un correo es phishing o legítimo.
  • Las visualizaciones te ayudarán a interpretar mejor los resultados.

Próximos pasos

  1. Integración con un sistema de correo:
    • Conectar el modelo a un cliente de correo electrónico para filtrar automáticamente mensajes sospechosos.
  2. Mejora del modelo:
    • Probar otros algoritmos como XGBoost, LightGBM o redes neuronales (por ejemplo, LSTM o BERT).
  3. Detección de URLs maliciosas:
    • Incluir análisis de enlaces en los correos para mejorar la detección.
  4. Notificaciones:
    • Enviar alertas a los usuarios cuando se detecte un correo phishing.

Como veis, este código utiliza las librerías «Pandas» y «Numpy», amén de otras. Espero que os sea útil.

Veces visto: 388
0
Modelo Predictivo en IA Para Detección Ransomware (II)

Entradas relacionadas

No hay comentarios

Aún no hay comentarios

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *