# Importar librerías necesarias
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score
from sklearn.preprocessing import StandardScaler
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
url = «https://example.com/ddos_dataset.csv» # Reemplaza con la URL o ruta de tu dataset
data = pd.read_csv(url)

# 2. Preprocesamiento de datos
# Convertir variables categóricas a numéricas (si las hay)
data = pd.get_dummies(data, columns=[«protocol_type», «flag»], drop_first=True)

# Separar características (X) y etiquetas (y)
X = data.drop(«attack_type», axis=1) # Características
y = data[«attack_type»] # Etiquetas (0: normal, 1: ataque DDoS)

# Balancear los datos (si están desbalanceados)
smote = SMOTE(random_state=42)
X, y = smote.fit_resample(X, y)

# 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)

# Escalar las características para normalizar los datos
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 3. 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, y_train)

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

# 4. Evaluar el modelo
# Validación cruzada
cv_scores = cross_val_score(best_model, X_train, y_train, cv=5, scoring=’accuracy’)
print(«Precisión en validación cruzada:», np.mean(cv_scores))

# Predicciones en el conjunto de prueba
y_pred = best_model.predict(X_test)
y_pred_proba = best_model.predict_proba(X_test)[:, 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))

# 5. 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()

# 6. Guardar el modelo entrenado
joblib.dump(best_model, «ddos_detection_model.pkl»)
joblib.dump(scaler, «scaler.pkl»)

# 7. Cargar el modelo y hacer predicciones en tiempo real (simulación)
# Cargar el modelo y el escalador
loaded_model = joblib.load(«ddos_detection_model.pkl»)
loaded_scaler = joblib.load(«scaler.pkl»)

# Simular un nuevo registro de tráfico de red
new_traffic = [[5, 100, 200, 0, 1, 0, 1]] # Ejemplo de características
new_traffic_scaled = loaded_scaler.transform(new_traffic) # Escalar el nuevo dato
prediction = loaded_model.predict(new_traffic_scaled)

if prediction[0] == 1:
print(«¡Alerta! Posible ataque DDoS detectado.»)
else:
print(«Tráfico normal.»)