Churn_Guard.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vl90zXuu8S27",
        "outputId": "68e40107-c163-4228-e76e-d33cbb4bfb33"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "          CustomerID            Age  Subscription_Length_Months  \\\n",
            "count  100000.000000  100000.000000               100000.000000   \n",
            "mean    50000.500000      44.027020                   12.490100   \n",
            "std     28867.657797      15.280283                    6.926461   \n",
            "min         1.000000      18.000000                    1.000000   \n",
            "25%     25000.750000      31.000000                    6.000000   \n",
            "50%     50000.500000      44.000000                   12.000000   \n",
            "75%     75000.250000      57.000000                   19.000000   \n",
            "max    100000.000000      70.000000                   24.000000   \n",
            "\n",
            "        Monthly_Bill  Total_Usage_GB          Churn  \n",
            "count  100000.000000   100000.000000  100000.000000  \n",
            "mean       65.053197      274.393650       0.497790  \n",
            "std        20.230696      130.463063       0.499998  \n",
            "min        30.000000       50.000000       0.000000  \n",
            "25%        47.540000      161.000000       0.000000  \n",
            "50%        65.010000      274.000000       0.000000  \n",
            "75%        82.640000      387.000000       1.000000  \n",
            "max       100.000000      500.000000       1.000000  \n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 100000 entries, 0 to 99999\n",
            "Data columns (total 9 columns):\n",
            " #   Column                      Non-Null Count   Dtype  \n",
            "---  ------                      --------------   -----  \n",
            " 0   CustomerID                  100000 non-null  int64  \n",
            " 1   Name                        100000 non-null  object \n",
            " 2   Age                         100000 non-null  int64  \n",
            " 3   Gender                      100000 non-null  object \n",
            " 4   Location                    100000 non-null  object \n",
            " 5   Subscription_Length_Months  100000 non-null  int64  \n",
            " 6   Monthly_Bill                100000 non-null  float64\n",
            " 7   Total_Usage_GB              100000 non-null  int64  \n",
            " 8   Churn                       100000 non-null  int64  \n",
            "dtypes: float64(1), int64(5), object(3)\n",
            "memory usage: 6.9+ MB\n",
            "None\n",
            "CustomerID                    0\n",
            "Name                          0\n",
            "Age                           0\n",
            "Gender                        0\n",
            "Location                      0\n",
            "Subscription_Length_Months    0\n",
            "Monthly_Bill                  0\n",
            "Total_Usage_GB                0\n",
            "Churn                         0\n",
            "dtype: int64\n"
          ]
        }
      ],
      "source": [
        "import pandas as pd\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import LabelEncoder, StandardScaler\n",
        "from scipy import stats\n",
        "\n",
        "# Step 1: Load the dataset and perform initial data exploration\n",
        "data = pd.read_excel('customer_churn_large_dataset.xlsx')\n",
        "\n",
        "# Check basic statistics\n",
        "print(data.describe())\n",
        "\n",
        "# Check column names and data types\n",
        "print(data.info())\n",
        "\n",
        "# Check missing values\n",
        "print(data.isnull().sum())\n",
        "\n",
        "# Step 2: Handling missing data\n",
        "# For missing data in 'Gender' and 'Location', fill with the most common value (mode).\n",
        "data['Gender'].fillna(data['Gender'].mode()[0], inplace=True)\n",
        "data['Location'].fillna(data['Location'].mode()[0], inplace=True)\n",
        "\n",
        "# Step 3: Handle outliers\n",
        "# Identify and handle outliers using the IQR method for numerical columns\n",
        "numerical_cols = ['Age', 'Subscription_Length_Months', 'Monthly_Bill', 'Total_Usage_GB']\n",
        "for col in numerical_cols:\n",
        "    Q1 = data[col].quantile(0.25)\n",
        "    Q3 = data[col].quantile(0.75)\n",
        "    IQR = Q3 - Q1\n",
        "    lower_bound = Q1 - 1.5 * IQR\n",
        "    upper_bound = Q3 + 1.5 * IQR\n",
        "    data = data[(data[col] >= lower_bound) & (data[col] <= upper_bound)]\n",
        "\n",
        "# Step 4: Prepare the data for machine learning\n",
        "# Encode categorical variables (Gender and Location) using one-hot encoding\n",
        "data = pd.get_dummies(data, columns=['Gender', 'Location'], drop_first=True)\n",
        "\n",
        "# Split the data into features (X) and target (y) for machine learning\n",
        "X = data.drop(columns=['CustomerID', 'Name', 'Churn'])\n",
        "y = data['Churn']\n",
        "\n",
        "# Split the data into training and testing sets (e.g., 80% train, 20% test)\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 4: Feature Engineering\n",
        "# Generate a new feature 'Cost_Per_GB' by dividing 'Monthly_Bill' by 'Total_Usage_GB'\n",
        "data['Cost_Per_GB'] = data['Monthly_Bill'] / data['Total_Usage_GB']\n",
        "\n",
        "# Drop the original 'Monthly_Bill' and 'Total_Usage_GB' columns\n",
        "data.drop(columns=['Monthly_Bill', 'Total_Usage_GB'], inplace=True)\n",
        "\n",
        "# Step 5: Feature Scaling (Normalization)\n",
        "# Standardize the numerical features using z-score scaling\n",
        "numerical_cols = ['Age', 'Subscription_Length_Months', 'Cost_Per_GB']\n",
        "scaler = StandardScaler()\n",
        "data[numerical_cols] = scaler.fit_transform(data[numerical_cols])\n",
        "\n",
        "# Step 6: Prepare the data for machine learning (again, after feature engineering and scaling)\n",
        "X = data.drop(columns=['CustomerID', 'Name', 'Churn'])\n",
        "y = data['Churn']\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
        "\n",
        "# Now, you have the dataset with feature engineering and scaling applied.\n",
        "# You can proceed to build and train your machine learning model using X_train and y_train."
      ],
      "metadata": {
        "id": "t6iYausV88W3"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report, confusion_matrix\n"
      ],
      "metadata": {
        "id": "BvWQKqmC9tl6"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 5: Model Building (Random Forest Classifier)\n",
        "rf_classifier = RandomForestClassifier(random_state=42)\n",
        "rf_classifier.fit(X_train, y_train)\n",
        "\n",
        "# Step 6: Model Validation and Evaluation\n",
        "y_pred = rf_classifier.predict(X_test)\n",
        "\n",
        "# Calculate and print accuracy\n",
        "accuracy = accuracy_score(y_test, y_pred)\n",
        "print(f'Accuracy: {accuracy:.2f}')\n",
        "\n",
        "# Calculate and print precision\n",
        "precision = precision_score(y_test, y_pred)\n",
        "print(f'Precision: {precision:.2f}')\n",
        "\n",
        "# Calculate and print recall\n",
        "recall = recall_score(y_test, y_pred)\n",
        "print(f'Recall: {recall:.2f}')\n",
        "\n",
        "# Calculate and print F1-score\n",
        "f1 = f1_score(y_test, y_pred)\n",
        "print(f'F1-score: {f1:.2f}')\n",
        "\n",
        "# Generate a classification report and confusion matrix\n",
        "print(classification_report(y_test, y_pred))\n",
        "print(confusion_matrix(y_test, y_pred))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K5wc3kjH-ZBu",
        "outputId": "e1c96181-43ce-4325-801e-41c85e9a38b7"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 0.50\n",
            "Precision: 0.50\n",
            "Recall: 0.49\n",
            "F1-score: 0.50\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.51      0.51      0.51     10079\n",
            "           1       0.50      0.49      0.50      9921\n",
            "\n",
            "    accuracy                           0.50     20000\n",
            "   macro avg       0.50      0.50      0.50     20000\n",
            "weighted avg       0.50      0.50      0.50     20000\n",
            "\n",
            "[[5176 4903]\n",
            " [5029 4892]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from sklearn.metrics import classification_report, confusion_matrix\n",
        "\n",
        "# Generate a classification report\n",
        "class_report = classification_report(y_test, y_pred, target_names=['Not Churn', 'Churn'], output_dict=True)\n",
        "\n",
        "# Create a heatmap for the confusion matrix\n",
        "conf_matrix = confusion_matrix(y_test, y_pred)\n",
        "plt.figure(figsize=(8, 6))\n",
        "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=['Not Churn', 'Churn'], yticklabels=['Not Churn', 'Churn'])\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('Actual')\n",
        "plt.title('Confusion Matrix')\n",
        "plt.show()\n",
        "\n",
        "# Display the classification report as a heatmap\n",
        "class_report_df = pd.DataFrame(class_report).transpose()\n",
        "plt.figure(figsize=(8, 6))\n",
        "sns.heatmap(class_report_df.iloc[:-1, :-3], annot=True, cmap='YlGnBu', cbar=False)\n",
        "plt.xlabel('Metrics')\n",
        "plt.ylabel('Classes')\n",
        "plt.title('Classification Report')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "MrnCekNG-iOJ",
        "outputId": "bf0cbc93-46a0-4867-a301-34635ff9cb82"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqsAAAIjCAYAAAAk+FJEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABHhklEQVR4nO3dd3RVVcL+8eemXUJCQgkQwFATqoAUHQGpKiBFkI6FagNipAwIOKDoCIIKCDgCKoKodHAEFFGaQ5EWQu8lgCIJJQmBkITk/P7wx329BjSEJPsg389aWcu7z7nnPjfzrnc97Oyzj8OyLEsAAACADXmYDgAAAADcDGUVAAAAtkVZBQAAgG1RVgEAAGBblFUAAADYFmUVAAAAtkVZBQAAgG1RVgEAAGBblFUAAADYFmUVgC2ULl1aPXr0MPb5PXr0UOnSpd3GEhMT9eyzzyo4OFgOh0P9+/fXiRMn5HA4NHPmzFzP2KhRIzVq1CjXPxcATKKsAshRR48e1QsvvKCyZcsqT548CggIUL169fT+++8rKSnJdLw/NXr0aM2cOVN9+vTR7Nmz9cwzz+T4Z+7bt0+vv/66Tpw4keOflVlr166Vw+Fw/Xh6eqpIkSLq0KGD9u/fbzpepnz55ZeaOHGi6RgAssBhWZZlOgSAv6fly5erY8eOcjqd6tatm+69916lpKRo/fr1WrRokXr06KHp06dL+m1mtVGjRkZmLCUpNTVV6enpcjqdrrEHH3xQXl5eWr9+vWvMsiwlJyfL29tbnp6e2Z5j4cKF6tixo9asWZNhFjUlJUWS5OPjk+2f+2fWrl2rxo0bKyIiQvfff79SU1O1a9cuTZ06VX5+ftqzZ4+Cg4NzNdOtatWqlfbs2WOrfwQAyBwv0wEA/D0dP35cXbp0UalSpbR69WoVK1bMdaxfv346cuSIli9fbjChO29v7wxjMTExqly5stuYw+FQnjx5ciuWm9wuqX9Uv359dejQwfW6QoUK6tOnjz777DMNGTLEYLKbu3z5svz8/EzHAHAbWAYAIEeMGzdOiYmJ+uSTT9yK6nWhoaF6+eWXb/r+Cxcu6J///KeqVq0qf39/BQQE6LHHHtPOnTsznDt58mRVqVJFefPmVYECBVS7dm19+eWXruOXLl1S//79Vbp0aTmdThUpUkSPPvqoIiMjXef8fs3q9T97Hz9+XMuXL3f9+fvEiRM3XbN64MABderUSYULF5avr68qVKigV1991XU8Ojpaffv2VYUKFeTr66tChQqpY8eObjN9M2fOVMeOHSVJjRs3dn3u2rVrJd14zWpMTIx69+6tokWLKk+ePKpevbpmzZrlds71zO+++66mT5+ucuXKyel06v7779fWrVtv+r/BX6lfv76k35Z6/N7PP/+sXr16qWjRonI6napSpYpmzJjhds713/G8efM0fPhwBQcHy8/PT48//rhOnTqV4bMWLFigWrVqydfXV0FBQXr66af1888/u53To0cP+fv76+jRo2rRooXy5cunp556So0aNdLy5csVHR3t+p3+cX0yAPtiZhVAjli6dKnKli2runXrZun9x44d01dffaWOHTuqTJkyOnv2rKZNm6aGDRtq3759Kl68uCTpo48+UkREhDp06KCXX35ZV69e1a5du7R582Y9+eSTkqQXX3xRCxcuVHh4uCpXrqzz589r/fr12r9/v2rWrJnhsytVqqTZs2drwIABuueeezRo0CBJUuHChRUbG5vh/F27dql+/fry9vbW888/r9KlS+vo0aNaunSp3nrrLUnS1q1btXHjRnXp0kX33HOPTpw4oQ8//FCNGjXSvn37lDdvXjVo0EARERGaNGmShg8frkqVKrny3EhSUpIaNWqkI0eOKDw8XGXKlNGCBQvUo0cPxcXFZfjHwJdffqlLly7phRdekMPh0Lhx49SuXTsdO3bshjPLf+V60S5QoIBr7OzZs3rwwQflcDgUHh6uwoUL69tvv1Xv3r2VkJCg/v37u13jrbfeksPh0CuvvKKYmBhNnDhRjzzyiKKiouTr6yvptxLfs2dP3X///RozZozOnj2r999/Xxs2bNCOHTuUP39+1/WuXbumZs2a6aGHHtK7776rvHnzKjg4WPHx8Tp9+rQmTJggSfL397/l7wvAEAsAsll8fLwlyWrTpk2m31OqVCmre/furtdXr1610tLS3M45fvy45XQ6rTfeeMM11qZNG6tKlSp/eu3AwECrX79+f3pO9+7drVKlSmXI1LJlywwZJFmffvqpa6xBgwZWvnz5rOjoaLdz09PTXf995cqVDJ+5adMmS5L12WefucYWLFhgSbLWrFmT4fyGDRtaDRs2dL2eOHGiJcn6/PPPXWMpKSlWnTp1LH9/fyshIcEtc6FChawLFy64zv3vf/9rSbKWLl2a8RfyO2vWrLEkWTNmzLBiY2OtX375xVqxYoUVGhpqORwOa8uWLa5ze/fubRUrVsw6d+6c2zW6dOliBQYGun4P169ZokQJV07Lsqz58+dbkqz333/f9X2KFCli3XvvvVZSUpLrvGXLllmSrJEjR7rGunfvbkmyhg4dmuE7tGzZMsP/vgDuDCwDAJDtEhISJEn58uXL8jWcTqc8PH77f1FpaWk6f/68/P39VaFCBbc/3+fPn1+nT5/+0z9n58+fX5s3b9Yvv/yS5Tw3Exsbqx9//FG9evVSyZIl3Y45HA7Xf1+fJZR+u5nr/PnzCg0NVf78+d2+z6345ptvFBwcrK5du7rGvL29FRERocTERK1bt87t/M6dO7vNgl7/M/6xY8cy9Xm9evVS4cKFVbx4cTVv3lzx8fGaPXu27r//fkm/3Xy2aNEitW7dWpZl6dy5c66fZs2aKT4+PsN37datm9v/nXTo0EHFihXTN998I0natm2bYmJi1LdvX7e1wi1btlTFihVvuO65T58+mfo+AO4MlFUA2S4gIEDSb2tFsyo9PV0TJkxQWFiYnE6ngoKCVLhwYe3atUvx8fGu81555RX5+/vrgQceUFhYmPr166cNGza4XWvcuHHas2ePQkJC9MADD+j111/PdEH7K9evc++99/7peUlJSRo5cqRCQkLcvk9cXJzb97kV0dHRCgsLc5X6664vG4iOjnYb/2OZvl5cL168mKnPGzlypL7//nstWbJE3bp1U3x8vNtnx8bGKi4uTtOnT1fhwoXdfnr27CnptzW2vxcWFub22uFwKDQ01LXE4Pp3qFChQoY8FStWzPAdvby8dM8992Tq+wC4M7BmFUC2CwgIUPHixbVnz54sX2P06NEaMWKEevXqpTfffFMFCxaUh4eH+vfvr/T0dNd5lSpV0sGDB7Vs2TKtWLFCixYt0n/+8x+NHDlSo0aNkiR16tRJ9evX15IlS7Ry5Uq98847Gjt2rBYvXqzHHnvstr9vZrz00kv69NNP1b9/f9WpU0eBgYFyOBzq0qWL2/fJSTfbasvK5A6GVatW1SOPPCJJatu2ra5cuaLnnntODz30kEJCQlzf4+mnn1b37t1veI1q1aplIXnm/X5GHsDfA2UVQI5o1aqVpk+frk2bNqlOnTq3/P6FCxeqcePG+uSTT9zG4+LiFBQU5Dbm5+enzp07q3PnzkpJSVG7du301ltvadiwYa4/HRcrVkx9+/ZV3759FRMTo5o1a+qtt9667bJatmxZSfrLYr5w4UJ1795d7733nmvs6tWriouLczvv90sH/kqpUqW0a9cupaenuxW0AwcOuI7npLfffltLlizRW2+9palTp6pw4cLKly+f0tLSXKX2rxw+fNjttWVZOnLkiKvUXv8OBw8eVJMmTdzOPXjwYKa/4638XgHYC//8BJAjhgwZIj8/Pz377LM6e/ZshuNHjx7V+++/f9P3e3p6ZpjxW7BgQYbtis6fP+/22sfHR5UrV5ZlWUpNTVVaWlqGP7MXKVJExYsXV3Jy8q1+rQwKFy6sBg0aaMaMGTp58qTbsd/nv9H3mTx5stLS0tzGru8J+scSeyMtWrTQr7/+qnnz5rnGrl27psmTJ8vf318NGza81a9zS8qVK6f27dtr5syZ+vXXX+Xp6an27dtr0aJFNyzvN9pJ4bPPPnNbLrJw4UKdOXPG9Y+I2rVrq0iRIpo6darb/17ffvut9u/fr5YtW2Yqq5+fX5aXWwAwi5lVADmiXLly+vLLL9W5c2dVqlTJ7QlWGzdudG2xdDOtWrXSG2+8oZ49e6pu3bravXu3vvjiC9dM5nVNmzZVcHCw6tWrp6JFi2r//v2aMmWKWrZsqXz58ikuLk733HOPOnTooOrVq8vf318//PCDtm7d6jbLeTsmTZqkhx56SDVr1tTzzz+vMmXK6MSJE1q+fLmioqJc32f27NkKDAxU5cqVtWnTJv3www8qVKiQ27Xuu+8+eXp6auzYsYqPj5fT6VSTJk1UpEiRDJ/7/PPPa9q0aerRo4e2b9+u0qVLa+HChdqwYYMmTpx4Wze4ZdbgwYM1f/58TZw4UW+//bbefvttrVmzRv/4xz/03HPPqXLlyrpw4YIiIyP1ww8/6MKFC27vL1iwoB566CH17NlTZ8+e1cSJExUaGqrnnntO0m83jI0dO1Y9e/ZUw4YN1bVrV9fWVaVLl9aAAQMylbNWrVqaN2+eBg4cqPvvv1/+/v5q3bp1tv8+AOQAcxsRALgbHDp0yHruuees0qVLWz4+Pla+fPmsevXqWZMnT7auXr3qOu9GW1cNGjTIKlasmOXr62vVq1fP2rRpU4btm6ZNm2Y1aNDAKlSokOV0Oq1y5cpZgwcPtuLj4y3Lsqzk5GRr8ODBVvXq1a18+fJZfn5+VvXq1a3//Oc/bjlvZ+sqy7KsPXv2WE888YSVP39+K0+ePFaFChWsESNGuI5fvHjR6tmzpxUUFGT5+/tbzZo1sw4cOJDhe1uWZX300UdW2bJlLU9PT7dtrP743S3Lss6ePeu6ro+Pj1W1atUM2a5nfuedd6w/kmS99tprGcZ/7/o2UwsWLLjh8UaNGlkBAQFWXFycK1O/fv2skJAQy9vb2woODrYefvhha/r06RmuOWfOHGvYsGFWkSJFLF9fX6tly5YZtgCzLMuaN2+eVaNGDcvpdFoFCxa0nnrqKev06dNu53Tv3t3y8/O7YcbExETrySeftPLnz29JYhsr4A7isKxMrqwHACCbrF27Vo0bN9aCBQvcHuEKAH/EmlUAAADYFmUVAAAAtkVZBQAAgG2xZhUAAAC2xcwqAAAAbIuyCgAAANuirAIAAMC2/pZPsPIt2dV0BAAAAPyJpJNzMnUeM6sAAACwLcoqAAAAbIuyCgAAANuirAIAAMC2KKsAAACwLcoqAAAAbIuyCgAAANuirAIAAMC2KKsAAACwLcoqAAAAbIuyCgAAANuirAIAAMC2KKsAAACwLcoqAAAAbIuyCgAAANuirAIAAMC2KKsAAACwLcoqAAAAbIuyCgAAANuirAIAAMC2KKsAAACwLcoqAAAAbIuyCgAAANvyMh3gupSUFMXExCg9Pd1tvGTJkoYSAQAAwDTjZfXw4cPq1auXNm7c6DZuWZYcDofS0tIMJQMAAIBpxstqjx495OXlpWXLlqlYsWJyOBymIwEAAMAmjJfVqKgobd++XRUrVjQdBQAAADZj/AarypUr69y5c6ZjAAAAwIaMl9WxY8dqyJAhWrt2rc6fP6+EhAS3HwAAANy9HJZlWSYDeHj81pf/uFb1dm6w8i3ZNVuyAQAAIGcknZyTqfOMr1lds2aN6QgAAACwKaNlNTU1VW+88YamTp2qsLAwk1EAAABgQ0bXrHp7e2vXrl0mIwAAAMDGjN9g9fTTT+uTTz4xHQMAAAA2ZHzN6rVr1zRjxgz98MMPqlWrlvz8/NyOjx8/3lAyAAAAmGa8rO7Zs0c1a9aUJB06dMjtGE+zAgAAuLsZL6vsBgAAAICbMb5mFQAAALgZ4zOrjRs3/tM/969evToX0wAAAMBOjJfV++67z+11amqqoqKitGfPHnXv3t1MKAAAANiC8bI6YcKEG46//vrrSkxMzOU0AAAAsBPbrll9+umnNWPGDNMxAAAAYJBty+qmTZuUJ08e0zEAAABgkPFlAO3atXN7bVmWzpw5o23btmnEiBGGUgEAAMAOjJfVwMBAt9ceHh6qUKGC3njjDTVt2tRQKgAAANiBw7Isy3SI7OZbsqvpCAAAAPgTSSfnZOo84zOr16WkpCgmJkbp6elu4yVLljSUCAAAAKYZL6uHDh1S7969tXHjRrdxy7LkcDiUlpZmKBkAAABMM15We/bsKS8vLy1btkzFihX706dZAQAA4O5ivKxGRUVp+/btqlixoukoAAAAsBnj+6xWrlxZ586dMx0DAAAANmSkrCYkJLh+xo4dqyFDhmjt2rU6f/6827GEhAQT8QAgx73Q7VEd2DBJFw/N0o//fVO1q5e76blPd2igpJNz3H4uHprldk6b5vdr6efDdHrndCWdnKNqlUvl9FcAgFxhZBlA/vz53damWpalhx9+2O0cbrAC8HfVofWDGjviGb00/BNtjTqi8N6P6evPh6p6o0GKPX/jf6THJ1xR9cYDXa//uOlg3rxObdx6UIuW/aQPxz2fk/EBIFcZKatr1qwx8bEAYAsRz7bUp3NWa/aCdZKkl4Z9osea1FD3zo307n++vuF7LMvS2dj4m15zzuL1kqSS9wRlf2AAMMhIWW3YsKGJjwUA47y9PVWjahm988F/XWOWZWn1+j16oGbYTd/n75dHBzdOkoeHh3bsOa7Xxs3T/kOncyMyABhl7Aarw4cPq2vXrjdclxofH68nn3xSx44d+8vrJCcnZ1jnalksHQBgT0EFA+Tl5amYc+6zpDHn4hVcOP8N33P42Bm9MHiaOj77nnq+/IE8PBxas3iUSgQXzIXEAGCWsbL6zjvvKCQkRAEBARmOBQYGKiQkRO+8885fXmfMmDEKDAx0+7mWsC8nIgOAEZsjD+vLRf/Trn3RWr95v7o8P0HnLiSo91MP//WbAeAOZ6ysrlu3Th07drzp8U6dOmn16tV/eZ1hw4YpPj7e7ccroHJ2RgWAbHPuQoKuXUtTkaBAt/EiQYH6NTYuU9e4di1NO/eeULnSwTmQEADsxVhZPXnypIoUKXLT40FBQTp16tRfXsfpdCogIMDtx+HwzM6oAJBtUlPTtGP3cTWud69rzOFwqHG9KtoSeThT1/DwcKhKhRD9GnMxp2ICgG0Ye4JVYGCgjh49qlKlbrwX4JEjR264RAAA7nSTPl6uj97ro+27j2nb/9+6Km9epz6b/9vuAB9P6KNffr2okWPnSpKGvdxOWyIP62j0WeUPyKsBL7RWyXsK69O5/7ezSoFAP4WUCFKxogUkSeXLFZMknY2N+9NdBADA7oyV1QYNGmjy5Mlq0qTJDY9PmjRJ9evXz+VUAJDzFi79SUEFAzRyYAcVLZxfu/ZFq80zb7tuugopHqT09P/bSLVAoJ/+M/Y5FS2cXxfjL/82M/vEazpw+GfXOS0fraWPxvdxvZ79wcuSpH9PWKi3JizKpW8GANnPYVl/3Fo6d+zYsUN16tRRq1atNGTIEFWoUEGSdODAAY0bN07Lly/Xxo0bVbNmzVu+tm/JrtkdFwAAANko6eScTJ1nbGa1Ro0aWrhwoXr16qUlS5a4HStUqJDmz5+fpaIKAACAvw9jM6vXJSUlacWKFTpy5Igsy1L58uXVtGlT5c2bN8vXZGYVAADA3jI7s2q8rOYEyioAAIC9ZbasGtu6CgAAAPgrlFUAAADYFmUVAAAAtkVZBQAAgG0ZL6uenp6KiYnJMH7+/Hl5evLYVAAAgLuZ8bJ6s80IkpOT5ePjk8tpAAAAYCfGHgowadIkSZLD4dDHH38sf39/17G0tDT9+OOPqlixoql4AAAAsAFjZXXChAmSfptZnTp1qtuf/H18fFS6dGlNnTrVVDwAAADYgLGyevz4cUlS48aNtXjxYhUoUMBUFAAAANiUsbJ63Zo1a1z/fX39qsPhMBUHAAAANmL8BitJ+uyzz1S1alX5+vrK19dX1apV0+zZs03HAgAAgGHGZ1bHjx+vESNGKDw8XPXq1ZMkrV+/Xi+++KLOnTunAQMGGE4IAAAAUxzWzfaOyiVlypTRqFGj1K1bN7fxWbNm6fXXX3etbb0VviW7Zlc8AAAA5ICkk3MydZ7xZQBnzpxR3bp1M4zXrVtXZ86cMZAIAAAAdmG8rIaGhmr+/PkZxufNm6ewsDADiQAAAGAXxtesjho1Sp07d9aPP/7oWrO6YcMGrVq16oYlFgAAAHcP4zOr7du31+bNmxUUFKSvvvpKX331lYKCgrRlyxY98cQTpuMBAADAIOM3WOUEbrACAACwtzvmBisAAADgZoytWfXw8PjLJ1U5HA5du3YtlxIBAADAboyV1SVLltz02KZNmzRp0iSlp6fnYiIAAADYjbGy2qZNmwxjBw8e1NChQ7V06VI99dRTeuONNwwkAwAAgF3YYs3qL7/8oueee05Vq1bVtWvXFBUVpVmzZqlUqVKmowEAAMAgo2U1Pj5er7zyikJDQ7V3716tWrVKS5cu1b333msyFgAAAGzC2DKAcePGaezYsQoODtacOXNuuCwAAAAAdzdj+6x6eHjI19dXjzzyiDw9PW963uLFi2/52uyzCgAAYG+Z3WfV2Mxqt27d/nLrKgAAANzdeIIVAAAAch1PsAIAAMAdj7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsi7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsi7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsi7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsi7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsy2FZlmU6RPY7ZDoAAAAA/lT5TJ3FzCoAAABsi7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsi7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsi7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsi7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsi7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsi7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsi7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsi7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsi7IKAAAA26KsAgAAwLYoqwAAALAtyioAAABsi7IKAAAA26KsAgAAwLa8TAeQpLi4OG3ZskUxMTFKT093O9atWzdDqQAAAGCaw7Isy2SApUuX6qmnnlJiYqICAgLkcDhcxxwOhy5cuJCFqx7KvoAAAADIAeUzdZbxslq+fHm1aNFCo0ePVt68ebPpqpRVAAAAe7tDyqqfn592796tsmXLZuNVKasAAAD2lrmyavwGq2bNmmnbtm2mYwAAAMCGjN9g1bJlSw0ePFj79u1T1apV5e3t7Xb88ccfN5QMAAAAphlfBuDhcfPJXYfDobS0tCxclWUAAAAA9pa5ZQDGZ1b/uFUVAAAAcJ3RNaupqany8vLSnj17TMYAAACATRktq97e3ipZsmQW/9QPAACAvzvjuwG8+uqrGj58eBY3/wcAAMDfmfEbrGrUqKEjR44oNTVVpUqVkp+fn9vxyMjILFyVG6wAAADs7Q65wapt27amIwAAAMCmjM+s5gxmVgHcWb74Yrk++WSxYmMvqmLFMhox4gVVq3bjWYfFi3/QsGHvu435+Hhr9+7FuREVALLJHTKzCgB3u2+++Z/GjPlYo0b1U/Xq5TVr1tfq3XukVqyYqkKF8t/wPf7+ebVixVTXa4cjl8ICQC4zfoOVh4eHPD09b/oDAH93n376lTp1aqb27R9RaGhJjRrVV3nyOLVo0fc3fY/D4VDhwgVcP0FBBXIxMQDkHuMzq0uWLHF7nZqaqh07dmjWrFkaNWqUoVQAkDtSUlK1d+8RvfBCB9eYh4eH6ta9Tzt2HLzp+65cSVLjxr2Unm6pcuVyGjjwGYWFlcqNyACQq4yX1TZt2mQY69Chg6pUqaJ58+apd+/ef/r+5ORkJScnu405nSlyOn2yNScA5ISLFxOUlpauQoXcZ0YLFcqvY8dO3/A9Zcrco9GjX1aFCqV16dJlzZixRF26DNHy5R8oODgoN2IDQK4xvgzgZh588EGtWrXqL88bM2aMAgMD3X7GjJmWCwkBwIwaNSqqbdsmqlSprB54oKomTx6uggUDNXfuCtPRACDbGZ9ZvZGkpCRNmjRJJUqU+Mtzhw0bpoEDB7qNOZ0ncyoaAGSrAgUC5OnpofPnL7qNnz8fl+l1qN7eXqpUqaxOnjyTExEBwCjjZbVAgQJy/O42VsuydOnSJeXNm1eff/75X77f6XTK6XT+YZQlAADuDD4+3qpSJVSbNu3SI4/UkSSlp6dr06adevrplpm6Rlpamg4dOqGGDWvnZFQAMMJ4WZ04caLbaw8PDxUuXFj/+Mc/VKAAd7cC+Pvr2bOtXnllgu69N1TVqpXXrFn/VVLSVbVr94gkaciQ8SpatJAGDeouSZoyZY7uu6+CSpUqroSERH3yyRL98kusOnZsavJrAECOMF5Wu3fvbjoCABjVokV9XbgQr0mTvlBs7EVVqlRWH388yrUM4MyZWHl4/N9foBISEjVixBTFxl5UYKC/qlQJ1dy54xQaWtLUVwCAHGOLJ1jFxcVpy5YtiomJUXp6utuxbt26ZeGKPMEKAADA3jL3BCvjZXXp0qV66qmnlJiYqICAALf1qw6HQxcuXMjCVSmrAAAA9naHlNXy5curRYsWGj16tPLmzZtNV6WsAgAA2NsdUlb9/Py0e/dulS1bNhuvSlkFAACwt8yVVeMPBWjWrJm2bdtmOgYAAABsyMhuAF9//bXrv1u2bKnBgwdr3759qlq1qry9vd3Offzxx3M7HgAAAGzCyDIAD4/MTeg6HA6lpaVl4RNYBgAAAGBvmVsGYGRm9Y/bUwEAAAA3YmzN6urVq1W5cmUlJCRkOBYfH68qVarof//7n4FkAAAAsAtjZXXixIl67rnnFBAQkOFYYGCgXnjhBY0fP95AMgAAANiFsbK6c+dONW/e/KbHmzZtqu3bt+diIgAAANiNsbJ69uzZDHf+/56Xl5diY2NzMREAAADsxlhZLVGihPbs2XPT47t27VKxYsVyMREAAADsxlhZbdGihUaMGKGrV69mOJaUlKTXXntNrVq1MpAMAAAAdmHscatnz55VzZo15enpqfDwcFWoUEGSdODAAX3wwQdKS0tTZGSkihYtmoWrs88qAACAvWVun1VjZVWSoqOj1adPH3333Xe6HsPhcKhZs2b64IMPVKZMmSxembIKAABgb3dAWb3u4sWLOnLkiCzLUlhYmAoUKHCbV6SsAgAA2NsdVFazH2UVAADA3jJXVo3dYAUAAAD8FcoqAAAAbIuyCgAAANuirAIAAMC2KKsAAACwLcoqAAAAbIuyCgAAANuirAIAAMC2KKsAAACwLcoqAAAAbIuyCgAAANvKUllNSkrSlStXXK+jo6M1ceJErVy5MtuCAQAAAFkqq23atNFnn30mSYqLi9M//vEPvffee2rTpo0+/PDDbA0IAACAu1eWympkZKTq168vSVq4cKGKFi2q6OhoffbZZ5o0aVK2BgQAAMDdK0tl9cqVK8qXL58kaeXKlWrXrp08PDz04IMPKjo6OlsDAgAA4O6VpbIaGhqqr776SqdOndJ3332npk2bSpJiYmIUEBCQrQEBAABw98pSWR05cqT++c9/qnTp0nrggQdUp04dSb/NstaoUSNbAwIAAODu5bAsy8rKG3/99VedOXNG1atXl4fHb513y5YtCggIUMWKFbM15K07ZPjzAQAA8OfKZ+qsLJdVSTpy5IiOHj2qBg0ayNfXV5ZlyeFwZPVy2YiyCgAAYG+ZK6tZWgZw/vx5PfzwwypfvrxatGihM2fOSJJ69+6tQYMGZeWSAAAAQAZZKqsDBgyQt7e3Tp48qbx587rGO3furBUrVmRbOAAAANzdvLLyppUrV+q7777TPffc4zYeFhbG1lUAAADINlmaWb18+bLbjOp1Fy5ckNPpvO1QAAAAgJTFslq/fn3X41YlyeFwKD09XePGjVPjxo2zLRwAAADubllaBjBu3Dg9/PDD2rZtm1JSUjRkyBDt3btXFy5c0IYNG7I7IwAAAO5SWd66Kj4+XlOmTNHOnTuVmJiomjVrql+/fipWrFh2Z8wCtq4CAACwt1zYZ9W+KKsAAAD2loP7rK5YsULr1693vf7ggw9033336cknn9TFixezckkAAAAggyyV1cGDByshIUGStHv3bg0cOFAtWrTQ8ePHNXDgwGwNCAAAgLtXlm6wOn78uCpXrixJWrRokVq3bq3Ro0crMjJSLVq0yNaAAAAAuHtlaWbVx8dHV65ckST98MMPatq0qSSpYMGCrhlXAAAA4HZlaWb1oYce0sCBA1WvXj1t2bJF8+bNkyQdOnQow1OtAAAAgKzK0szqlClT5OXlpYULF+rDDz9UiRIlJEnffvutmjdvnq0BAQAAcPdi6yoAAAAYkINbV0VGRmr37t2u1//973/Vtm1bDR8+XCkpKVm5JAAAAJBBlmZW77//fg0dOlTt27fXsWPHVKVKFT3xxBPaunWrWrZsqYkTJ+ZA1MxruIxHvgIAANjZulb1MnVelmZWDx06pPvuu0+StGDBAjVo0EBffvmlZs6cqUWLFmXlkgAAAEAGWSqrlmUpPT1d0m9bV13fWzUkJETnzp3LvnQAAAC4q2WprNauXVv//ve/NXv2bK1bt04tW7aU9NvDAooWLZqtAQEAAHD3ylJZnThxoiIjIxUeHq5XX31VoaGhkqSFCxeqbt262RoQAAAAd69s3brq6tWr8vT0lLe3d3ZdMku4wQoAAMDeMnuDVZaeYHUzefLkyc7LAQAA4C6XpbKalpamCRMmaP78+Tp58mSGvVUvXLiQLeEAAABwd8vSmtVRo0Zp/Pjx6ty5s+Lj4zVw4EC1a9dOHh4eev3117M5IgAAAO5WWSqrX3zxhT766CMNGjRIXl5e6tq1qz7++GONHDlSP/30U3ZnBAAAwF0qS2X1119/VdWqVSVJ/v7+io+PlyS1atVKy5cvz750AAAAuKtlqazec889OnPmjCSpXLlyWrlypSRp69atcjqd2ZcOAAAAd7UsldUnnnhCq1atkiS99NJLGjFihMLCwtStWzf16tUrWwMCAADg7pUt+6xu2rRJmzZtUlhYmFq3bp0duW4L+6wCAADYW67us1qnTh3VqVMnOy4FAAAAuGS6rH799deZvujjjz+epTAAAADA72W6rLZt2zZT5zkcDqWlpWU1DwAAAOCS6bKanp6ekzkAAACADG5pN4DVq1ercuXKSkhIyHAsPj5eVapU0f/+979sCwcAAIC72y2V1YkTJ+q5555TQEBAhmOBgYF64YUXNH78+GwLBwAAgLvbLZXVnTt3qnnz5jc93rRpU23fvv22QwEAAADSLZbVs2fPytvb+6bHvby8FBsbe9uhAAAAAOkWy2qJEiW0Z8+emx7ftWuXihUrdtuhAAAAAOkWy2qLFi00YsQIXb16NcOxpKQkvfbaa2rVqlW2hQMAAMDd7ZYet3r27FnVrFlTnp6eCg8PV4UKFSRJBw4c0AcffKC0tDRFRkaqaNGiORY4M3jcKgAAgL3lyONWixYtqo0bN6pPnz4aNmyYrvdch8OhZs2a6YMPPjBeVAEAAPD3cUtlVZJKlSqlb775RhcvXtSRI0dkWZbCwsJUoECBnMgHAACAu9gtl9XrChQooPvvvz87swAAAABubukGKwAAACA3GS+ra9asMR0BAAAANmW8rDZv3lzlypXTv//9b506dcp0HAAAANiI8bL6888/Kzw8XAsXLlTZsmXVrFkzzZ8/XykpKaajAQAAwDDjZTUoKEgDBgxQVFSUNm/erPLly6tv374qXry4IiIitHPnTtMRAQAAYIjxsvp7NWvW1LBhwxQeHq7ExETNmDFDtWrVUv369bV3717T8QAAAJDLbFFWU1NTtXDhQrVo0UKlSpXSd999pylTpujs2bM6cuSISpUqpY4dO5qOCQAAgFyW5X1Ws8tLL72kOXPmyLIsPfPMMxo3bpzuvfde13E/Pz+9++67Kl68uMGUAAAAMMF4Wd23b58mT56sdu3ayel03vCcoKAgtrgCAAC4Czksy7JMh8huDZdtMB0BAAAAf2Jdq3qZOs/4mtUxY8ZoxowZGcZnzJihsWPHGkgEAAAAuzBeVqdNm6aKFStmGK9SpYqmTp1qIBEAAADswnhZ/fXXX1WsWLEM44ULF9aZM2cMJAIAAIBdGC+rISEh2rAh4xrTDRs2sAMAAADAXc74bgDPPfec+vfvr9TUVDVp0kSStGrVKg0ZMkSDBg0ynA4AAAAmGS+rgwcP1vnz59W3b1+lpKRIkvLkyaNXXnlFw4YNM5wOAAAAJtlm66rExETt379fvr6+CgsLu+meq5nB1lUAAAD2ltmtq4zPrF7n7++v+++/33QMAAAA2Igtyuq2bds0f/58nTx50rUU4LrFixcbSgUAAADTjO8GMHfuXNWtW1f79+/XkiVLlJqaqr1792r16tUKDAw0HQ8AAAAGGS+ro0eP1oQJE7R06VL5+Pjo/fff14EDB9SpUyeVLFnSdDwAAAAYZLysHj16VC1btpQk+fj46PLly3I4HBowYICmT59uOB0AAABMMl5WCxQooEuXLkmSSpQooT179kiS4uLidOXKFZPRAAAAYJjxG6waNGig77//XlWrVlXHjh318ssva/Xq1fr+++/18MMPm44HAAAAg4yX1SlTpujq1auSpFdffVXe3t7auHGj2rdvr3/961+G0wFA7mhbKlhdypVQQaePjiZc1vt7j+lAXOINz21+TxENuy/MbSw5LV1Nv92UG1EBIFcZLavXrl3TsmXL1KxZM0mSh4eHhg4dajISAOS6xsWC1K9yGY3ffVT74i6pY5nieveBKnp6baTiUlJv+J7E1Gt6Zm2k67U9Hu8CANnP6JpVLy8vvfjii66ZVQC4G3UqW1zLTp3Vt6djFJ2YpPd2H9XV9DS1CCly0/dYki4kp7p+Lt6k1ALAnc74MoAHHnhAUVFRKlWqlOkoAJDrvBwOlQ/01xdHTrvGLEnbY+NVpUC+m77P19NT85rUkofDoUPxifroQLROJCblQmIAyF3Gy2rfvn01cOBAnTp1SrVq1ZKfn5/b8WrVqv3p+5OTk5WcnOw2lp6aIg9vn2zPCgDZLdDHW14eDl1Mdp8ZvZiSopL+N34wyqnEJI3beVhHL12Rn5enupQroQ/qVVOPdTsUezXlhu8BgDuV8bLapUsXSVJERIRrzOFwyLIsORwOpaWl/en7x4wZo1GjRrmNlezaU6Wf7J39YQHABvbGXdLeuEuu13suXtJnjWqodclgzTh00mAyAMh+xsvq8ePHb+v9w4YN08CBA93GWq7aflvXBIDcEp+Sqmvplgo4vd3GC/j46EJy5mZJ0yxLR+Iv6x6/PDkREQCMMl5Wb3etqtPplNPpdBtjCQCAO8U1y9Kh+ETVCgrU+rMXJEkOSTWDArXkxJlMXcNDUpmAvNocczHnggKAIcbL6mefffanx7t165ZLSQDAjPnHftGw+8J0ID5RB+IS1aFMcfl6eurbUzGSpOH3hSn2aoo+OhAtSeoeFqK9Fy/p5ytJ8vfyUtdyJRTs69Syk2dNfg0AyBHGy+rLL7/s9jo1NVVXrlyRj4+P8ubNS1kF8Le35sw55Xd6qVf5kiro9NGRhMsavGWvazuqIr5Opf9uI1V/by8NrlZOBZ0+upR6TYfiE9Vvw25FsxsAgL8hh2XZbyvpw4cPq0+fPho8eLDrgQG3ouGyDTmQCgAAANllXat6mTrP6EMBbiYsLExvv/12hllXAAAA3F1sWVal355u9csvv5iOAQAAAIOMr1n9+uuv3V5blqUzZ85oypQpqlcvc9PDAAAA+HsyXlbbtm3r9trhcKhw4cJq0qSJ3nvvPTOhAAAAYAvGy2p6errpCAAAALAp265ZBQAAAIyX1fbt22vs2LEZxseNG6eOHTsaSAQAAAC7MF5Wf/zxR7Vo0SLD+GOPPaYff/zRQCIAAADYhfGympiYKB8fnwzj3t7eSkhIMJAIAAAAdmG8rFatWlXz5s3LMD537lxVrlzZQCIAAADYhfHdAEaMGKF27drp6NGjatKkiSRp1apVmjNnjhYsWGA4HQAAAEwyXlZbt26tr776SqNHj9bChQvl6+uratWq6YcfflDDhg1NxwMAAIBBDsuyLNMhslvDZRtMRwAAAMCfWNcqc08qNb5mdevWrdq8eXOG8c2bN2vbtm0GEgEAAMAujJfVfv366dSpUxnGf/75Z/Xr189AIgAAANiF8bK6b98+1axZM8N4jRo1tG/fPgOJAAAAYBfGy6rT6dTZs2czjJ85c0ZeXsbv/wIAAIBBxstq06ZNNWzYMMXHx7vG4uLiNHz4cD366KMGkwEAAMA041OX7777rho0aKBSpUqpRo0akqSoqCgVLVpUs2fPNpwOAAAAJhkvqyVKlNCuXbv0xRdfaOfOnfL19VXPnj3VtWtXeXt7m44HAAAAg4yXVUny8/PTQw89pJIlSyolJUWS9O2330qSHn/8cZPRAAAAYJDxsnrs2DE98cQT2r17txwOhyzLksPhcB1PS0szmA4AAAAmGb/B6uWXX1aZMmUUExOjvHnzas+ePVq3bp1q166ttWvXmo4HAAAAg4zPrG7atEmrV69WUFCQPDw85OnpqYceekhjxoxRRESEduzYYToiAAAADDE+s5qWlqZ8+fJJkoKCgvTLL79IkkqVKqWDBw+ajAYAAADDjM+s3nvvvdq5c6fKlCmjf/zjHxo3bpx8fHw0ffp0lS1b1nQ8AAAAGGS8rP7rX//S5cuXJUlvvPGGWrVqpfr166tQoUKaN2+e4XQAAAAwyWFZlmU6xB9duHBBBQoUcNsV4FY0XLYhmxMBAAAgO61rVS9T5xmfWb2RggULmo4AAAAAGzB+gxUAAABwM5RVAAAA2BZlFQAAALZFWQUAAIBtUVYBAABgW5RVAAAA2BZlFQAAALZFWQUAAIBtUVYBAABgW5RVAAAA2BZlFQAAALZFWQUAAIBtUVYBAABgW5RVAAAA2BZlFQAAALZFWQUAAIBtUVYBAABgW5RVAAAA2BZlFQAAALZFWQUAAIBtUVYBAABgW5RVAAAA2BZlFQAAALblZTpATvCgggMAAPwtUOsAAABgW5RVAAAA2BZlFQAAALZFWQUAAIBtUVYBAABgW5RVAAAA2BZlFQAAALZFWQUAAIBtUVYBAABgW5RVAAAA2BZlFQAAALZFWQUAAIBtUVYBAABgW5RVAAAA2BZlFQAAALZFWQUAAIBtUVYBAABgW5RVAAAA2BZlFQAAALZFWQUAAIBtUVYBAABgW5RVAAAA2BZlFQAAALblZTrAwIEDbzjucDiUJ08ehYaGqk2bNipYsGAuJwMAAIBpDsuyLJMBGjdurMjISKWlpalChQqSpEOHDsnT01MVK1bUwYMH5XA4tH79elWuXDlz1/xmQ05GBgAAwG1a06Jeps4zvgygTZs2euSRR/TLL79o+/bt2r59u06fPq1HH31UXbt21c8//6wGDRpowIABpqMCAAAglxmfWS1RooS+//77DLOme/fuVdOmTfXzzz8rMjJSTZs21blz5zJ1TWZWAQAA7O2OmVmNj49XTExMhvHY2FglJCRIkvLnz6+UlJTcjgYAAADDjJfVNm3aqFevXlqyZIlOnz6t06dPa8mSJerdu7fatm0rSdqyZYvKly9vNigAAABynfHdAKZNm6YBAwaoS5cuunbtmiTJy8tL3bt314QJEyRJFStW1Mcff2wyJgAAAAwwvmb1usTERB07dkySVLZsWfn7+2f5WqxZBQAAsLc7Zs3q559/ritXrsjf31/VqlVTtWrVbquoAgAA4O/DeFkdMGCAihQpoieffFLffPON0tLSTEcCAACATRgvq2fOnNHcuXPlcDjUqVMnFStWTP369dPGjRtNRwMAAIBhxsuql5eXWrVqpS+++EIxMTGaMGGCTpw4ocaNG6tcuXKm4wEAAMAg47sB/F7evHnVrFkzXbx4UdHR0dq/f7/pSAAAADDI+MyqJF25ckVffPGFWrRooRIlSmjixIl64okntHfvXtPRAAAAYJDxmdUuXbpo2bJlyps3rzp16qQRI0aoTp06pmMBAADABoyXVU9PT82fP1/NmjWTp6en6TgAAACwEeNl9YsvvjAdAQAAADZlvKxK0uXLl7Vu3TqdPHlSKSkpbsciIiIMpQIAAIBpxsvqjh071KJFC125ckWXL19WwYIFde7cOeXNm1dFihShrAIAANzFjO8GMGDAALVu3VoXL16Ur6+vfvrpJ0VHR6tWrVp69913TccDAACAQcbLalRUlAYNGiQPDw95enoqOTlZISEhGjdunIYPH246HgAAAAwyXla9vb3l4fFbjCJFiujkyZOSpMDAQJ06dcpkNAAAABhmfM1qjRo1tHXrVoWFhalhw4YaOXKkzp07p9mzZ+vee+81HQ8AAAAGGZ9ZHT16tIoVKyZJeuutt1SgQAH16dNHsbGxmj59uuF0AAAAMMlhWZZlOkR2a/zNBtMRAAAA8CfWtKiXqfOMz6wCAAAAN0NZBQAAgG1RVgEAAGBblFUAAADYlvGtqwAAUttSwepcpoQKOn109NJlTdp7TAfiE294brMSRTS0epjbWEpaupp9tyk3ogJArrJFWV23bp3effdd7d+/X5JUuXJlDR48WPXr1zecDAByXuNiQepTsYwm7D2q/XGX1KF0cY17oIq6rYtUXErqDd+TmHpN3dZF5nJSAMh9xpcBfP7553rkkUeUN29eRUREKCIiQr6+vnr44Yf15Zdfmo4HADmuY5niWn7qrFacjlF0YpLG7zmqq2lpeuyeIn/6vospqW4/APB3ZHxm9a233tK4ceM0YMAA11hERITGjx+vN998U08++aTBdACQs7wcDpUP8NcXR0+7xixJkefiVaVAvpu+z9fTU3Ma15KHHDqckKiPD0brRGJSLiQGgNxlfGb12LFjat26dYbxxx9/XMePH//L9ycnJyshIcHtJz01JSeiAkC2C/TxlqeHQxeT3WdGLyanqKDT54bvOXU5SeN2H9a/th3Q6J2H5JBDk+tUU1CeG58PAHcy42U1JCREq1atyjD+ww8/KCQk5C/fP2bMGAUGBrr9RM+fnRNRAcAW9sVd0sqfY3X00mXtvJCgkZEHFJ+SqtYhwaajAUC2M74MYNCgQYqIiFBUVJTq1q0rSdqwYYNmzpyp999//y/fP2zYMA0cONBtrPWa7TmSFQCyW3xKqtLSLRVweruNF3D66EJy5v5KlGZZOpxwWSX88uRERAAwynhZ7dOnj4KDg/Xee+9p/vz5kqRKlSpp3rx5atOmzV++3+l0yul0uo15ePOnMAB3hmuWpUMJiapZKFAbzl6QJDkk1SwUqCXRZzJ1DQ9JZfPl1ebYizkXFAAMMVpWr127ptGjR6tXr15av369ySgAYMyC479oaLUwHYpP1P64RHUoU1x5vDy14nSMJGlYtTDFJqfo44PRkqRuoSHaF3dJP19Okr+3lzqXLaGivk4tP3XW5NcAgBxhtKx6eXlp3Lhx6tatm8kYAGDUmjPnFOjjpR7lS6qgz28PBXhly17XdlRFfJ1Kl+U639/bS4OqllNBHx8lXrumQ/GJCt+0W9HsBgDgb8hhWZb116flnDZt2qhdu3bq3r17tl2z8Tcbsu1aAAAAyH5rWtTL1HnG16w+9thjGjp0qHbv3q1atWrJz8/P7fjjjz9uKBkAAABMMz6z6uFx892zHA6H0tLSbvmazKwCAADY2x0zs5qenm46AgAAAGzK+EMBAAAAgJsxXlYjIiI0adKkDONTpkxR//79cz8QAAAAbMN4WV20aJHq1cu4ZqFu3bpauHChgUQAAACwC+Nl9fz58woMDMwwHhAQoHPnzhlIBAAAALswXlZDQ0O1YsWKDOPffvutypYtayARAAAA7ML4bgADBw5UeHi4YmNj1aRJE0nSqlWr9N5772nixIlmwwEAAMAo42W1V69eSk5O1ltvvaU333xTklS6dGl9+OGHPIYVAADgLmf8oQC/FxsbK19fX/n7+9/WdXgoAAAAgL3dMQ8F+L3ChQubjgAAAAAbsUVZXbhwoebPn6+TJ08qJSXF7VhkZKShVAAAADDN+G4AkyZNUs+ePVW0aFHt2LFDDzzwgAoVKqRjx47pscceMx0PAAAABhkvq//5z380ffp0TZ48WT4+PhoyZIi+//57RUREKD4+3nQ8AAAAGGS8rJ48eVJ169aVJPn6+urSpUuSpGeeeUZz5swxGQ0AAACGGS+rwcHBunDhgiSpZMmS+umnnyRJx48fl402KgAAAIABxstqkyZN9PXXX0uSevbsqQEDBujRRx9V586d9cQTTxhOBwAAAJOM77Oanp6u9PR0eXn9tjHB3LlztXHjRoWFhemFF16Qj4/PLV+TfVYBAADsLbP7rBovqzmBsgoAAGBvd9RDAa5evapdu3YpJiZG6enpbscef/xxQ6kAAABgmvGyumLFCnXr1k3nzp3LcMzhcCgtLc1AKgAAANiB8RusXnrpJXXs2FFnzpxxrV+9/kNRBQAAuLsZL6tnz57VwIEDVbRoUdNRAAAAYDPGy2qHDh20du1a0zEAAABgQ8Z3A7hy5Yo6duyowoULq2rVqvL29nY7HhERccvXZDcAAAAAe7tjdgOYM2eOVq5cqTx58mjt2rVyOByuYw6HI0tlFQAAAH8Pxsvqq6++qlGjRmno0KHy8DC+KgEAAAA2YrwdpqSkqHPnzhRVAAAAZGC8IXbv3l3z5s0zHQMAAAA2ZHwZQFpamsaNG6fvvvtO1apVy3CD1fjx4w0lAwAAgGnGy+ru3btVo0YNSdKePXvcjv3+ZisAAADcfYyX1TVr1piOAAAAAJsyvmYVAAAAuBnKKgAAAGyLsgoAAADboqwCAADAtiirAAAAsC3KKgAAAGyLsgoAAADboqwCAADAtiirAAAAsC3KKgAAAGyLsgoAAADboqwCAADAtiirAAAAsC3KKgAAAGyLsgoAAADboqwCAADAtiirAAAAsC3KKgAAAGyLsgoAAADbcliWZZkOAQC4ueTkZI0ZM0bDhg2T0+k0HQcAchVlFQBsLiEhQYGBgYqPj1dAQIDpOACQq1gGAAAAANuirAIAAMC2KKsAAACwLcoqANic0+nUa6+9xs1VAO5K3GAFAAAA22JmFQAAALZFWQUAAIBtUVYBAABgW5RVALC5tWvXyuFwKC4uLlvPBYA7ATdYAYDNpaSk6MKFCypatKgcDke2nQsAdwLKKgDkoJSUFPn4+JiOAQB3LJYBAMAtaNSokcLDwxUeHq7AwEAFBQVpxIgRuv7v/tKlS+vNN99Ut27dFBAQoOeff16StH79etWvX1++vr4KCQlRRESELl++7LpucnKyXnnlFYWEhMjpdCo0NFSffPKJpIx/2o+Ojlbr1q1VoEAB+fn5qUqVKvrmm29ueK4kLVq0SFWqVJHT6VTp0qX13nvvuX2n0qVLa/To0erVq5fy5cunkiVLavr06Tn1KwSAW0JZBYBbNGvWLHl5eWnLli16//33NX78eH388ceu4++++66qV6+uHTt2aMSIETp69KiaN2+u9u3ba9euXZo3b57Wr1+v8PBw13u6deumOXPmaNKkSdq/f7+mTZsmf3//G35+v379lJycrB9//FG7d+/W2LFjb3ru9u3b1alTJ3Xp0kW7d+/W66+/rhEjRmjmzJlu57333nuqXbu2duzYob59+6pPnz46ePDg7f+yAOA2sQwAAG5Bo0aNFBMTo71797rWhA4dOlRff/219u3bp9KlS6tGjRpasmSJ6z3PPvusPD09NW3aNNfY+vXr1bBhQ12+fFknT55UhQoV9P333+uRRx7J8Jlr165V48aNdfHiReXPn1/VqlVT+/bt9dprr/3luU899ZRiY2O1cuVK1zlDhgzR8uXLtXfvXkm/zazWr19fs2fPliRZlqXg4GCNGjVKL774Yvb84gAgi5hZBYBb9OCDD7rdvFSnTh0dPnxYaWlpkqTatWu7nb9z507NnDlT/v7+rp9mzZopPT1dx48fV1RUlDw9PdWwYcNMfX5ERIT+/e9/q169enrttde0a9eum567f/9+1atXz22sXr16bnklqVq1aq7/djgcCg4OVkxMTKbyAEBOoqwCQDbz8/Nze52YmKgXXnhBUVFRrp+dO3fq8OHDKleunHx9fW/p+s8++6yOHTumZ555Rrt371bt2rU1efLk28rs7e3t9trhcCg9Pf22rgkA2YGyCgC3aPPmzW6vf/rpJ4WFhcnT0/OG59esWVP79u1TaGhohh8fHx9VrVpV6enpWrduXaYzhISE6MUXX9TixYs1aNAgffTRRzc8r1KlStqwYYPb2IYNG1S+fPmb5gUAO6GsAsAtOnnypAYOHKiDBw9qzpw5mjx5sl5++eWbnv/KK69o48aNCg8PV1RUlA4fPqz//ve/rhusSpcure7du6tXr1766quvdPz4ca1du1bz58+/4fX69++v7777TsePH1dkZKTWrFmjSpUq3fDcQYMGadWqVXrzzTd16NAhzZo1S1OmTNE///nP2/9FAEAu8DIdAADuNN26dVNSUpIeeOABeXp66uWXX3ZtUXUj1apV07p16/Tqq6+qfv36sixL5cqVU+fOnV3nfPjhhxo+fLj69u2r8+fPq2TJkho+fPgNr5eWlqZ+/frp9OnTCggIUPPmzTVhwoQbnluzZk3Nnz9fI0eO1JtvvqlixYrpjTfeUI8ePW7rdwAAuYXdAADgFjRq1Ej33XefJk6caDoKANwVWAYAAAAA26KsAgAAwLZYBgAAAADbYmYVAAAAtkVZBQAAgG1RVgEAAGBblFUAAADYFmUVAAAAtkVZBYA7nMPh0FdffWU6BgDkCMoqAGSDHj16yOFw6MUXX8xwrF+/fnI4HJl+xOnatWvlcDgUFxeXqfPPnDmjxx577BbSAsCdg7IKANkkJCREc+fOVVJSkmvs6tWr+vLLL1WyZMls/7yUlBRJUnBwsJxOZ7ZfHwDsgLIKANmkZs2aCgkJ0eLFi11jixcvVsmSJVWjRg3XWHp6usaMGaMyZcrI19dX1atX18KFCyVJJ06cUOPGjSVJBQoUcJuRbdSokcLDw9W/f38FBQWpWbNmkjIuAzh9+rS6du2qggULys/PT7Vr19bmzZslSTt37lTjxo2VL18+BQQEqFatWtq2bVtO/loA4LZ4mQ4AAH8nvXr10qeffqqnnnpKkjRjxgz17NlTa9eudZ0zZswYff7555o6darCwsL0448/6umnn1bhwoX10EMPadGiRWrfvr0OHjyogIAA+fr6ut47a9Ys9enTRxs2bLjh5ycmJqphw4YqUaKEvv76awUHBysyMlLp6emSpKeeeko1atTQhx9+KE9PT0VFRcnb2zvnfiEAcJsoqwCQjZ5++mkNGzZM0dHRkqQNGzZo7ty5rrKanJys0aNH64cfflCdOnUkSWXLltX69es1bdo0NWzYUAULFpQkFSlSRPnz53e7flhYmMaNG3fTz//yyy8VGxurrVu3uq4TGhrqOn7y5EkNHjxYFStWdF0PAOyMsgoA2ahw4cJq2bKlZs6cKcuy1LJlSwUFBbmOHzlyRFeuXNGjjz7q9r6UlBS3pQI3U6tWrT89HhUVpRo1ariK6h8NHDhQzz77rGbPnq1HHnlEHTt2VLly5TLxzQDADMoqAGSzXr16KTw8XJL0wQcfuB1LTEyUJC1fvlwlSpRwO5aZm6T8/Pz+9PjvlwzcyOuvv64nn3xSy5cv17fffqvXXntNc+fO1RNPPPGXnw0AJnCDFQBks+bNmyslJUWpqamum6Cuq1y5spxOp06ePKnQ0FC3n5CQEEmSj4+PJCktLe2WP7tatWqKiorShQsXbnpO+fLlNWDAAK1cuVLt2rXTp59+esufAwC5hbIKANnM09NT+/fv1759++Tp6el2LF++fPrnP/+pAQMGaNasWTp69KgiIyM1efJkzZo1S5JUqlQpORwOLVu2TLGxsa7Z2Mzo2rWrgoOD1bZtW23YsEHHjh3TokWLtGnTJiUlJSk8PFxr165VdHS0NmzYoK1bt6pSpUrZ+v0BIDtRVgEgBwQEBCggIOCGx958802NGDFCY8aMUaVKldS8eXMtX75cZcqUkSSVKFFCo0aN0tChQ1W0aFHXkoLM8PHx0cqVK1WkSBG1aNFCVatW1dtvvy1PT095enrq/Pnz6tatm8qXL69OnTrpscce06hRo7LlOwNATnBYlmWZDgEAAADcCDOrAAAAsC3KKgAAAGyLsgoAAADboqwCAADAtiirAAAAsC3KKgAAAGyLsgoAAADboqwCAADAtiirAAAAsC3KKgAAAGyLsgoAAADb+n8N36ztvP/e+AAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from sklearn.model_selection import train_test_split, RandomizedSearchCV, StratifiedKFold\n",
        "from scipy.stats import randint\n",
        "\n",
        "# Step 5: Model Optimization (Randomized Search Cross-Validation)\n",
        "param_dist = {\n",
        "    'n_estimators': randint(100, 500),\n",
        "    'max_depth': [None, 10, 20, 30],\n",
        "    'min_samples_split': randint(2, 20),\n",
        "    'min_samples_leaf': randint(1, 10),\n",
        "    'bootstrap': [True, False]\n",
        "}\n",
        "\n",
        "# Use StratifiedKFold for cross-validation (maintains class distribution)\n",
        "stratified_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n",
        "\n",
        "random_search = RandomizedSearchCV(estimator=RandomForestClassifier(random_state=42),\n",
        "                                   param_distributions=param_dist, n_iter=20, cv=stratified_cv, scoring='accuracy', n_jobs=-1, verbose=2)\n",
        "random_search.fit(X_train, y_train)\n",
        "\n",
        "# the best parameters from Randomized Search\n",
        "best_params = random_search.best_params_\n",
        "print(f'Best Parameters: {best_params}')\n",
        "\n",
        "# the best model\n",
        "best_rf_model = random_search.best_estimator_\n",
        "\n",
        "# Step 6: Model Evaluation (using the best model from the grid search)\n",
        "y_pred = best_rf_model.predict(X_test)\n",
        "\n",
        "# Calculate and print accuracy, precision, recall, and F1-score\n",
        "accuracy = accuracy_score(y_test, y_pred)\n",
        "precision = precision_score(y_test, y_pred)\n",
        "recall = recall_score(y_test, y_pred)\n",
        "f1 = f1_score(y_test, y_pred)\n",
        "\n",
        "print(f'Accuracy: {accuracy:.2f}')\n",
        "print(f'Precision: {precision:.2f}')\n",
        "print(f'Recall: {recall:.2f}')\n",
        "print(f'F1-score: {f1:.2f}')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4LC32nl7-5UI",
        "outputId": "531104a9-e7b6-461b-e1a3-05d79a76db33"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Fitting 5 folds for each of 20 candidates, totalling 100 fits\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/joblib/externals/loky/process_executor.py:752: UserWarning: A worker stopped while some jobs were given to the executor. This can be caused by a too short worker timeout or by a memory leak.\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best Parameters: {'bootstrap': True, 'max_depth': 10, 'min_samples_leaf': 7, 'min_samples_split': 6, 'n_estimators': 124}\n",
            "Accuracy: 0.50\n",
            "Precision: 0.49\n",
            "Recall: 0.42\n",
            "F1-score: 0.45\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from sklearn.metrics import classification_report, confusion_matrix\n",
        "\n",
        "# Assuming you have already trained a model and made predictions (y_pred)\n",
        "\n",
        "# Generate a classification report\n",
        "class_report = classification_report(y_test, y_pred, target_names=['Not Churn', 'Churn'], output_dict=True)\n",
        "\n",
        "# heatmap for the confusion matrix\n",
        "conf_matrix = confusion_matrix(y_test, y_pred)\n",
        "plt.figure(figsize=(8, 6))\n",
        "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=['Not Churn', 'Churn'], yticklabels=['Not Churn', 'Churn'])\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('Actual')\n",
        "plt.title('Confusion Matrix')\n",
        "plt.show()\n",
        "\n",
        "# the classification report as a heatmap\n",
        "class_report_df = pd.DataFrame(class_report).transpose()\n",
        "plt.figure(figsize=(8, 6))\n",
        "sns.heatmap(class_report_df.iloc[:-1, :-3], annot=True, cmap='YlGnBu', cbar=False)\n",
        "plt.xlabel('Metrics')\n",
        "plt.ylabel('Classes')\n",
        "plt.title('Classification Report')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 245
        },
        "id": "ZecEZ8PHylpn",
        "outputId": "231ab710-5fbb-4748-aeb1-479c84982f36"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-83bc7f9ffe62>\u001b[0m in \u001b[0;36m<cell line: 8>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;31m# Generate a classification report\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mclass_report\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mclassification_report\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_names\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Not Churn'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'Churn'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_dict\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;31m# Create a heatmap for the confusion matrix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'y_test' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import joblib\n",
        "\n",
        "# Save the model for deployment\n",
        "# 'best_rf_model' is our trained model\n",
        "model_filename = 'churn_prediction_model.pkl'\n",
        "joblib.dump(best_rf_model, model_filename)\n"
      ],
      "metadata": {
        "id": "V-FHiZ4Mq7nx"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}