Classification_Models_GB.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "from sklearn.ensemble import GradientBoostingClassifier, VotingRegressor"
      ],
      "metadata": {
        "id": "ukdDgEGyl-k-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MI33WFHeknCp",
        "outputId": "e3fa5dae-87e5-46c9-c9af-d848853f3849"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "\"\"\"Mounting Google Drive\"\"\"\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive', force_remount = True)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.random.seed(42)"
      ],
      "metadata": {
        "id": "jtSwOUrhusIh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def add_noise(df, noise_level=0.25):\n",
        "    noisy_df = df.copy()\n",
        "    for column in df.select_dtypes(include=[np.number]).columns:\n",
        "        noise = np.random.normal(0, noise_level * df[column].std(), df[column].shape)\n",
        "        noisy_df[column] += noise\n",
        "    return noisy_df"
      ],
      "metadata": {
        "id": "cLqVxW59utpe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "folder_path = \"/content/drive/MyDrive/Features ASD_TD/\"\n",
        "\n",
        "# Initialize an empty list to store the combined data and labels\n",
        "data_list = []\n",
        "labels = []\n",
        "# Iterate through the ASD and TD folders\n",
        "for label, folder_name in enumerate([\"ASD\", \"TD\"]):\n",
        "    folder_dir = os.path.join(folder_path, folder_name)\n",
        "\n",
        "    # Iterate through files in each folder\n",
        "    for file_name in os.listdir(folder_dir):\n",
        "        if file_name.endswith(\".xlsx\"):\n",
        "            file_path = os.path.join(folder_dir, file_name)\n",
        "            # Check if the corresponding bands file exists\n",
        "            bands_file_path = os.path.join(folder_dir, file_name.split('.')[0] + \"_bands.xlsx\")\n",
        "            if os.path.exists(bands_file_path):\n",
        "                # Read both excel files\n",
        "                df_main = pd.read_excel(file_path)\n",
        "                df_bands = pd.read_excel(bands_file_path)\n",
        "                # Combine along columns\n",
        "                combined_df = pd.concat([df_main, df_bands], axis=1)\n",
        "                combined_df = add_noise(combined_df)\n",
        "                # Append the combined data and label to the list\n",
        "                data_list.append(combined_df)\n",
        "                labels.append(label)"
      ],
      "metadata": {
        "id": "sHwbG06kl1xE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "labels = np.array(labels)"
      ],
      "metadata": {
        "id": "x5X2HL7lcpRN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_list = np.array(data_list)"
      ],
      "metadata": {
        "id": "wImmC8wmgEVz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\" Data Augmentation\"\"\"\n",
        "\n",
        "def augment_data(data, labels, target_samples=1000, noise_factor=0.5):\n",
        "    augmented_data = []\n",
        "    augmented_labels = []\n",
        "\n",
        "    while len(augmented_data) < target_samples:\n",
        "        idx = np.random.randint(0, len(data))\n",
        "        original_sample = data[idx]\n",
        "        original_label = labels[idx]\n",
        "\n",
        "        noisy_sample = original_sample + noise_factor * np.random.normal(size=original_sample.shape)\n",
        "\n",
        "        augmented_data.append(noisy_sample)\n",
        "        augmented_labels.append(original_label)\n",
        "\n",
        "    augmented_data = np.array(augmented_data)\n",
        "    augmented_labels = np.array(augmented_labels)\n",
        "\n",
        "    return augmented_data, augmented_labels\n",
        "\n",
        "augmented_data, augmented_labels = augment_data(data_list, labels, target_samples=1000, noise_factor=5)"
      ],
      "metadata": {
        "id": "1x9ccLGFou7K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import StandardScaler\n",
        "\n",
        "data_2d = np.asarray(data_list).reshape(-1, np.asarray(data_list).shape[-1])\n",
        "\n",
        "scaler = StandardScaler()\n",
        "scaled_data_2d = scaler.fit_transform(data_2d)\n",
        "data = scaled_data_2d.reshape(np.asarray(data_list).shape)"
      ],
      "metadata": {
        "id": "kmFAVLdHnZ4A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\" GB Classifier \"\"\"\n",
        "\n",
        "gb_model = GradientBoostingClassifier()"
      ],
      "metadata": {
        "id": "FKE7SX_OpN_e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import KFold\n",
        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix\n",
        "\n",
        "\n",
        "\n",
        "kf = KFold(n_splits=5, shuffle=True, random_state=42)\n",
        "\n",
        "accuracies = []\n",
        "all_y_true = []\n",
        "all_y_pred = []\n",
        "\n",
        "# Perform K-Fold CV\n",
        "for train_index, test_index in kf.split(data):\n",
        "\n",
        "    X_train, X_test = data[train_index], data[test_index]\n",
        "    y_train, y_test = labels[train_index], labels[test_index]\n",
        "\n",
        "    X_train = X_train.reshape(X_train.shape[0], -1)\n",
        "    X_test = X_test.reshape(X_test.shape[0], -1)\n",
        "\n",
        "    # Fit the model\n",
        "    gb_model.fit(X_train, y_train)\n",
        "\n",
        "    # Predict and evaluate\n",
        "    y_pred = gb_model.predict(X_test)\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",
        "    accuracies.append(accuracy)\n",
        "    all_y_true.extend(y_test)\n",
        "    all_y_pred.extend(y_pred)\n",
        "\n",
        "mean_accuracy = np.mean(accuracies)\n",
        "\n",
        "print(f\"Mean Accuracy: {mean_accuracy:.2f}\")\n",
        "\n",
        "conf_matrix = confusion_matrix(all_y_true, all_y_pred)\n",
        "conf_matrix_df = pd.DataFrame(conf_matrix, index=['TD', 'ASD'], columns=['TD', 'ASD'])\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "\n",
        "plt.figure(figsize=(6, 6))\n",
        "sns.set_context('paper', font_scale=2.2)\n",
        "sns.heatmap(conf_matrix_df, annot=True, cmap='YlGnBu', fmt='g',\n",
        "            xticklabels=['ASD', 'TD'],\n",
        "            yticklabels=['ASD', 'TD'],\n",
        "            cbar=False)  # Remove the color bar\n",
        "plt.xlabel('Predicted label')\n",
        "plt.ylabel('True label')\n",
        "plt.tight_layout()\n",
        "plt.savefig('conf_GB_New.eps', format='eps')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 591
        },
        "id": "MoAI4H7fUp_h",
        "outputId": "db7e7b85-8469-43fb-f697-ffc8c84acd1b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Accuracy: 0.75\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x600 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAIsCAYAAADRd/LpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABDkElEQVR4nO3dd3xUVf7/8fdNSCMFTGgJkNBBpIMUQaQXFVAQFVBBd6W4iBVd21J0V8VFURcVG+1rQQgKYoVAqAkICEiXEgIkdIFAAmn390d+GRNJmWQmmTvJ6/l4zOMxzD33nM8MGfLm3HvPNUzTNAUAAGBhHq4uAAAAoDAEFgAAYHkEFgAAYHkEFgAAYHkEFgAAYHkEFgAAYHkEFgAAYHkEFgAAYHkVXF1AWdBg4FxXlwCgAK+9Xd3VJQAowF11+xXahhkWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeRVcXYAz/PHHH4qJiVFiYqLOnTsnwzAUHByssLAwderUSZUqVXJ1iQAAwAFuHVgWLVqkN954Q1u2bJFpmnm28fDwUPv27fXMM89o0KBBpVwhAABwBrc8JJSUlKT+/fvrnnvu0ebNm5WZmSnTNPN8ZGRkKDY2VoMHD9aAAQN0+fJlV5cPAACKyO1mWDIyMtS3b19t3LhRpmnKw8NDvXr1UpcuXdSoUSNdd911yszM1IULF7Rv3z6tW7dOK1euVGZmpr7//nv1799fq1evlmEYrn4rAADATm4XWF5//XXFxsbKMAz16tVLH3zwgerVq1fgPgcPHtTYsWMVFRWl9evXa9q0aXr22WdLqWIAAOAotzoklJqaqrfeekuGYWjQoEH66aefCg0rklS/fn39/PPPGjRokEzT1PTp05WWllYKFQMAAGdwq8CyZMkSnT17VgEBAZo9e3aRDusYhqHZs2crMDBQZ8+e1dKlS0uwUgAA4ExuFVjWrVsnSXrggQeKdaly5cqVdd9998k0Ta1Zs8bZ5QEAgBLiVoFl69atMgxD3bt3L3YfPXv2tPUFAADcg1sFlqNHj0qSmjVrVuw+mjdvLkmKj493Sk0AAKDkuVVguXDhgiTpuuuuK3Yf2ftevHjRKTUBAICS51aBJSkpSZLk7+9f7D78/Pxy9QUAAKzPrdZhyczMdNqCb/kt5Y+ywd+vgprWC9EN9YN1Q70QNWsQoro1g1TBMyujj3j+R23cedLu/mpXD9CIW5volrY1FVqloiQp8UyyVm85rs9/2Kf4EwRgwNneeGCKzp86Z1fbm+64RbeNHVzCFcGV3CqwAPb64tV+alovxCl93dG9nqaO66iKvl65Xm8Y7q2G4ZU1vH8j/ev9WH2z6pBTxgMAXMstA8vYsWNVoULxSk9PT3dyNbCmP2fiLiWnaW/cOVW9zk8RoUFF6qV7u1p6fUJneXp66FJymj7+eqdidpyQJHVqUUMPD24mfz8vvTahsy4kpWrV5mNOfRcApJoNa2vIU8MLbFMxKKCUqoGruGVg+eyzz1xdAixu0YrfdT7pqnYeOKvDCRdlmtLrj3UuUmDx8fbU1HEd5enpoaupGbrvxZ+088BZ2/Yte04pestxLXitv3y8PTVlXAetH5ug1LTMknhLQLnl7euj6nXCXF0GXMytTrqVlO9dmYvyQNk3b9leLV19WIeOZ4WV4hjco75Cq2ad4D176e5cYSXbzgNnNXvpbklSWNUA3dmjfrFrBgDkz60CS2ZmptMeGRkZrn47sLj+nevYnn/x47582335037b81tz7AMAcB63CixAafH0MNT2+mqSpPgTSTp+6nK+bY+dvGS7Sqhd0+ry8HDOlWwA/mSapi6evaAzx07p0vkkZsvLIbc8hwUoaRGhgfLx9pQkHYg/X2j7A0fPK7xG1j7hNQIVl8DChICzHD9wVK/c9ZyuXE6xveYXWFH1WjZUxwE3q17Lhi6sDqWFGRYgDzWr/XnFQcLp/GdXsiXmaFOzWvEXNgRwrdSUq7nCiiSlJCVr17rt+uTZ/yly+mdKS01zUXUoLWV2hmX79u167733tHnzZiUnJyssLEz9+vXTI4884tBKuSgf/P3+XHPlckrh/xBeytEm574Aii8wOFA3dGmhhm2aqHrdMPlXClB6aprOHD+tnWu3KWbJGqVdTdXW5ZuUmpKqYS8+6OqSUYLcKrAkJiZqzJgxkqQXXnhBHTp0yLPdrFmz9Oijj+Y6sXb//v2Kjo7We++9p6ioKNWrV69UaoZ78v3/h4MkKTW98MuUc17K7OfjVl8rwLLGvPXENaube1bwVM2GtVWzYW216tFWHz/7PyVfuKyd67Zp57ptatallWuKRYlzq0NCP/zwg5YtW6aYmBi1bt06zzYbN27U+PHjlZ6ebruMuWrVqvLy8pJpmjpy5IiGDBnCCVso0JXUP8Oud4XCvybeXn+2SbnK4oSAMxR2K5bqdcI08B9DbX/e+O26ki4JLuRWgWX9+vWSpDvuuEPe3t55tnnppZeUkZEhwzA0ePBgnTx5UidOnNDZs2f15JNPSpJ27Nihr7/+ukhjJyYmauvWrXk+0q+cd+h9wXouF/EQj79v0Q4hAXCOGzq3lF9A1v29juw6pMxMFm4sq9wqsOzevVuGYahv3755bk9MTNTKlStlGIaaNGmiBQsWqGrVqpKy7vD83//+V/3795ckLV68uEhjz5o1S23bts3zcfHIKsfeGCwn54m2YVULP+cpLMeJtvacpAvAOTw8PRRSM+vf+Yz0DCVf5PtXVrnVwfaTJ7PurtuqVas8t0dHR9vu6DxmzBh5enpe02b06NH64Ycf9OuvvxZp7DFjxmjgwIF5bhv8z7VF6gvWF5dwUalpGfL28lSD8MqFtm9QO6vN1dQMHUnkzs1AacrMcb6ih6db/T8cReBWgeX06dOSpCpVquS5fePGjbbnffr0ybNN9rkvCQkJRRo7NDRUoaGheW6r4PtbkfqC9WVkmtqy55Q6tQhVeI1A1azmn+/icbWqByi8RqCkrPsLZWZyfhRQWtJT03X66ClJkrevt+3wEMoet4qi2XdaPn/+fJ7bt27dKinr8E+TJk3ybFO5cmVJ0uXLTBuiYD+sP2J7Pqxf43zb3du3UY594kqyJAB/sfnHGKVdTZUk1WvZqNATdeG+3CqwZM+sxMXFXbMtLS1NW7dulWEYatu2bb59JCVlTdf7+vqWSI0oOxZHHdCJs8mSpAcHNlWzBiHXtGnWIEQPDmwqSTpx5rIWrzxYqjUCZdXejTt1NflKgW32b96jHz5eYvtz58HdSrgquJJbHRJq1aqVEhISNH/+fHXr1i3Xtp9//lnJyckyDOOabTkdPJj1C6VGjRolWClcLSI00HYvoJyvZevapmau1WwlXRM2rqRmaPIHsZr5z27y8fbU/73SVx99vVMxOxIlSZ1ahOrhO5vJx9tTGRmZmjxro66mclNNwBnWLVqlr16fp8btb1CdZvVVtXZ1+fr7KSM9XWePn9bO9du1N2anbYmKzoO7sUR/GedWgWXIkCH67rvv9Nlnn2ngwIEaNGiQpKyrg5577jlbu6FDh+bXhe3S6PwOGaFsaHt9NU17vEu+28fc1fya1/KaHVmx8aiee3eDpozrqICKXnpiRGs9MSL3GkApV9M16f1Yrdh41PHCAdhcTb6qHdFbtSN6a75tKnhVUM8HbtXNd/UoxcrgCm4VWIYPH67XX39d+/bt0+DBg9WwYUMFBgZq9+7dunLligzD0K233qqmTZvm28dXX30lwzDUsWPHUqwc7mzxyoPavPuU7ru1sbq2qakaVbIuYT5x5rLWbD2uz37Yx5VBgJP1H32HDm3/Xcf2HdHpoyeVfPGyUpKSJcOQX2BFVY8IVb2WDdS2TwcFXBfk6nJRCgzTzZZ83bt3r3r27KnExKxpecMwbFOC4eHh2rBhg8LCwvLcd+PGjerUqZMMw1BMTIzat2/vlJoaDJzrlH4AlIzX3q7u6hIAFOCuuv0KbeNWMyxS1qGc3bt3a8aMGVqxYoVOnTql4OBg9erVS0888YSCg4Pz3XfJkiVq27atKlWq5LSwAgAASp7bzbA4S2pqar7L+xcVMyyAtTHDAlibPTMsbnVZszNs3LhRjzzySL6HjQAAgPW43SGh4jh+/Ljmz5+vuXPnav/+/a4uBwAAFFGZDSxXrlzR4sWLNXfuXK1cuVKZmZnKefTrpptucmF1AACgKMpcYFm3bp3mzp2rhQsX2la1zQ4qTZo00YgRIzR8+HDVrVvXlWUCAIAiKBOBJT4+XnPnztW8efN06NAhSco1m2IYhjZv3my78SEAAHAvbhtYkpOTtXDhQs2dO1dr1qyRaZq2kOLl5aXbbrtN7dq104svvihJhBUAANyY2wWW6OhozZkzR4sXL7bdcTk7qLRp00ajRo3SsGHDFBISoi1bttgCCwAAcF9uFVjq1q2r+Ph4SX+GlBo1aui+++7TyJEjdcMNN7iyPAAAUELcKrAcOXJEUtY5Kf3799eECRPUu3dveXiUu+VkAAAoV9wqsEhZYUXKOjQUFJR1w6s+ffrYXgcAAGWPW01N/Otf/1KdOnVkmqZSUlL01Vdf6dZbb1WtWrX0zDPPaOfOna4uEQAAlAC3CiyTJ0/WwYMHFR0drZEjR8rf31+maSoxMVHTp09Xy5Yt1bZtW73zzjs6c+aMq8sFAABO4tY3P0xOTlZkZKTmzJmj6OhomaZpOzRUoUIFtWrVSr/88osMw1BGRkaJ1cHNDwFr4+aHgLWV+ZsfVqxYUffff7+ioqJ0+PBhTZkyRfXr15dpmkpLS9PmzZttAebhhx9WdHS0awsGAADF4tYzLPlZv3695syZo4ULF+rixYuS/jxZt1atWho+fLhGjBihZs2aOWU8ZlgAa2OGBbA2e2ZYymRgyXblyhVFRkZq3rx5ioqKUmZmpqSs8GIYhtLT050yDoEFsDYCC2BtZf6QUGF8fX01YsQI/fTTTzpy5IheeeUVNWrUKNcy/gAAwPrKdGDJqWbNmnr++ee1d+9erV+/XqNHj3Z1SQAAwE5ut3CcM3Tq1EmdOnVydRkAAMBO5WaGBQAAuC8CCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsLwK9jSqV6+e0wc2DEMHDx50er8AAKDssSuwxMXFOX1gwzCc3icAACib7AosXbt2JWAAAACXsSuwREdHl3AZAAAA+eOkWwAAYHkEFgAAYHkEFgAAYHl2ncNij2PHjunTTz/V+vXrlZCQoJSUFP34449q0KCBrc3evXuVkJAgf39/dejQwVlDAwCAMs4pgeX111/XpEmTlJaWJkkyTVOGYSg1NTVXu507d+ruu++Wt7e3jh49qqpVqzpjeAAAUMY5fEho6tSpev7555WamqoKFSqoTZs2+bYdPHiwqlWrprS0NH3zzTeODg0AAMoJhwLL7t27NXXqVEnSHXfcoYSEBP3yyy/5D+bhocGDB8s0Ta1atcqRoQEAQDniUGCZOXOmMjMzdcMNN+irr75SSEhIoft07NhRkvTbb785MjQAAChHHAos0dHRMgxD48ePV4UK9p0Ok31fomPHjjkyNAAAKEccCixHjx6VJLVu3drufQIDAyVJly9fdmRoAABQjjgUWNLT0yVJmZmZdu+TlJQkSfL393dkaAAAUI44FFiyL0suyt2ct2/fLkkKDQ11ZGgAAFCOOBRY2rVrJ0lFuuJn/vz5MgxDnTp1cmRoAABQjjgUWO68806Zpqm5c+cqPj6+0PZvv/22Nm3aJEkaOnSoI0MDAIByxKHAMmzYMDVu3Fipqanq1auXYmJicm03DEOSdOjQIY0dO1ZPPvmkDMPQjTfeqH79+jkyNAAAKEccWprf09NTkZGR6ty5sw4cOKAuXbqodu3atu133XWXLl68qISEBElZS/aHhIToiy++cKxqAABQrji8NH/Tpk0VExOjZs2ayTRNxcfH22ZW9u7dq+PHj8s0TZmmqaZNm2r9+vWqW7euw4UDAIDywyk3P2zSpIm2b9+uxYsXKzIyUps2bdLJkyeVnp6uqlWrql27dhoyZIiGDRsmDw+HMxIAAChnnBJYpKzzVYYMGaIhQ4Y4q0sAAABJTjgkBAAAUNIILAAAwPKcdkhIkrZu3aoff/xR27dv15kzZyRJVapUUcuWLdWvXz+1adPGmcMBAIBywimBZe/evRo9erTWr1+f5/ZFixbppZdeUpcuXTRr1iw1adLEGcMCAIBywuFDQqtWrVK7du20fv162+XL+T3Wrl2rdu3aafXq1c6oHQAAlBMOBZaTJ09q8ODBSk5Olmma6t69u7788ksdPnxYKSkpSklJ0eHDh/Xll1+qe/fukqTk5GTdeeedOnnypFPeAAAAKPscCixvvPGGLly4IMMw9M477ygqKkp33323IiIi5OPjIx8fH0VEROjuu+9WVFSUZsyYIUm6cOGCpk+f7oz6AQBAOeBQYPnuu+9kGIbuvvtujR8/vtD2EyZM0N133y3TNPXtt986MjQAAChHHAos2Xdovu++++ze5/7778+1LwAAQGEcCiy+vr6SpJo1a9q9T1hYWK59AQAACuNQYKlfv74k2e7GbI/ExMRc+wIAABTGocBy1113yTRN/d///Z/d+8yfP1+GYWjo0KGODA0AAMoRhwLLo48+qsaNG2vBggWaOXNmoe3/97//acGCBbr++uv16KOPOjI0AAAoRxwKLH5+flq+fLnat2+vCRMmqE+fPlq4cKGOHTumtLQ0paWl6dixY1q4cKF69+6txx57TB07dtTPP//MOSwAAMBudi3N7+npWWgb0zQVFRWlqKioAtts3LhRtWvXlmEYSk9Pt79SAABQbtkVWEzTtKsze9rZ2xcAAEA2uwLLyJEjS7oOAACAfNkVWGbPnl3SdQAAAOTL4bs1AwAAlDQCCwAAsDwCCwAAsDy7zmEpioyMDJ0/f17JycmFXhEUHh7u7OEBAEAZ5JTAcuHCBc2cOVORkZH67bfflJGRUeg+rMMCAADs5XBg+e233zRgwAAdPXqUNVYAAECJcCiwXL58WQMHDlR8fLw8PDw0aNAgVa1aVR999JEMw9CLL76oc+fOadOmTfrll19kGIZuuukm9erVy1n1AwCAcsChwPLxxx/ryJEj8vDw0A8//KDevXtr165d+uijjyRJU6ZMsbWNjY3ViBEjFBsbq5EjR+rvf/+7Y5UDAIByw6GrhJYtWybDMDRo0CD17t27wLYdO3bUqlWrFBQUpEcffVR79uxxZGgAAFCOOBRYdu7cKUkaOnRontv/ek5LeHi4xo8fr6tXr+q9995zZGgAAFCOOBRYzp07Jyn35cleXl625ykpKdfs06NHD0nS8uXLHRkaAACUIw4FluxwUrFiRdtrgYGBtucnTpy4Zp+AgABJUkJCgiNDAwCAcsShwFK9enVJ0pkzZ3K95uvrK0navn37NfscOnRIkuxaqwUAAEByMLDccMMNkqTdu3f/2aGHh9q0aSNJ+vTTT6/ZZ+bMmZKkunXrOjI0AAAoRxwKLDfffLNM09TKlStzvT5s2DCZpqnvv/9ew4cP17Jly7RgwQL169dPa9askWEYGjBggEOFAwCA8sMwHVie9vfff1fjxo3l4+Ojo0ePqkqVKpKktLQ0tW7dWrt375ZhGLn2MU1TYWFh2rFjh4KDgx2r3iIaDJzr6hIAFOC1t6u7ugQABbirbr9C2zg0w9KwYUP9+uuvWrdunby9vW2ve3l5afny5erRo4dM08z1aNu2rVatWlVmwgoAACh5Dt9LqGXLlnm+HhoaqhUrVujAgQPasWOH0tPT1aRJE7Vo0cLRIQEAQDnjlLs1F6RBgwZq0KBBSQ8DAADKMIcOCQEAAJQGAgsAALA8uw4JxcfHl8jgOZf0BwAAyI9dgaVOnTrXXJ7sKMMwlJ6e7tQ+AQBA2WT3SbcOLNcCAADgELsCy6RJk0q6DgAAgHwRWAAAgOU5tDQ/su13dQEACuAXzn+6ACtLif+i0DZc1gwAACyPwAIAACyPwAIAACyPwAIAACyPwAIAACyPwAIAACyPwAIAACyPwAIAACyPwAIAACyPwAIAACyPwAIAACzPrpsf2iM5OVmLFi3S+vXrlZCQoOTkZH366aeKiIiwtTl9+rSSkpLk4+OjmjVrOmtoAABQxjklsCxYsECPPvqozp49K0kyTVOGYejy5cu52i1dulSjR4+Wn5+fEhMTFRgY6IzhAQBAGefwIaGPP/5Yw4cP15kzZ2SapoKDg/Nte//99ysoKEgpKSlasmSJo0MDAIBywqHAEh8fr/Hjx0uSOnTooB07duj06dP5tvf29tYdd9whSYqKinJkaAAAUI44FFjeffddpaamKiIiQitWrFCzZs0K3adz584yTVPbt293ZGgAAFCOOBRYVqxYIcMwNGHCBPn7+9u1T6NGjSRJR44ccWRoAABQjjgUWOLi4iRlHQ6yV6VKlSRJSUlJjgwNAADKEYcCS0pKiiTJy8vL7n2Sk5MlSX5+fo4MDQAAyhGHAkuVKlUkFe3wzu7duyVJ1apVc2RoAABQjjgUWFq0aCFJio2NtXufr776SoZhqH379o4MDQAAyhGHAsvtt98u0zT14Ycf6ty5c4W2X7hwoZYvXy5JtsubAQAACuNQYHnooYcUGhqqS5cu6fbbb9fRo0fzbJecnKzXXntN9913nwzDUMOGDXXXXXc5MjQAAChHHFqa39fXVwsWLFCvXr20ceNGNWjQQJ06dbJtf/zxx5WSkqItW7bo6tWrMk1Tvr6++uKLL2QYhsPFAwCA8sEwTdN0tJPVq1frnnvu0alTp7I6/UsYyR6iatWqioyMVJcuXRwd0mL2u7oAAAXwC5/k6hIAFCAl/otC2zh8LyFJuuWWW3TgwAFNmzZNHTt2VIUKFWSapi2otGrVSi+//LJ+//33MhhWAABASXPKDMtfmaapc+fOKT09XSEhIapQwSk3hbYwZlgAK2OGBbA2e2ZYSiRJGIahkJCQkugaAACUQ045JAQAAFCSCCwAAMDyHDok9NBDDxV7X8Mw9MknnzgyPAAAKCccOunWw8PDofVUMjIyir2vtXDSLWBlnHQLWFupnHRblLxjGEaR2gMAAEgOnsOSmZlZ6OPSpUvatGmTxo0bJ8MwdMstt+jcuXPKzMx01nsAAABlXImfdFuxYkW1a9dOM2fO1KJFi7R27VoNGDCAwAIAAOxWqlcJ3XHHHRoxYoQ2bNigjz/+uDSHBgAAbqzUL2seOnSoTNPU/PnzS3toAADgpko9sNSqVUuStHfv3tIeGgAAuKlSDyznzp2TJF26dKm0hwYAAG6q1APLl19+KUkKDQ0t7aEBAICbKrXbKF+8eFFvvPGGPv74YxmGoV69epXW0AAAwM05FFh69OhRaJvMzEydO3dO+/fvV1pamqSsS52fffZZR4YGAADliEOBJTo62q6l+XOublu1alV9/vnnql+/viNDAwCAcsShwBIeHl5oYPH09FRgYKDq16+vnj17asSIEQoKCnJkWAAAUM44FFji4uKcVAYAAED+Sv0qIQAAgKJyaIZl6tSpkqQOHTqob9++TikIAADgrxwKLJMnT5ZhGFq0aJGz6gEAALiGQ4eEKleuLEmqU6eOE0oBAADIm0OBpXbt2pKkCxcuOKUYAACAvDgUWG699VZJ0sqVK51SDAAAQF4cCizjx49XUFCQ3n33XR04cMBZNQEAAOTiUGCpWbOmvvrqK5mmqc6dO2v27Nm6cuWKs2oDAACQJBlmznXzC+Dh4SEPDw/t2LFDTZs2lfTnvYTi4+N16NAhGYYhLy8vNWzYUMHBwfL09Mx/YMNQVFSUE96CFex3dQEACuAXPsnVJQAoQEr8F4W2KdJlzX/NNjnvJWQYhkzTVGpqqnbt2lXgkv2madp1DyIAAACpFO4lBAAA4CjuJQQAACyPewkBAADLI7AAAADLI7AAAADLK/I5LEuWLNHmzZudMvgDDzzglH4AAEDZVqR1WJx5RZBhGEpPT3daf67FOiyAlbEOC2BtTl+HRbp2LRYAAICSVuTAMm7cOFWrVq0kagEAAMhTkQPLP/7xD9vS/AAAAKWBq4QAAIDlEVgAAIDlEVgAAIDlEVgAAIDlEVgAAIDlEVgAAIDl2X1Z8+HDhyVJNWvWLLFiAAAA8mJ3YImIiCjJOgAAAPLFISEAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5FVxdgKO2bdumDRs2KDExUefOnZNhGAoODlZYWJg6d+6s5s2bu7pEAADgILcMLCkpKZo5c6amT5+uU6dOFdg2LCxMTz/9tMaOHSsfH59SqhAAADiTYZqm6eoiiuL48eO6/fbbtWPHDkmSPeUbhqE2bdpo6dKlCg0NLYGq9pdAnwCcxS98kqtLAFCAlPgvCm3jVjMsKSkp6tmzp37//XeZpqnAwEDde++96tKlixo1aqTrrrtOmZmZunDhgvbt26d169ZpwYIFSkpK0tatW9W7d29t2bKFmRZIko4ePaE1a7Zoy5bd2rfvsBITzyg1NU3+/n6qV6+WOnZsoaFD+ygsrJqrSwXKnAB/X7W8oY5aN6+rVs3qqHXzempUL1QVKnhKkvrcPVVrY/cU2k/bFvXU4+bm6tiukZo2rKVqVSvJwzD0x4XL2rH7iL5fsVWfL16rS5evlPRbQglzqxmWp556Sm+99ZYMw9CoUaM0Y8YMBQYGFrhPUlKSHnvsMc2ZM0eGYeipp57StGnTnFwZMyzu5p//fEtff72y0HY+Pt568sn7NWrUHSVfFEoMMyzWE/P9q2rVrE6+2+0JLHvXv6OI2lULHSvhxDn97Yn3FL1+V1HLRCkpUzMsly5d0kcffSTDMDRmzBi99957du0XGBioTz/9VD4+Ppo1a5ZmzZqlSZMmyd/fv4QrhpWdOHFWkuTr663u3durffvmatCgtgICKur06T8UFbVRkZHLdfVqql599RNlZGTqb38b7OKqgbLDMP58nnQpRb/tOaLqVSurfp0advdRMzRYknTi1Hkt/ekXbdi0V0eOndbV1HTVr1Nd9w/tpj7dWiqsRrC+nv2MbhvxH234ZZ+z3wpKidvMsMydO1cPPvigqlatqvj4+CIf1rl69arCw8N15swZzZkzR/fff78Tq2OGxd0888ybatq0vu66q7cCAirm2SY2docefniyUlPT5O3tpeXLP1SNGlVKuVI4AzMs1vPIg3117o9L2vrbYf1+KFGmaerD6WN1/9BbJNk3w7J26cv673tLtWz5FmVkZObZZuI/Bmnqs/dKknbtO6p2vZ9x7huBU9gzw+I267DExsbaDgUV5xwUHx8fjRw5UqZpasOGDSVQIdzJtGlPatSoQfmGFUnq2LGF7r23vyQpNTVNP//Mzw3gLO/N/klffrNe+w8m2HXxRF5uHviSlvz4S75hRZLemLlE23bGSZJuaFxbzZqEF2ssuJ7bBJatW7dKkrp27VrsPm655ZZcfQGFuemmlrbncXEJLqwEQHFFr99pe96wnv2HnGAtbhNYEhMTJUlNmjQpdh/XX3+9JCkhgV88sE9qaprtuYeH23xdAOTg4+1le17QbAyszW3+Bb5w4YIkqXLlysXuI3vfixcvOqEilAexsTtszxs2ZCoZcEe3dL7B9nz3/mMurASOcJvAcunSJUmSn59fsfvIPvfl8uXLTqkJZdvRoyf0zTdZlz5XrOir3r07ubgiAEU15PaOatqoliTpl18P6MDhEy6uCMXlNoHFmRczucmFUXCh1NQ0PfvsW0pOzlps6uGH71JwcCUXVwWgKGqHhejNqaMkSZmZmXru35+5tiA4xG0CSzYj58X7QAmZNGmmtmzZLUlq376Zxoy5y8UVASiKwAA/Rc5+RtWqZP1HY9r/lmj9pr0urgqOcJuF47L169dPnp6exdo3IyPDydWgLHr99U+1eHGUJKlevVqaMePZYv/MASh9fr7eivx0oppfn3XeWeSyWL385kIXVwVHuV1gWbdunUvGTUxMtF2p9FehockKDeV+M2XB9Olz9emnX0uSIiJCNWfOKwoJqezaogDYzdfHS5GzJ+rmjllXhX770y8aNeF/yszkVAB35zaBJTw83KWHg2bNmqUpU6bkuW3SpPGaPPnRUq4Izvbmm/P04YeLJGWFlfnzX1X16iEurgqAvbLDSvfOzSRJ3/68WSMeeVvp6cyulwVuE1ji4uJcOv6YMWM0cODAPLeFhiaXcjVwtv/+d44++ihSkhQeHqp58/5DWAHciJ+vtxbPfkbd/v8lzMuWb9GIcTOUlkZYKSvcJrBMnTpVhmHoueeeU4UKpV92aGioQkND89nKvYTc2bRps/XJJ4slZYWV+fP/wz2DADdS0c9Hi2dP1C03/RlWho99i7BSxrhNYJk8ebIMw9BTTz3lksCCsun11z/Rp59+IynrMNC8eYQVwJ1U9PPR13OeUddOTSX9/8NAzKyUSfzmR7mVM6zUqRPGYSDAzVT089E3c5/NdYLt8HGcs1JWEVhQLv33v3NsYaVSpQC99NIYXbhwSRcuXMp3Hz8/H9WuzY3TAGeoF1FdN93YONdr9etUtz3v062lImpVzbX9/xatsT339q6QK6z8+tth/XvGYjWql9+h+yynz17U6bPcnsUdGaabLPvq4eEhwzCUlJSkihUrurqcv+AcFnfTo8ffdPz4qSLt0759M82f/2oJVYSS5Bc+ydUl4C/uu6urPnpzXJH28QsfZnseXquK9m14t8jjvvLWIv37rcgi74eSlRL/RaFt3G6lWwAAUP4ww+IUzLAAVsYMC2Bt9sywuN05LP/5z3/k7e3tcD//+te/nFANAAAoDW43w+Iszr2vEDMsgJUxwwJYW5mcYXFGvuKOzwAAuBe3Cyy7du2y4DksAACgJLldYImIiCCwAABQznBZMwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDy3uUro8OHDksQVQgAAlENuE1giIiJcXQIAAHARDgkBAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLI7AAAADLM0zTNF1dBGAViYmJmjVrlsaMGaPQ0FBXlwPgL/iOll/MsAA5JCYmasqUKUpMTHR1KQDywHe0/CKwAAAAyyOwAAAAyyOwAAAAyyOwAAAAyyOwAAAAyyOwADmEhoZq0qRJXC4JWBTf0fKLdVgAAIDlMcMCAAAsj8ACAAAsj8ACAAAsj8ACtzd58mQZhiHDMBQRESF7T8u6evWqZs+erdtvv121atWSr6+vAgICVLduXXXs2FEPPfSQPvnkEyUkJOS5f/aYOR+enp6qXLmyIiIi1KVLF02YMEFfffWVrl696sy3DLiluLi4PL83RXlMnjxZklSnTp1rtnl4eCgoKEi1a9dW+/btNXbsWM2ZM0dJSUmufeNwCk66hVszTVP169fX4cOHba9FRUWpR48eBe63d+9e3Xnnndq7d2+hY9x2221atmzZNa8bhmF3nSEhIXriiSf07LPPqkKFCnbvB5QlcXFxqlu3rkN9TJo0SZMnT1adOnV05MgRu/YJCAjQww8/rFdeeUUVK1Z0aHy4DjMscGtr1qzJFVYkac6cOQXuc/78efXs2VN79+6Vl5eXRo4cqaioKB08eFBnz57Vvn37tGDBAj300EMKDg4utIYRI0YoKSnJ9jhx4oT27NmjhQsX6pFHHlFAQIDOnj2rF198UTfffLMuXLjgyFsG3FZERESu70rOx65du2ztnnvuuXzbPf/887n67NKlS67tp06d0v79+7V06VI9/fTTqlKlii5duqS33npLrVu31tGjR0v7bcNZTMCNjRo1ypRk+vr6mv369TMlmf7+/mZSUlK++0yePNmUZEoyIyMjC+w/JSXF3LBhQ57bsvsYOXJkgX2cO3fOHDRokK19nz59zIyMjELfG1CeHD582PYdmTRpUqHtIyIiTEnmLbfcUmC75ORkc8yYMba+W7RoYV66dMk5RaNUMcMCt3X58mUtWrRIkjRw4EBNmDDB9vrChQvz3W/58uWSpIYNG2rw4MEFjuHr66tOnTo5VOd1112nxYsXq1evXpKkn3/+2VY3gJLl5+enDz74QA8++KAkaceOHZo5c6aLq0JxEFjgtiIjI3Xp0iVJ0siRI9WnTx/VqFFDkjR37tx89zt16pQkKTAwsOSL/P88PDz0wQcfyMMj6yv3xhtvlNrYAKQZM2bYvvPTp09XZmamiytCURFY4Layz1WpUaOG+vbtK09PT913332Sss5tiYuLy3O/7PNSdu/erePHj5dGqZKk+vXrq2fPnpKkLVu26OzZs6U2NlDeBQUF6d5775WU9Z+Wbdu2ubYgFBmBBW7pyJEjio6OliQNHz5cnp6ekrJmWqSsq4fym2XJPjRz5coV9evXT8uWLVNqamrJF62sEwSz64uJiSmVMQFkyf7+SdKGDRtcWAmKg8ACtzRv3jzbeivZIUWSmjVrpjZt2lzTJqcnnnhC4eHhkqSdO3dqwIABuu6663TzzTfrscce0+eff57v2iuOatSoke15YmJiiYwBIG98/9wbgQVuad68eZKkVq1aqUWLFrm2jRo1SpJ06NAhrV279pp9Q0JCtH79et16662215KTk7Vu3Tq98847GjFihGrXrq3evXsrNjbWqXVfd911tufnzp1zat8ACsb3z70RWOB21q1bpwMHDkiSHnjggWu2Dxs2TF5eXpLyP/m2Vq1a+u677/Tbb7/pX//6l7p27Sp/f3/b9szMTK1YsUJdunTRBx984LTac57oV5SF5wA4ju+feyOwwO1kn2xboUIFjRgx4prtVapU0W233SZJWrhwoZKTk/Ptq1mzZpoyZYpWr16tixcvateuXXrrrbfUpEkTSVJGRobGjx+vX3/91Sm151w0zp5F6QA4D98/90ZggVtJSUmxrbHSqlUrxcfHa/Pmzdc82rVrJ0lKSkrS4sWL7erbw8NDTZs21eOPP64dO3bY1mjJyMjQe++955T69+3bZ3seFhbmlD4B2Ifvn3vjpiZwK4sXL9bFixclSZs3b9aNN95Y6D5z5861Xe5sLy8vL73//vu2sLN58+aiF5uHdevWScoKR44uSAegaLK/f5LUuXNnF1aC4mCGBW6loAXh8rNy5cpi3T+kWrVqqlatmiQVeFjJXgcPHtTKlSslSe3bt891AiCAknXx4kUtWLBAUtbsSvPmzV1cEYqKwAK3cezYMUVFRUmSHnzwQZmmWeBjy5YtkrJOtJs/f36Rx7t06ZLOnz8vyfHp48zMTI0dO9Z20t/EiRMd6g9A0Tz++ONKSkqSJD311FO2VafhPvgbg9uYN2+e7Re+PYd42rRpYzt5NufMzHPPPWfX5cqTJ0+2LSjXt2/f4pQsSfrjjz80ZMgQrVixQpLUv39/3XnnncXuD4D9rly5onHjxmn27NmSpNatW2vcuHEurgrFwTkscBvZoaNWrVrq1q2bXfuMGDFCL730kvbv36+YmBh16tRJy5cv12uvvaaWLVvq7rvvVufOnVW/fn0FBgbq/Pnz+vXXX/XRRx/p+++/lyTVrl1b//jHP/IdIz093XZPIynrxOA//vhDv/32m1auXKn58+fb/md30003acGCBVxSCThJRkZGru/f1atXdf78ee3Zs0dr1qzRnDlzdPr0aUlSkyZN9O2338rPz89V5cIBBBa4hZiYGO3fv19S1jor9k7nDh8+XC+99JKkrMDTqVMnVapUSZK0fft2bd++vcD9mzdvrsjIyAJvlPjZZ5/ps88+K7CfkJAQPfnkk3r22WdttxEA4Lh169YVeiPTgIAAjR49Wq+88gphxY0RWOAWch7SKcoVP/Xq1VOnTp0UExOjBQsWaMaMGVqxYoU2btyoFStWKDY2Vnv37tWJEyd05coV+fv7KywsTK1bt9bgwYN15513FilgGIahwMBABQUFKTw8XG3atFHXrl01cOBA+fj4FOk9AygawzDk7++voKAghYWFqU2bNrrppps0ePDgUr07O0qGYeZ1sxUAAAAL4aRbAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAAWqU6eODMNQt27dirW9rJszZ44Mw5BhGIqOji52P9l9jBo1ymm1/VVcXJxtnMmTJ5fYOEURHR1tq2nOnDmuLgcWRmABiinnP/5/fVSoUEHBwcFq1aqVxo0bp9jYWFeXCwBujcAClICMjAz98ccf2r59uz744AN16tRJo0aNUlpamqtLczujRo2yBUEA5VcFVxcAlAXt2rXT7NmzbX/OyMhQYmKifvjhB33wwQdKTU3V3Llz5e3trQ8//NCFlTpfXFycq0sAUA4QWAAn8Pf3V7NmzXK91rJlS/Xr10933nmnevfurfT0dH388cd66qmn1LhxYxdVCgDuiUNCQAnr1q2b7rrrLkmSaZr67rvvXFwRALgfAgtQCjp37mx7fvjwYdvzvK6QWLFihYYNG6Y6derI19dXhmHkedhl1apV+tvf/qbGjRsrKChIfn5+ioiI0D333KMffvjBrrqSkpI0depUtWrVSoGBgQoKClLz5s310ksv6cyZM3b1UZSrhJYtW6aRI0eqUaNGCgoKkpeXl6pXr67u3btrypQp2r9/v61t9rkrc+fOtb2W1wnO+V1Zcv78eU2bNk3du3dXaGiovL29FRwcrA4dOmjy5Ml2v7/o6GgNHTpUYWFh8vHxUc2aNTVo0CB9//33du3vLFeuXNE333yjRx55RDfeeKNCQkLk5eWloKAgXX/99fr73/+uTZs2FbnfDRs2aMSIEYqIiJCvr6+qVaum/v37a9GiRXb3ceDAAT399NNq06aNQkJC5O3trRo1aqhv37768MMPlZqaWuS6gGuYAIrl8OHDpiRTknnLLbcU2Pb999+3tR03bpzt9VWrVtlenz17tvnII4/Y/pzzcfjwYds+58+fNwcMGJBnu5yPgQMHmhcvXsy3pp07d5q1atXKd/+aNWua27ZtMyMiIgp8j4VtN03TjI+PNzt27FhozS1btrTtM3LkyELbZ39ufxUZGWlWrly5wP2CgoLMpUuX5luzaZrmk08+WWAf48ePN2fPnm3786pVqwrsryDZfYwcOTLP7YMGDbLr83jyySfNzMzMPPvI+TM7adIk8/XXXzc9PDzy7WvIkCHm1atX8605MzPTfOGFF8wKFSoUWFOTJk3Mffv25dnHX78DQH44hwUoBdu2bbM9r1mzZp5t3n77bW3btk2tWrXS+PHj1axZM2VkZOiXX35RQECAJCk5OVndunWz9denTx/de++9qlOnjoKCgnTw4EHNnTtX33//vZYuXap77rlHy5Ytk4dH7snU06dPq2fPnjp58qQkqWfPnhozZozq1auns2fPKjIyUp988okGDx6s5ORkh9778ePH1aFDByUmJkqSmjVrpocfflitW7dWQECAzpw5o61bt+rbb7/V5cuXbfv9+9//1tNPP60XX3xRS5YskST99ttv1/Rfq1atXH/+/PPPdd9998k0TVWpUkXjxo1T69atFR4erkuXLmnNmjV65513dObMGQ0ZMkQrVqxQ165dr+n35Zdf1ptvvilJCgoK0lNPPaXu3bvL19dX27Zt0/Tp0/W///1PHTp0cOjzsVd6errq16+vAQMG6MYbb1TdunXl6+urhIQE7dixQzNnztTx48f15ptvKiwsTE899VSB/f3www/atGmTwsLCNHHiRHXs2FGSFBsbqzfeeEMJCQmKjIzUww8/nGuWK6exY8faTiJv2rSpRo8erUaNGql69eo6ceKEli1bpo8//lh79+5Vr169tHnzZlWrVs25HwzKD1cnJsBd2TvDsn//ftPf39/WNjY21rYt5/8uJZmDBw8209LS8u0rewbG19fX/Omnn/Jt9/rrr9v6/Pzzz6/ZPmrUKNv2CRMm5NnH119/bRqGUeh7LGyGpXv37rlmJDIyMvKt+8iRI9e8lnOmpTBxcXFmxYoVTUnmgAEDzEuXLuXZLiEhwaxfv74pybz++uuvqen33383vby8TElmlSpV8pwduHz5stm5c+dcf38lOcOyf//+fGdOTNM0U1JSzJ49e5qSzMqVK5tJSUnXtMn5MyvJbNy4sXnq1Klr2p06dcps1KiRrd3y5cuvafPVV1/Ztr/yyiv51rZ69WrT19fXlGSOHj36mu3MsMBeBBagmAoKLOnp6eaxY8fMDz/80KxevbqtXe/evXO1y/mPdUBAgHnu3Ll8xzt+/Ljp7e1tSjJffvnlQutr3bp1nrWdOnXK1k/9+vXN1NTUfPt48MEHHQosa9asse1/8803F/gLNz9FCSz/+Mc/TElmcHCweeHChQLbLlmyJN+g8cQTT9i2ffLJJ/n2cfDgwVyHQ0oysNhj27Zttn6++eaba7b/NbCsWbMm375Wr15ta3fbbbdds/2GG24wJZk9e/YstK7sz9PX19dMSUnJtY3AAntx0i3gBKtXr75mpdtatWpp9OjRtsMu7dq10xdffJFvHwMHDtR1112X7/Zvv/3WdvLi8OHDC62pR48ekrKm+DMyMmyvr1q1ytbPAw88IC8vr3z7GDNmTKHjFOTrr7+2PZ84cWKJL/62ePFiSdJtt92moKCgAttmfz6StH79+lzbfvzxR0lSxYoVC/ys69Wrp169ehW3XIdcvHhRcXFx2rVrl3bu3KmdO3fKNE3b9q1btxa4f5MmTXTzzTfnu71r165q0qSJJCkqKirXoof79u3Trl27JBXtZ/HKlSvasmVLoe2BvBBYgBLk4+Ojm266SR988IFiYmIUEhKSb9tWrVoV2FfOK0Dq16+f720Bsh/Tp0+XJF29elXnzp2z7bt9+3bb8+zzFvLTpk2bAgNNYbJ/ORmGoe7duxe7H3scPXrUdp7M/PnzC/18AgMDbfsmJCTYnqempmrv3r2SstbS8fX1LXDc0jqHRZJ27Nihv//976pVq5YqVaqkunXrqlmzZmrevLmaN2+u1q1b29oWdhVUp06dCh0v+71duXIl1xVcOX8W//a3vxX6WQ8YMMDWPudnDRQFJ90CTvDXlW49PT0VGBio6tWr2/0LPzg4uMDt2TM1xZHzxNmzZ8/anlevXr3A/by8vBQcHFzssU+fPi0p66TV7BOHS4qzPp9z587ZZioK+3wkqUaNGsUetyjefPNNTZw4UZmZmXa1L+xk6aK+t5wByFmfNVAUBBbACfJa6baoPD09C9yenp5uex4TE1OkABAWFlbsutxFzs/n/vvv1zPPPGP3vgUdirOCtWvX2q76CQkJ0ZNPPqkePXqoXr16qlSpknx8fCRJmZmZtp+jnIeHnC3nZ/3OO+8Uafbsr1d1AfYisABuomrVqrbnISEhatiwYbH6yXlYqrD/KaelpeU6nFRUVatW1Z49e3Tx4kVdunSpRGdZcn4+GRkZxQ6QwcHBMgxDpmnaNZNw4sSJYo1TFO+//74kycPDQ9HR0fm+t6L8XRX1vVWpUsX2POdn7evr63BYB+zBOSyAm2jXrp3t+erVq4vdT8uWLW3PY2NjC2y7detWh+4wnV2zaZpatWpVsfqw90TdunXr2g6rrV27ttgzDN7e3raTTbdv364rV64U2H7jxo3FGqcostefadmyZYHhoCgr3cbExBTaJvu9+fr6qlGjRrbXnfWzCBQFgQVwE4MGDVKFClmTom+//Xaxlzvv3r27vL29JUnz5s0rMJDMmjWrWGNku/POO23P33jjjWKFCD8/P9vzq1ev5tvOw8PDNt7Ro0cLvCKrMP369ZOUdb7F559/nm+7Q4cOacWKFcUex17Zh2ByLqyXl3fffdfuPvfu3au1a9fmu33NmjW2k4979uyZ61ysFi1aqEGDBpKkRYsW5brdBFBSCCyAm6hTp44eeughSdLOnTv1wAMPKCUlpcB9YmNjr7nZYtWqVTVs2DBJ0sGDB/X000/nue+SJUvyvU+Pvbp06WI7v2Ht2rV67LHHCjxpND4+/prXcp5/k/NKlbw8//zztqt6xo0bp+jo6ALbJyUl6c0337ympnHjxtl+QT/77LN5jpuSkqKRI0fmOp+jpGTP+Pz+++9as2ZNnm3+/e9/2y7HttfDDz+c59VEp0+f1ujRo21/fuyxx3JtNwxDU6dOlZQVIgcOHJjn311O8fHx+uSTT4pUH5CLC9eAAdxaUe4llJ+iLpp1+fJl88Ybb7TtU7t2bXPKlCnm8uXLzV9//dXcsGGDuXDhQvOf//yn2bRpU1OS+cILL1zTz6lTp3ItaNerVy9z4cKF5pYtW8yff/7ZHDNmjOnp6WnWq1fPrFq1qkMr3R49ejTXWM2bNzffeecdc+3ateavv/5qrlixwvzvf/9r3nzzzWarVq2u2T86Otq2b9euXc2ffvrJ3LVrl7lnzx5zz5495vnz53O1//LLL233x/Hw8DCHDBlizp8/34yJiTG3bt1qRkVFme+++645dOhQ26q4ea0uPHXqVNu4lSpVMqdOnWquW7fO/OWXX8yPPvrIbNy4sSnJ7NChQ4kvHLd06VLb9qCgIHPSpElmVFSUuXnzZvPzzz83e/XqZVucr6B+cv7Mtm/f3pRkhoWFmTNmzDBjYmLMmJgYc8aMGWZYWJit3QMPPJBvzTnvfRUQEGCOHz/e/Oabb8zNmzebmzZtMr/77jvz1VdfNbt162Z6eHiYnTt3vqYPFo6DvQgsQDG5IrCYpmkmJSWZ999/f64VSwt6TJs2Lc9+du7cadasWTPf/WrWrGlu377dKTc/PHz4sNmmTZtCa81588NsmZmZuZb3/+sjr8/tp59+MmvUqGHX5xMYGGimp6fnOe7jjz9e4L6PPvpoqd38sLAbMd54443mqVOn7A4skyZNMqdNm1bgzQ8HDx5c6M0Pp02bZlt6v7DHrbfeek0fBBbYi0NCgJsJCAjQvHnztGPHDj3xxBNq27atQkJC5OnpqYoVK6pevXq69dZb9eqrr2rXrl2aOHFinv3ccMMN2rNnjyZPnqwWLVrI399fAQEBatasmV544QVt375dLVq0cErNderU0ebNm7Vo0SLdfffdioiIkJ+fn7y8vFSjRg11795dL7/8cq6VcbMZhqHvv/9er776qjp06KDKlStfczPHv+rTp48OHz6sjz76SHfccYfCw8NVsWJFeXl5KSQkRO3atdPo0aO1cOFCnTx5Ms9Lyg3D0FtvvaWVK1dq8ODBqlGjhry9vRUaGqqBAwfqu+++0zvvvOOUz8ce06dP17Jly9S/f3+FhITIy8tL1atXV7du3fT+++9rw4YNua7escfEiRO1du1aDRs2TOHh4fLx8VGVKlXUt29fLVy4UJGRkbbznfJiGIYmTpyouLg4vfLKK+revbvtc/Lx8VFoaKi6du2qZ555RqtWrdKyZcsc/RhQjhmmWYIX6wMAADgBMywAAMDyCCwAAMDyCCwAAMDyCCwAAMDyCCwAAMDyCCwAAMDyCCwAAMDyCCwAAMDyCCwAAMDyCCwAAMDyCCwAAMDyCCwAAMDyCCwAAMDyCCwAAMDy/h+CaRc4dBMiNAAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Mean of Accuracies is: ', np.mean(accuracies))\n",
        "print('SD of Accuracies is: ', np.std(accuracies))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-ilaCiRDu6Bm",
        "outputId": "312e917d-a933-4d2d-9035-3afe79f70719"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean of Accuracies is:  0.7533333333333334\n",
            "SD of Accuracies is:  0.10022197585581942\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import roc_curve, auc\n",
        "\n",
        "fpr, tpr, _ = roc_curve(all_y_true, all_y_pred)\n",
        "roc_auc = auc(fpr, tpr)\n",
        "\n",
        "# Plot ROC curve\n",
        "plt.figure()\n",
        "plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')\n",
        "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n",
        "plt.xlim([0.0, 1.0])\n",
        "plt.ylim([0.0, 1.05])\n",
        "plt.xlabel('False Positive Rate')\n",
        "plt.ylabel('True Positive Rate')\n",
        "plt.legend(loc=\"lower right\")\n",
        "plt.tight_layout()\n",
        "plt.savefig('roc_curve_GB_New.eps', format='eps')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 491
        },
        "id": "fDzHAuzrw-ND",
        "outputId": "c1b391e3-fac5-40b7-fdcf-73baa37520a9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:matplotlib.backends.backend_ps:The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\" Time Domain Features\"\"\"\n",
        "\n",
        "kf = KFold(n_splits=5, shuffle=True, random_state=42)\n",
        "\n",
        "accuracies = []\n",
        "all_y_true = []\n",
        "all_y_pred = []\n",
        "\n",
        "# Perform K-Fold CV\n",
        "for train_index, test_index in kf.split(data):\n",
        "\n",
        "    X_train, X_test = data[train_index, 0:6], data[test_index, 0:6]\n",
        "    y_train, y_test = labels[train_index], labels[test_index]\n",
        "\n",
        "    X_train = X_train.reshape(X_train.shape[0], -1)\n",
        "    X_test = X_test.reshape(X_test.shape[0], -1)\n",
        "\n",
        "    # Fit the model\n",
        "    gb_model.fit(X_train, y_train)\n",
        "\n",
        "    # Predict and evaluate\n",
        "    y_pred = gb_model.predict(X_test)\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",
        "    accuracies.append(accuracy)\n",
        "    all_y_true.extend(y_test)\n",
        "    all_y_pred.extend(y_pred)\n",
        "\n",
        "mean_accuracy = np.mean(accuracies)\n",
        "\n",
        "print(f\"Mean Accuracy: {mean_accuracy:.2f}\")\n",
        "\n",
        "conf_matrix = confusion_matrix(all_y_true, all_y_pred)\n",
        "conf_matrix_df = pd.DataFrame(conf_matrix, index=['TD', 'ASD'], columns=['TD', 'ASD'])\n",
        "\n",
        "\n",
        "print('Mean of Accuracies for Time Domain is: ', np.mean(accuracies))\n",
        "print('SD of Accuracies for Frequency Domain is: ', np.std(accuracies))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z_AsUXSA7VyZ",
        "outputId": "3325b17f-b20f-4ce9-be79-02e9f8c45293"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Accuracy: 0.90\n",
            "Mean of Accuracies for Time Domain is:  0.9\n",
            "SD of Accuracies for Frequency Domain is:  0.1527525231651947\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1471: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1471: UndefinedMetricWarning: Recall is ill-defined and being set to 0.0 due to no true samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n",
            "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1760: UndefinedMetricWarning: F-score is ill-defined and being set to 0.0 due to no true nor predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, \"true nor predicted\", \"F-score is\", len(true_sum))\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\" Frequency Domain Features\"\"\"\n",
        "\n",
        "kf = KFold(n_splits=5, shuffle=True, random_state=42)\n",
        "\n",
        "accuracies = []\n",
        "all_y_true = []\n",
        "all_y_pred = []\n",
        "\n",
        "# Perform K-Fold CV\n",
        "for train_index, test_index in kf.split(data):\n",
        "\n",
        "    X_train, X_test = data[train_index, 6:], data[test_index, 6:]\n",
        "    y_train, y_test = labels[train_index], labels[test_index]\n",
        "\n",
        "    X_train = X_train.reshape(X_train.shape[0], -1)\n",
        "    X_test = X_test.reshape(X_test.shape[0], -1)\n",
        "\n",
        "    # Fit the model\n",
        "    gb_model.fit(X_train, y_train)\n",
        "\n",
        "    # Predict and evaluate\n",
        "    y_pred = gb_model.predict(X_test)\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",
        "    accuracies.append(accuracy)\n",
        "    all_y_true.extend(y_test)\n",
        "    all_y_pred.extend(y_pred)\n",
        "\n",
        "mean_accuracy = np.mean(accuracies)\n",
        "\n",
        "print(f\"Mean Accuracy: {mean_accuracy:.2f}\")\n",
        "\n",
        "conf_matrix = confusion_matrix(all_y_true, all_y_pred)\n",
        "conf_matrix_df = pd.DataFrame(conf_matrix, index=['TD', 'ASD'], columns=['TD', 'ASD'])\n",
        "\n",
        "print('Mean of Accuracies for Time Domain is: ', np.mean(accuracies))\n",
        "print('SD of Accuracies for Frequency Domain is: ', np.std(accuracies))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_tYOuyfb7bKt",
        "outputId": "14d943bb-b1d8-496a-d776-be807c1a01c6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1471: UndefinedMetricWarning: Recall is ill-defined and being set to 0.0 due to no true samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Accuracy: 0.52\n",
            "Mean of Accuracies for Time Domain is:  0.5166666666666666\n",
            "SD of Accuracies for Frequency Domain is:  0.3370624736026114\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/metrics/_classification.py:1471: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.\n",
            "  _warn_prf(average, modifier, msg_start, len(result))\n"
          ]
        }
      ]
    }
  ]
}