ann_with_unsw-db15.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3beaf000-6394-46f5-8573-0ef53fe6f272",
   "metadata": {},
   "source": [
    "## Se instalan las dependencias usando pip\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2961d3b1-20a1-4987-bca9-ecddb4034600",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install keras-tuner -q\n",
    "!pip install pandas numpy seaborn scikit-learn tensorflow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "473bc3b1-7d96-4c49-bed2-1f00d040ebb9",
   "metadata": {},
   "source": [
    "## Se importan los elementos a usar\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4752bd05-9e45-4d92-ac64-2725ee2cd485",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import keras_tuner\n",
    "from tensorflow import keras\n",
    "from matplotlib import pyplot as plt\n",
    "from os import path, mkdir\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "from keras import Sequential\n",
    "from keras.layers import Dense, Dropout, Input, Normalization, BatchNormalization\n",
    "from keras.optimizers import Adam"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15c8a9c9-cd29-4c02-9af2-8f60648984a3",
   "metadata": {},
   "source": [
    "## Se definen constantes\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0d618a5-2361-4dde-8a30-2eeb675c54d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# parametros usados para cargar el dataset\n",
    "DATASET_COLUMNS = ['sbytes', 'dbytes', 'smean', 'sload', 'ct_state_ttl', 'sttl', 'dttl', 'rate', 'dur', 'dmean']\n",
    "DATASET_COLUMN_LABEL_NAME = 'label'\n",
    "BASE_PATH = path.join('.', 'datasets', 'unsw-nb15')\n",
    "\n",
    "# parametros usados para dividir el dataset en validation y test\n",
    "VALIDATION_SIZE = 0.2\n",
    "RANDOM_STATE = 20\n",
    "\n",
    "# parametros usados para el entrenar el modelo\n",
    "NUM_EPOCHS = 45\n",
    "\n",
    "# parametros usados para el ajuste de hiperparametros\n",
    "# cantidad de modelos a probar\n",
    "NUM_MODELS_TO_TEST = 5\n",
    "# cantidad de veces que se va a probar el modelo\n",
    "NUM_TEST_PER_MODEL = 2\n",
    "# objetivo a maximizar / minimizar\n",
    "OBJECTIVE = 'val_loss'\n",
    "# ruta de la carpeta raíz que contiene la carpeta que va a guardar los modelos\n",
    "BASE_MODEL_DIRECTORY = path.join('.')\n",
    "# carpeta donde se va a guardar el modelo encontrado por keras_tuner\n",
    "MODEL_DIRECTORY = 'models'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ca97c35-6b69-47c5-9146-98a2cf0224ad",
   "metadata": {},
   "source": [
    "## Se verifica que exista la carpeta models\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32d75e19-3f13-4771-9aa6-9ee7f9d55ac3",
   "metadata": {},
   "outputs": [],
   "source": [
    "MODEL_DIRECTORY_PATH = path.join(BASE_MODEL_DIRECTORY, MODEL_DIRECTORY)\n",
    "\n",
    "if not path.exists(MODEL_DIRECTORY_PATH):\n",
    "    mkdir(MODEL_DIRECTORY_PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37c2ee8d-696d-49e0-af35-b04d1dd47c12",
   "metadata": {},
   "source": [
    "## Se definen funciones\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a47c8790-7384-4412-8052-d79d221dae66",
   "metadata": {},
   "outputs": [],
   "source": [
    "# basado en la selección de características del paper\n",
    "# https://www.researchgate.net/publication/320944473_Towards_Developing_Network_forensic_mechanism_for_Botnet_Activities_in_the_IoT_based_on_Machine_Learning_Techniques\n",
    "def load_dataset(path, columns, label_column_name):\n",
    "    # se carga el archivo csv como un pandas dataframe\n",
    "    df = pd.read_csv(path)\n",
    "    # se quitan las etiquetas del dataset\n",
    "    labels = df.pop(label_column_name)\n",
    "    # se transforman a numpy array de tipo float 32\n",
    "    labels = labels.to_numpy(dtype=np.float32)\n",
    "    # se obtienen las características del dataframe correspondientes\n",
    "    features = df[columns]\n",
    "    # se transforman a numpy array de ti´po float 32\n",
    "    features = features.to_numpy(dtype=np.float32)\n",
    "    return features, labels"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d95e33f8-8213-45b9-ad6b-bdd34b9aad8b",
   "metadata": {},
   "source": [
    "## Se cargan los vectores de características y las correspondientes etiquetas usados para entrenar el modelo\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e56fb7e3-988b-4d94-9f7e-9aa1a924158d",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_features, train_labels = load_dataset(path.join(BASE_PATH, 'training.csv'), DATASET_COLUMNS, DATASET_COLUMN_LABEL_NAME)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72c85936-77d0-48e9-bb14-6e91d3c81c25",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(train_features)\n",
    "print(train_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e62ba330-c415-4adf-aad1-7924ee5b1df3",
   "metadata": {},
   "source": [
    "## Se cargan los vectores de características y las correspondientes etiquetas usados para probar el modelo\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2dd05a2-eaad-4c24-b0f0-52a67ce5f7bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "testing_features, testing_labels = load_dataset(path.join(BASE_PATH, 'testing.csv'), DATASET_COLUMNS, DATASET_COLUMN_LABEL_NAME)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5684f965-8da7-40ac-b060-500d7f169c50",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(testing_features)\n",
    "print(testing_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ead5a327-9cd9-4c33-a1ba-13de06095e37",
   "metadata": {},
   "source": [
    "## Se divide el conjunto de prueba en validación y prueba\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80cfbc25-42c2-4520-8faf-aab7c488ab55",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_features, validation_features, test_labels, validation_labels = train_test_split(testing_features, testing_labels, test_size=VALIDATION_SIZE, random_state=RANDOM_STATE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccb43482-f167-4293-9402-4ef0f6ffc44a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(test_labels))\n",
    "print(len(validation_labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "647aa3e4-e970-42d4-82d1-73c2e3a2cd75",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(validation_features)\n",
    "print(validation_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65dff265-ae79-4618-bb84-dd20c4ecc76d",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(test_features)\n",
    "print(test_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0b8a820-cfb0-48ee-a9df-9a9feef299c1",
   "metadata": {},
   "source": [
    "## Ajuste de hiperparámetros para encontrar el modelo con menor val loss\n",
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4e0b0bd-29bb-4bcf-9578-e55f5adebdfb",
   "metadata": {},
   "source": [
    "### Se definen funciones para definir los modelos y crear los modelos mediante ajuste de hiperparámetros\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a7fec54-9430-4394-b378-287cf3794cb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define la estructura del modelo\n",
    "def define_model(input_shape, train_features, num_layers, units_selected_per_layer, activation_per_dense_layer,\n",
    "                 learning_rate, loss, metrics, dropout_before_first_hidden_layer = False, dropout = False,\n",
    "                 dropout_rate = None, batch_normalization = False):\n",
    "    # Se define preprocesamiento\n",
    "    normalization = Normalization()\n",
    "    normalization.adapt(train_features)\n",
    "    \n",
    "    # Definición del modelo\n",
    "    model = keras.Sequential()\n",
    "    model.add(Input(shape = input_shape))\n",
    "    model.add(normalization)\n",
    "    if dropout_before_first_hidden_layer:\n",
    "        model.add(Dropout(rate = dropout_rate))\n",
    "    for layer in range(num_layers):\n",
    "        if dropout and layer != 0:\n",
    "            model.add(Dropout(rate = dropout_rate))\n",
    "        model.add(Dense(units = units_selected_per_layer[layer], activation = activation_per_dense_layer))\n",
    "        if batch_normalization:\n",
    "            model.add(BatchNormalization())\n",
    "    if dropout:\n",
    "        model.add(Dropout(rate = dropout_rate))\n",
    "    model.add(Dense(units = 1, activation = 'sigmoid'))\n",
    "\n",
    "    # Definición de la compilación\n",
    "    model.compile(\n",
    "        optimizer = Adam(learning_rate = learning_rate),\n",
    "        loss = loss,\n",
    "        metrics = metrics\n",
    "    )\n",
    "\n",
    "    return model\n",
    "\n",
    "# crea el modelo\n",
    "def create_build_model(input_shape, train_features):\n",
    "    def build_model(hp):\n",
    "        # parametros para configurar el modelo\n",
    "        NUM_MIN_LAYERS = 1\n",
    "        NUM_MAX_LAYERS = 3\n",
    "        \n",
    "        units_selected_per_hidden_layer = []\n",
    "        activation_per_dense_layer = hp.Choice(\"activation\", ['relu', 'elu', 'leaky_relu'])\n",
    "        num_hidden_layers = hp.Choice('num_layers', list(range(NUM_MIN_LAYERS, NUM_MAX_LAYERS + 1)))\n",
    "        dropout_before_first_hidden_layer = hp.Boolean(\"dropout_before_first_layer\")\n",
    "        dropout = hp.Boolean(\"dropout\")\n",
    "        dropout_rate = None\n",
    "        with hp.conditional_scope(\"dropout\", [True]):\n",
    "            dropout_rate = hp.Choice(\"dropout_rate\", [0.25, 0.3, 0.35, 0.4, 0.45, 0.5])\n",
    "        batch_normalization = hp.Boolean(\"batch_normalization\")\n",
    "        # si dropout y batch_normalization son false, se usa por lo menos la capa de batch_normalization\n",
    "        batch_normalization = True if not (dropout or batch_normalization) else batch_normalization\n",
    "        # cantidad de neuronas usadas en las capas densas de la red\n",
    "        units_per_layers = {\n",
    "            1: [1024, 512, 256, 128, 64, 32],\n",
    "            2: [512, 256, 128, 64, 32, 16],\n",
    "            3: [256, 128, 64, 16, 8]\n",
    "        }\n",
    "\n",
    "        # utilizado para cambiar el indice de las capas dentro del for\n",
    "        last_hidden_layer = num_hidden_layers + 1\n",
    "        \n",
    "        for layer in range(1, last_hidden_layer):\n",
    "            with hp.conditional_scope(\"num_layers\", list(range(layer, NUM_MAX_LAYERS + 1))):\n",
    "                units_in_this_layer = units_per_layers[layer]\n",
    "                units_selected_per_hidden_layer.append(hp.Choice(f\"units_hidden_layer_{layer}\", units_in_this_layer))\n",
    "    \n",
    "        # parametros para configurar el compilador\n",
    "        learning_rate = hp.Float(\"lr\", min_value = 0.00001, max_value = 0.1, sampling = \"log\")\n",
    "        loss = hp.Choice(\"loss\", ['binary_crossentropy', 'binary_focal_crossentropy'])\n",
    "        metrics = ['accuracy']\n",
    "    \n",
    "        model = define_model(input_shape, train_features, num_hidden_layers, units_selected_per_hidden_layer,\n",
    "                             activation_per_dense_layer, learning_rate, loss, metrics,\n",
    "                             dropout_before_first_hidden_layer = dropout_before_first_hidden_layer, dropout = dropout,\n",
    "                             dropout_rate = dropout_rate, batch_normalization = batch_normalization)\n",
    "        model.summary()\n",
    "        \n",
    "        return model\n",
    "    return build_model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce7d7c09-2f35-4d01-9e5d-177d9945b267",
   "metadata": {},
   "source": [
    "### Se configura la estrategía de búsqueda de hiperparámetros\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f3e15c5-cacd-44f1-9e71-44102367934b",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_features = train_features.shape[1]\n",
    "input_shape = (num_features,)\n",
    "\n",
    "tuner = keras_tuner.BayesianOptimization(\n",
    "    hypermodel = create_build_model(input_shape, train_features),\n",
    "    objective = OBJECTIVE,\n",
    "    max_trials = NUM_MODELS_TO_TEST,\n",
    "    executions_per_trial = NUM_TEST_PER_MODEL,\n",
    "    overwrite = True,\n",
    "    directory = BASE_MODEL_DIRECTORY,\n",
    "    project_name = MODEL_DIRECTORY\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0c03b3d-3468-4758-b64b-c0143fb39f47",
   "metadata": {},
   "outputs": [],
   "source": [
    "tuner.search_space_summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e3c8fa0-cb12-496b-8c59-c2f90479fc0e",
   "metadata": {},
   "source": [
    "### Se realiza la búsqueda de los hiperparámetros\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b06d24b8-b7a2-4fc1-b3bd-2e92c3041f5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "tuner.search(train_features, train_labels, epochs = NUM_EPOCHS, validation_data = (validation_features, validation_labels), shuffle = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c85a0ef-6be9-4c57-8a9f-6ba9956ef104",
   "metadata": {},
   "source": [
    "## Resumen del ajuste de hiperparámetros\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f541f228-a06c-4608-bbbe-a235f8d7391b",
   "metadata": {},
   "outputs": [],
   "source": [
    "tuner.results_summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1f0d89c-44cf-45ff-a980-c5afa37a51ce",
   "metadata": {},
   "source": [
    "## Obtener el mejor modelo\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "992496b4-88fb-4946-b1d8-b2e95a41db35",
   "metadata": {},
   "outputs": [],
   "source": [
    "models = tuner.get_best_models(num_models = 1)\n",
    "best_model = models[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "134f23ac-47d5-47fc-8ab8-a5fafd4f3dd5",
   "metadata": {},
   "source": [
    "## Arquitectura del modelo\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "704c635a-ad81-40e1-a9e9-911e4f1b3584",
   "metadata": {},
   "outputs": [],
   "source": [
    "best_model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bdcf543-f589-4d6d-805b-684c1cb6fdb4",
   "metadata": {},
   "source": [
    "## Se obtiene nuevamente el conjunto de pruebas completo a partir del conjuto de datos de validación y prueba\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62049da8-4fc5-4830-a627-f2decc42865d",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_features = np.concatenate((test_features, validation_features))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dac6cd2a-4388-4b32-9797-851b17bb428c",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_labels = np.concatenate((test_labels, validation_labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8f25faa-ad64-4237-984b-a7a0e9bf3f7a",
   "metadata": {},
   "source": [
    "## Se realiza la predicción\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f997341e-7da8-441d-a1b3-c263c045fda7",
   "metadata": {},
   "outputs": [],
   "source": [
    "predict = best_model.predict(test_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b11be2b1-2085-49cd-902c-14fdc0ad16b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(predict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc7044b9-0b96-422f-a069-651024d86bf7",
   "metadata": {},
   "source": [
    "## Se etiquetan las probabilidades con las etiquetas de la clase a la que pertenecen, utilizando un umbral\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8ba7f54-11be-4241-bf30-439f5e8b2fb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#transformar probabilidades en enteros\n",
    "predict_labels = np.array([1 if x >= 0.5 else 0 for x in predict.flatten()], dtype = np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d7102f5-b416-4a44-9978-d7e2e22f1cbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(predict_labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a35744a-9e24-4dcf-9c9e-1e796736f8ae",
   "metadata": {},
   "source": [
    "## Se obtienen las métricas de clasificación\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4a029b5-39f4-4880-bb66-276969ded540",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(classification_report(test_labels, predict_labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53dea784-a0e1-4e2e-ac7c-08dade71bf58",
   "metadata": {},
   "source": [
    "## Se obtienen las matrices de confusión\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f305a20-4846-4aae-ab0b-e732e791e3b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "result = confusion_matrix(test_labels, predict_labels)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82ef0cff-c164-43d2-9208-858125e51ca2",
   "metadata": {},
   "source": [
    "### Matriz de confusión que muestra la cantidad de datos clasificados\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9e36be5-2cd5-41bf-81eb-248e48b9dde4",
   "metadata": {},
   "outputs": [],
   "source": [
    "confusion_matrix_labels = ['Tráfico de red normal', 'Tráfico de red bajo ataque']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12fc9b38-68fc-48f0-b550-5025b1822318",
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix = sns.heatmap(result, annot = True, xticklabels = confusion_matrix_labels, yticklabels = confusion_matrix_labels)\n",
    "_ = matrix.set(xlabel = \"Valor real\", ylabel = \"Valor predicho\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36dff7c6-4430-4ba2-b1fc-da9a76420831",
   "metadata": {},
   "source": [
    "### Matriz de confusión que muestra el porcentaje de datos clasificados por filas\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "390eceaa-b960-4b67-9e4d-b89a7425181f",
   "metadata": {},
   "outputs": [],
   "source": [
    "porcentaje = result / np.sum(result, axis = 1).reshape(2,1)\n",
    "matrix = sns.heatmap(porcentaje, annot = True, xticklabels = confusion_matrix_labels, yticklabels = confusion_matrix_labels)\n",
    "_ = matrix.set(xlabel = \"Valor real %\", ylabel = \"Valor predicho %\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "039f50d8-2ba8-4483-9215-919c2a2f90ad",
   "metadata": {},
   "source": [
    "## Comparación equiparable a la realizada en el paper https://www.researchgate.net/publication/320944473_Towards_Developing_Network_forensic_mechanism_for_Botnet_Activities_in_the_IoT_based_on_Machine_Learning_Techniques\n",
    "-----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06d8db75-fe43-4a58-98c1-20d11be0ad99",
   "metadata": {},
   "source": [
    "### Se obtiene el conjunto de datos total al combinar los datasets de entrenamiento, validación y prueba\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "162ea717-beb3-4023-a713-6ec71afb0b07",
   "metadata": {},
   "outputs": [],
   "source": [
    "paper_comparison_features = np.concatenate((train_features, test_features))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "312306f3-9fca-4ddb-bc3b-3f6204cdc572",
   "metadata": {},
   "outputs": [],
   "source": [
    "paper_comparison_labels = np.concatenate((train_labels, test_labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc218030-4923-4283-8cc2-703c5ad9eaab",
   "metadata": {},
   "source": [
    "### Se realiza la predicción\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3baf0ed2-b507-4782-a771-a1e7a2a1716c",
   "metadata": {},
   "outputs": [],
   "source": [
    "paper_comparison_predict = best_model.predict(paper_comparison_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e76643f-1a51-4998-8acc-9fd7824cec0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(paper_comparison_predict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00548184-2b67-44be-8875-647ae796f553",
   "metadata": {},
   "source": [
    "### Se etiquetan las probabilidades con las etiquetas de la clase a la que pertenecen, utilizando un umbral\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9c7ffc9-8cae-4100-aac2-fcc1bddcd6ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "#transformar probabilidades en enteros\n",
    "paper_comparison_predict_labels = np.array([1 if x >= 0.5 else 0 for x in paper_comparison_predict.flatten()], dtype = np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa44522d-082e-4016-8b55-c98eb5ab77c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(paper_comparison_predict_labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97691cc4-8108-4d8a-9fc9-d46fd636de89",
   "metadata": {},
   "source": [
    "### Se obtienen las métricas de clasificación\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e0faa5f-a850-45e8-98be-44db2b519255",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(classification_report(paper_comparison_labels, paper_comparison_predict_labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34e23bad-05d6-4c4c-8f39-c4bfac4e9667",
   "metadata": {},
   "source": [
    "### Se obtienen las matrices de confusión\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b783910d-31fa-46da-a429-30522049f254",
   "metadata": {},
   "outputs": [],
   "source": [
    "paper_comparison_result = confusion_matrix(paper_comparison_labels, paper_comparison_predict_labels)\n",
    "print(paper_comparison_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75bbce49-84a1-4935-8a6e-d995f1c4d125",
   "metadata": {},
   "source": [
    "#### Matriz de confusión que muestra la cantidad de datos clasificados\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f94c9e0e-71a5-4664-bb0d-3275a42dad4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "confusion_matrix_labels = ['Tráfico de red normal', 'Tráfico de red bajo ataque']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "718e44ba-0d81-4d39-a73c-89e21ef670b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "paper_comparison_matrix = sns.heatmap(paper_comparison_result, annot = True, xticklabels = confusion_matrix_labels, yticklabels = confusion_matrix_labels)\n",
    "_ = paper_comparison_matrix.set(xlabel = \"Valor real\", ylabel = \"Valor predicho\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d5e35da-492e-44ed-be72-e10563744ac6",
   "metadata": {},
   "source": [
    "#### Matriz de confusión que muestra el porcentaje de datos clasificados por filas\n",
    "-----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de0264da-d614-433b-ae73-245e9e730972",
   "metadata": {},
   "outputs": [],
   "source": [
    "paper_comparison_porcentaje = paper_comparison_result / np.sum(paper_comparison_result, axis = 1).reshape(2,1)\n",
    "paper_comparison_matrix = sns.heatmap(paper_comparison_porcentaje, annot = True, xticklabels = confusion_matrix_labels, yticklabels = confusion_matrix_labels)\n",
    "_ = paper_comparison_matrix.set(xlabel = \"Valor real %\", ylabel = \"Valor predicho %\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7e96173-5174-4d24-b345-f30444e4a5e4",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}