Clase_12__Churn_Analysis__Tensorflow_Keras__1.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E4OEtECGjKtp"
      },
      "source": [
        "# Curso Deep Learning\n",
        "\n",
        "<img src=\"https://yaelmanuel.com/wp-content/uploads/2021/12/platzi-banner-logo-matematicas.png\" width=\"500px\">\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p_ny9c9fjbLP"
      },
      "source": [
        "## Creando nuestro propio Churn Analysis 🤓📊\n",
        "\n",
        "En este lab aprenderás:\n",
        "\n",
        "* [Tensorflow](https://www.tensorflow.org/)\n",
        "* [Keras](https://keras.io/)\n",
        "* Descargar un dataset, prepararlo, entrenarlo, realizar finetuning y guardarlo.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fxgR3AqoTxQP"
      },
      "source": [
        "### 1) Descarga del dataset 🤓\n",
        "\n",
        "Utilizaremos un conjunto de datos de un proveedor de Telecomunicaciones para su Programa de Retención.\n",
        "<br>Para más detalle acá se puede ver el dataset de Kaggle: [Telco Customer Churn](https://www.kaggle.com/datasets/blastchar/telco-customer-churn/data).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5WVoiMyphoSc"
      },
      "outputs": [],
      "source": [
        "!pip install --upgrade --force-reinstall --no-deps kaggle"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Lv-i750ghtiv"
      },
      "outputs": [],
      "source": [
        "from google.colab import files\n",
        "files.upload()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kgDVQkKGibgT"
      },
      "outputs": [],
      "source": [
        "!mkdir -p ~/.kaggle\n",
        "!cp kaggle.json ~/.kaggle/\n",
        "!chmod 600 /root/.kaggle/kaggle.json"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b9JJy0CIhxNn"
      },
      "outputs": [],
      "source": [
        "!kaggle datasets list -s telco-customer-churn"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "z10nbuiQh4av"
      },
      "outputs": [],
      "source": [
        "!kaggle datasets download -d blastchar/telco-customer-churn"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T-6HAPlAiza9"
      },
      "outputs": [],
      "source": [
        "!unzip '/content/telco-customer-churn.zip'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HX8Q_QXsTts3"
      },
      "source": [
        "### 2) Preparación de la data 👌"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BYa0Tjnv74mE"
      },
      "source": [
        "#### 2.1) Instalamos las dependencias 🙌"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DRk5qVls96PG"
      },
      "outputs": [],
      "source": [
        "!pip install ydata-profiling"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Xu_qILeYSLv_"
      },
      "outputs": [],
      "source": [
        "import joblib\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras.models import load_model\n",
        "from tensorflow.keras.callbacks import EarlyStopping\n",
        "\n",
        "from sklearn.preprocessing import LabelEncoder, MinMaxScaler\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import confusion_matrix, classification_report, roc_curve, auc"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ull0vjyr9Ihl"
      },
      "source": [
        "#### 2.2) Explorar Dataset 🔍"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DSj6JT8QWbtG"
      },
      "outputs": [],
      "source": [
        "!ls"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "r__2J3X5sSPX"
      },
      "outputs": [],
      "source": [
        "df = pd.read_csv(\"WA_Fn-UseC_-Telco-Customer-Churn.csv\", sep=\",\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b0akcxXCsUJl"
      },
      "source": [
        "**Tip:** Para visualizar todas las columnas del dataframe"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2V22BAwcsaxX"
      },
      "outputs": [],
      "source": [
        "df.head(3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1I8KfBKFsSlQ"
      },
      "outputs": [],
      "source": [
        "pd.set_option('display.max_columns', None)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8BgfGwLWsa2g"
      },
      "outputs": [],
      "source": [
        "df.head(3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4Xjwnyq7sijv"
      },
      "source": [
        "#### 2.3) EDA (Análisis Exploratorio de Datos)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X24Wz6o87MD7"
      },
      "source": [
        "Visualizamos qué tenemos en el dataframe"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "64SawhYT61gS"
      },
      "outputs": [],
      "source": [
        "# Crear un resumen utilizando funciones nativas de pandas\n",
        "def summarize_dataframe_with_pandas(df):\n",
        "    summary = df.describe(include='all').T  # Descripción general\n",
        "    summary['Type'] = df.dtypes  # Tipos de datos\n",
        "    summary['Unique Values'] = df.nunique()  # Cantidad de valores únicos\n",
        "    summary['Examples'] = df.apply(lambda col: col.dropna().unique()[:3])  # Ejemplos de valores\n",
        "\n",
        "    # Reorganizar columnas para mejor visualización\n",
        "    summary = summary[['Type', 'Unique Values', 'Examples']]\n",
        "    return summary"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6cEslJiv76pP"
      },
      "outputs": [],
      "source": [
        "summarize_dataframe_with_pandas(df)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UNwp7HdKdZ1g"
      },
      "source": [
        "Una visualización más detallada e interactiva"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Zn1NtF3yddWT"
      },
      "outputs": [],
      "source": [
        "from ydata_profiling import ProfileReport\n",
        "\n",
        "ProfileReport(df, minimal=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X_nMMYAZdjEp"
      },
      "source": [
        "#### 2.4) Valores únicos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FzYhKk6LgPpC"
      },
      "source": [
        "Eliminar columna con valores únicos"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jBpBlS8JdpvW"
      },
      "outputs": [],
      "source": [
        "df = df.drop('customerID', axis=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BbX5yn_hdrcE"
      },
      "source": [
        "Eliminar columna con que puede generar Bias o Sesgo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dkkBy6Ladt_y"
      },
      "outputs": [],
      "source": [
        "df = df.drop('gender', axis=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6uO2wy_utdOb"
      },
      "source": [
        "#### 2.5) Valores faltantes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2Cx-F3t6tgpS"
      },
      "outputs": [],
      "source": [
        "# Evaluar cantidad de valores faltantes\n",
        "df.isnull().sum()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UpB8G4J8t6sb"
      },
      "source": [
        "#### 2.6) Columnas Categóricas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z_JusynMTbFK"
      },
      "source": [
        "Reeplazo de valores binarios en columnas categóricas"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zaW6B2TVSOHf"
      },
      "outputs": [],
      "source": [
        "# Evitar warning por uso de Replace\n",
        "pd.set_option('future.no_silent_downcasting', True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aT8zAREQEu-v"
      },
      "outputs": [],
      "source": [
        "categorical_columns = list(df.select_dtypes(include='O').keys())\n",
        "\n",
        "for i in categorical_columns:\n",
        "    df[i] = df[i].replace('Yes', 1)\n",
        "    df[i] = df[i].replace('No', 0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sBC3NCDLuLMX"
      },
      "source": [
        "Label Encoder"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3HdfTTXrpLIi"
      },
      "outputs": [],
      "source": [
        "# Inicializar y aplicar LabelEncoder único\n",
        "label_encoders = {}\n",
        "for col in categorical_columns:\n",
        "    le = LabelEncoder()\n",
        "    df[col] = le.fit_transform(df[col].astype(str))  # Codificar las columnas categóricas\n",
        "    label_encoders[col] = le  # Guardar el codificador único para cada columna"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L3NOyy6OZgqu"
      },
      "outputs": [],
      "source": [
        "# Guardar los label encoders\n",
        "joblib.dump(label_encoders, 'label_encoders.pkl')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oNOGq3DnTgQN"
      },
      "source": [
        "#### 2.7) Columnas Numéricas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bjnijN7ovJrL"
      },
      "source": [
        "Escalar la data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ywAu-R-TvNBx"
      },
      "outputs": [],
      "source": [
        "scale_cols = ['tenure','MonthlyCharges','TotalCharges']\n",
        "\n",
        "scale = MinMaxScaler()\n",
        "df[scale_cols] = scale.fit_transform(df[scale_cols])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kSO9nFvyZwyW"
      },
      "outputs": [],
      "source": [
        "# Guardar el escalado de datos\n",
        "joblib.dump(scale, 'scaler.pkl')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z5CReMaiYSDt"
      },
      "source": [
        "### 3) Entrenamiento 💪"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wvL5xN1kvayu"
      },
      "outputs": [],
      "source": [
        "x = df.drop('Churn', axis=1)\n",
        "y = df['Churn']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TdTSu9R6vdZU"
      },
      "outputs": [],
      "source": [
        "xtrain, xtest, ytrain, ytest = train_test_split(x, y, test_size=0.2)\n",
        "\n",
        "print(xtrain.shape, ytrain.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Wpy8DqtWeb7j"
      },
      "outputs": [],
      "source": [
        "print(xtest.shape, ytest.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NdRZS4ZactJU"
      },
      "source": [
        "### 4) Red Neuronal 😨"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install keras-tuner"
      ],
      "metadata": {
        "id": "g8IB8P1Vnjhw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from keras_tuner import RandomSearch"
      ],
      "metadata": {
        "id": "Yu3JDRScnh7n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4ibs8FIvCePP"
      },
      "outputs": [],
      "source": [
        "# Obtener el número de columnas de entrenamiento\n",
        "num_columns = 18"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Función para construir el modelo**"
      ],
      "metadata": {
        "id": "ISeUAWAbnoSQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def build_model(hp):\n",
        "    model = keras.Sequential([\n",
        "        keras.layers.Input(shape=(num_columns,))\n",
        "        ])\n",
        "\n",
        "    # Primera capa con ajuste de unidades y función de activación\n",
        "    model.add(keras.layers.Dense(units=hp.Int('units_layer1', min_value=10, max_value=16, step=2),\n",
        "                    activation=hp.Choice('activation_layer1', values=['relu', 'tanh'])))\n",
        "\n",
        "    # Dropout ajustable\n",
        "    model.add(keras.layers.Dropout(rate=hp.Float('dropout_layer1', min_value=0.0, max_value=0.5, step=0.1)))\n",
        "\n",
        "    # Segunda capa opcional\n",
        "    if hp.Boolean('second_layer'):\n",
        "        model.add(keras.layers.Dense(units=hp.Int('units_layer2', min_value=5, max_value=10, step=1),\n",
        "                        activation=hp.Choice('activation_layer2', values=['relu', 'tanh'])))\n",
        "        model.add(keras.layers.Dropout(rate=hp.Float('dropout_layer2', min_value=0.0, max_value=0.5, step=0.1)))\n",
        "\n",
        "    # Capa de salida\n",
        "    model.add(keras.layers.Dense(1, activation='sigmoid'))\n",
        "\n",
        "    # Compilación\n",
        "    model.compile(\n",
        "        optimizer=hp.Choice('optimizer', values=['adam', 'adamW']),\n",
        "        loss='binary_crossentropy',\n",
        "        metrics=['accuracy'])\n",
        "\n",
        "    return model"
      ],
      "metadata": {
        "id": "xaHYtBzym9Xb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Configurar KerasTuner**"
      ],
      "metadata": {
        "id": "Z2Zuee0Insdf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tuner = RandomSearch(\n",
        "    build_model,\n",
        "    objective='val_accuracy',  # Métrica a optimizar\n",
        "    max_trials=10,             # Número de combinaciones a probar\n",
        "    executions_per_trial=2,    # Número de ejecuciones por combinación\n",
        "    directory='my_dir',        # Carpeta para guardar resultados\n",
        "    project_name='churn_tuning'  # Nombre del proyecto\n",
        ")"
      ],
      "metadata": {
        "id": "_XMJTcRrnt8z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Ejecutar la búsqueda**\n",
        "\n",
        "Vamos a probar con 20 epochs"
      ],
      "metadata": {
        "id": "0MHSPoFZn6oe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tuner.search(xtrain, ytrain, epochs=20, validation_data=(xtest, ytest))"
      ],
      "metadata": {
        "id": "iKb1OxV6n7AI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Obtener el mejor modelo**"
      ],
      "metadata": {
        "id": "8bbuQBlyoNdI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]\n",
        "print(\"Mejores hiperparámetros encontrados:\")\n",
        "print(f\"- Unidades primera capa: {best_hps.get('units_layer1')}\")\n",
        "print(f\"- Optimizer: {best_hps.get('optimizer')}\")\n",
        "print(f\"- Dropout primera capa: {best_hps.get('dropout_layer1')}\")"
      ],
      "metadata": {
        "id": "WSf3CLvsoQh0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Construir el mejor modelo**"
      ],
      "metadata": {
        "id": "Ortw75yyoUsH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "best_model = tuner.hypermodel.build(best_hps)"
      ],
      "metadata": {
        "id": "sIwzQxt0oWgB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "keras.utils.plot_model(best_model, show_shapes=True)"
      ],
      "metadata": {
        "id": "UxqMTQATrehy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Entrenar el mejor modelo**\n",
        "\n",
        "Probamos con 50 epochs"
      ],
      "metadata": {
        "id": "82F_GwtrIem-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Agregamos el Early Stopping\n",
        "early_stop = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)"
      ],
      "metadata": {
        "id": "LP09YSkgrmNu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "history = best_model.fit(xtrain, ytrain, epochs=50, validation_data=(xtest, ytest), callbacks=[early_stop])"
      ],
      "metadata": {
        "id": "rOiVYTaGGUeU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BkY3Xe9fDhN3"
      },
      "source": [
        "### 5) Métricas 📊"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "***Ahora las métricas obtenidas son para best_model.***"
      ],
      "metadata": {
        "id": "qfPv5iu4rywW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Matriz de Confusión**"
      ],
      "metadata": {
        "id": "5VCtXik4HUv5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred = (best_model.predict(xtest) > 0.5)  # Convertir las probabilidades a 0 o 1\n",
        "cm = confusion_matrix(ytest, y_pred)\n",
        "\n",
        "plt.figure(figsize=(6, 6))\n",
        "sns.heatmap(cm, annot=True, fmt='d', cmap='Greens', xticklabels=['No', 'Yes'], yticklabels=['No', 'Yes'])\n",
        "plt.title(\"Matriz de Confusión\")\n",
        "plt.xlabel(\"Predicción\")\n",
        "plt.ylabel(\"Real\")\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "YkaiSeFJHWSK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Reporte de Métricas**"
      ],
      "metadata": {
        "id": "3o1bxyhoMHDX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "report = classification_report(ytest, y_pred, target_names=['No', 'Yes'])\n",
        "print(report)"
      ],
      "metadata": {
        "id": "PfAXHDpUMIpC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Gráfica de Accuracy**"
      ],
      "metadata": {
        "id": "_zr7H5aBH5Fz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(12, 6))\n",
        "\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(history.history['accuracy'], label='Accuracy Entrenamiento')\n",
        "plt.plot(history.history['val_accuracy'], label='Accuracy Validación')\n",
        "plt.title('Accuracy vs Epochs')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "m9lhFjPmH5pU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Gráfica de Loss**"
      ],
      "metadata": {
        "id": "-IdFBT7gIAXu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(history.history['loss'], label='Loss Entrenamiento')\n",
        "plt.plot(history.history['val_loss'], label='Loss Validación')\n",
        "plt.title('Loss vs Epochs')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "Wz3_0iMjICL6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Curva ROC**"
      ],
      "metadata": {
        "id": "IOsroFjDkjrZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Obtener las predicciones de probabilidades\n",
        "y_pred_train = (best_model.predict(xtrain) > 0.5)  # Convertir las probabilidades a 0 o 1\n",
        "\n",
        "# Calcular las métricas de la curva ROC para entrenamiento\n",
        "fpr_train, tpr_train, _ = roc_curve(ytrain, y_pred_train)\n",
        "roc_auc_train = auc(fpr_train, tpr_train)\n",
        "\n",
        "# Calcular las métricas de la curva ROC para validación\n",
        "fpr_val, tpr_val, _ = roc_curve(ytest, y_pred)\n",
        "roc_auc_val = auc(fpr_val, tpr_val)\n",
        "\n",
        "# Graficar ambas curvas ROC\n",
        "plt.figure(figsize=(8, 6))\n",
        "plt.plot(fpr_train, tpr_train, color='blue', lw=2, label=f'Train ROC (AUC = {roc_auc_train:.2f})')\n",
        "plt.plot(fpr_val, tpr_val, color='green', lw=2, label=f'Validation ROC (AUC = {roc_auc_val:.2f})')\n",
        "plt.plot([0, 1], [0, 1], color='red', linestyle='--', lw=2, label='Random guess')\n",
        "plt.xlim([0.0, 1.0])\n",
        "plt.ylim([0.0, 1.05])\n",
        "plt.xlabel('False Positive Rate', fontsize=14)\n",
        "plt.ylabel('True Positive Rate', fontsize=14)\n",
        "plt.title('Receiver Operating Characteristic (ROC)', fontsize=16)\n",
        "plt.legend(loc=\"lower right\", fontsize=12)\n",
        "plt.grid(alpha=0.3)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "A2EZoDDgldfW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F2MHfLfbxrtc"
      },
      "source": [
        "### 6) Guardar el modelo 💾"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Guardar en formato HDF5\n",
        "best_model.save('mi_modelo_entrenado.keras')"
      ],
      "metadata": {
        "id": "9GXPevkwvTb9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**El modelo pesa ~28 KB.**"
      ],
      "metadata": {
        "id": "-tAqdKl_1ypP"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "icAp1SniSDuN"
      },
      "source": [
        "### 7) Hacer Predicciones en Producción 🤙"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import joblib\n",
        "import pandas as pd\n",
        "\n",
        "from tensorflow.keras.models import load_model\n",
        "from sklearn.preprocessing import LabelEncoder, MinMaxScaler"
      ],
      "metadata": {
        "id": "JnS8BG4YaaX4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Cargar el modelo una vez (al inicio de la aplicación)"
      ],
      "metadata": {
        "id": "SRtZXB8LSRw-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Cargar los objetos de preprocesamiento guardados\n",
        "label_encoders = joblib.load('label_encoders.pkl')\n",
        "scaler = joblib.load('scaler.pkl')\n",
        "\n",
        "# Cargar el modelo entrenado\n",
        "model = load_model('mi_modelo_entrenado.keras', compile=False)"
      ],
      "metadata": {
        "id": "pb51IGwBmExK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Función para predicción / inferencia"
      ],
      "metadata": {
        "id": "7vhsu1naSWb_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Función para preprocesar datos con los objetos guardados\n",
        "def preprocess_data(df):\n",
        "    # Eliminar columnas irrelevantes\n",
        "    df = df.drop(['customerID', 'gender'], axis=1, errors='ignore')\n",
        "\n",
        "    # Reemplazar valores \"Yes\"/\"No\" por 1/0\n",
        "    categorical_columns = list(df.select_dtypes(include='O').keys())\n",
        "    for i in categorical_columns:\n",
        "        df[i] = df[i].replace('Yes', 1)\n",
        "        df[i] = df[i].replace('No', 0)\n",
        "\n",
        "    # Aplicar Label Encoding usando los objetos guardados\n",
        "    for col, le in label_encoders.items():\n",
        "        if col in df.columns:\n",
        "            # Asegurar que los valores sean cadenas antes de la transformación\n",
        "            df[col] = df[col].astype(str)\n",
        "            try:\n",
        "                df[col] = le.transform(df[col])\n",
        "            except ValueError as e:\n",
        "                raise ValueError(\n",
        "                    f\"Error al transformar la columna '{col}'. \"\n",
        "                    f\"Asegúrate de que los valores en los nuevos datos coincidan con los datos de entrenamiento. \"\n",
        "                    f\"Detalles: {e}\"\n",
        "                )\n",
        "\n",
        "    # Aplicar escalado usando el scaler guardado\n",
        "    scale_cols = ['tenure', 'MonthlyCharges', 'TotalCharges']\n",
        "    df[scale_cols] = scaler.transform(df[scale_cols])\n",
        "\n",
        "    return df"
      ],
      "metadata": {
        "id": "a4cgqfzyamcV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def make_prediction(single_case):\n",
        "  # Convertir el caso único en DataFrame\n",
        "  single_case_df = pd.DataFrame(single_case)\n",
        "\n",
        "  # Preprocesar el caso único\n",
        "  processed_single_case = preprocess_data(single_case_df)\n",
        "\n",
        "  # Separar las características del target si aplica\n",
        "  X_single_case = processed_single_case.drop('Churn', axis=1, errors='ignore')\n",
        "\n",
        "  # Realizar predicción\n",
        "  prediction = model.predict(X_single_case)\n",
        "\n",
        "  score = prediction[0][0] * 100\n",
        "  print(f\"Probabilidad que abandone: {score:.2f} %\")\n",
        "\n",
        "  prediction_binary = (prediction > 0.5).astype(int)\n",
        "  print(\"Churn: \", prediction_binary[0][0])"
      ],
      "metadata": {
        "id": "6s03naEraqv_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ejemplos de uso"
      ],
      "metadata": {
        "id": "3gkxguDSSc-P"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Churn: Yes / 1\n",
        "single_case = {\n",
        "    \"customerID\": [\"9237-HQITU\"],\n",
        "    \"gender\": [\"Female\"],\n",
        "    \"SeniorCitizen\": [0],\n",
        "    \"Partner\": [\"No\"],\n",
        "    \"Dependents\": [\"No\"],\n",
        "    \"tenure\": [2],\n",
        "    \"PhoneService\": [\"Yes\"],\n",
        "    \"MultipleLines\": [\"No\"],\n",
        "    \"InternetService\": [\"Fiber optic\"],\n",
        "    \"OnlineSecurity\": [\"No\"],\n",
        "    \"OnlineBackup\": [\"No\"],\n",
        "    \"DeviceProtection\": [\"No\"],\n",
        "    \"TechSupport\": [\"No\"],\n",
        "    \"StreamingTV\": [\"No\"],\n",
        "    \"StreamingMovies\": [\"No\"],\n",
        "    \"Contract\": [\"Month-to-month\"],\n",
        "    \"PaperlessBilling\": [\"Yes\"],\n",
        "    \"PaymentMethod\": [\"Electronic check\"],\n",
        "    \"MonthlyCharges\": [70.70],\n",
        "    \"TotalCharges\": [151.65],\n",
        "}\n",
        "\n",
        "make_prediction(single_case)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RSfBbY3_bVCv",
        "outputId": "060eca40-f0b7-4fa9-f5cb-678a51ad2f6f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 102ms/step\n",
            "Probabilidad que abandone: 63.90 %\n",
            "Churn:  1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Churn: No / 0\n",
        "single_case = {\n",
        "    \"customerID\": [\"7795-CFOCW\"],\n",
        "    \"gender\": [\"Male\"],\n",
        "    \"SeniorCitizen\": [0],\n",
        "    \"Partner\": [\"No\"],\n",
        "    \"Dependents\": [\"No\"],\n",
        "    \"tenure\": [45],\n",
        "    \"PhoneService\": [\"No\"],\n",
        "    \"MultipleLines\": [\"No phone service\"],\n",
        "    \"InternetService\": [\"DSL\"],\n",
        "    \"OnlineSecurity\": [\"Yes\"],\n",
        "    \"OnlineBackup\": [\"No\"],\n",
        "    \"DeviceProtection\": [\"Yes\"],\n",
        "    \"TechSupport\": [\"Yes\"],\n",
        "    \"StreamingTV\": [\"No\"],\n",
        "    \"StreamingMovies\": [\"No\"],\n",
        "    \"Contract\": [\"One year\"],\n",
        "    \"PaperlessBilling\": [\"No\"],\n",
        "    \"PaymentMethod\": [\"Bank transfer (automatic)\"],\n",
        "    \"MonthlyCharges\": [42.30],\n",
        "    \"TotalCharges\": [1840.75],\n",
        "}\n",
        "\n",
        "make_prediction(single_case)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j6wet0s7blhz",
        "outputId": "0a7e0cbb-cd67-4523-9ff7-8e4106d7734e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 36ms/step\n",
            "Probabilidad que abandone: 4.02 %\n",
            "Churn:  0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Churn: No / 0\n",
        "single_case = {\n",
        "    \"customerID\": [\"7590-VHVEG\"],\n",
        "    \"gender\": [\"Female\"],\n",
        "    \"SeniorCitizen\": [0],\n",
        "    \"Partner\": [\"Yes\"],\n",
        "    \"Dependents\": [\"No\"],\n",
        "    \"tenure\": [1],\n",
        "    \"PhoneService\": [\"No\"],\n",
        "    \"MultipleLines\": [\"No phone service\"],\n",
        "    \"InternetService\": [\"DSL\"],\n",
        "    \"OnlineSecurity\": [\"No\"],\n",
        "    \"OnlineBackup\": [\"Yes\"],\n",
        "    \"DeviceProtection\": [\"No\"],\n",
        "    \"TechSupport\": [\"No\"],\n",
        "    \"StreamingTV\": [\"No\"],\n",
        "    \"StreamingMovies\": [\"No\"],\n",
        "    \"Contract\": [\"Month-to-month\"],\n",
        "    \"PaperlessBilling\": [\"Yes\"],\n",
        "    \"PaymentMethod\": [\"Electronic check\"],\n",
        "    \"MonthlyCharges\": [29.85],\n",
        "    \"TotalCharges\": [29.85],\n",
        "}\n",
        "\n",
        "make_prediction(single_case)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d75mtyReb0Hu",
        "outputId": "db7d5c10-6af7-4a55-b8fc-8c797d003a40"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step\n",
            "Probabilidad que abandone: 49.35 %\n",
            "Churn:  0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Churn: Yes / 1\n",
        "single_case = {\n",
        "    \"customerID\": [\"3668-QPYBK\"],\n",
        "    \"gender\": [\"Male\"],\n",
        "    \"SeniorCitizen\": [0],\n",
        "    \"Partner\": [\"No\"],\n",
        "    \"Dependents\": [\"No\"],\n",
        "    \"tenure\": [2],\n",
        "    \"PhoneService\": [\"Yes\"],\n",
        "    \"MultipleLines\": [\"No\"],\n",
        "    \"InternetService\": [\"DSL\"],\n",
        "    \"OnlineSecurity\": [\"Yes\"],\n",
        "    \"OnlineBackup\": [\"Yes\"],\n",
        "    \"DeviceProtection\": [\"No\"],\n",
        "    \"TechSupport\": [\"No\"],\n",
        "    \"StreamingTV\": [\"No\"],\n",
        "    \"StreamingMovies\": [\"No\"],\n",
        "    \"Contract\": [\"Month-to-month\"],\n",
        "    \"PaperlessBilling\": [\"Yes\"],\n",
        "    \"PaymentMethod\": [\"Mailed check\"],\n",
        "    \"MonthlyCharges\": [53.85],\n",
        "    \"TotalCharges\": [108.15],\n",
        "}\n",
        "\n",
        "make_prediction(single_case)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "avTMW_M4cDmr",
        "outputId": "2fdbdd15-7ae7-4b2e-c138-319ef6047f4f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 16ms/step\n",
            "Probabilidad que abandone: 26.36 %\n",
            "Churn:  0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wl7v6oyFkREF"
      },
      "source": [
        "### 8) Conclusiones\n",
        "\n",
        "- Aprender sobre los distintos objetos y métodos que nos ofrece Tensorflow + Keras.\n",
        "\n",
        "- Realizar el proceso completo de entrenamiento de un modelo con Tensorflow + Keras.\n",
        "\n",
        "- Aprender tips sobre implementación con el uso de la GPU.\n",
        "\n",
        "<br>\n",
        "<br>\n",
        "<br>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0sQ95LlzkUZN"
      },
      "source": [
        "---\n",
        "\n",
        "<br>\n",
        "<br>\n",
        "\n",
        "\n",
        "<img src=\"https://static.platzi.com/media/avatars/platziteam_8cfe6fc7-1246-4c9a-9f5d-d10d467443ee.png\" width=\"100px\">\n",
        "\n",
        "[Platzi](https://platzi.com/) 🚀\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "fxgR3AqoTxQP",
        "HX8Q_QXsTts3",
        "BYa0Tjnv74mE",
        "z5CReMaiYSDt",
        "NdRZS4ZactJU",
        "BkY3Xe9fDhN3"
      ]
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}