Approach_3_ryan's_nn_attempt.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Approach 3: ryan's nn attempt.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "CZ_luYEyhNva",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3d9131ef-a431-460a-fea1-75e25ee1e05f"
      },
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from torch.utils.data import DataLoader\n",
        "from torch.utils.data import TensorDataset\n",
        "\n",
        "from torch import optim, nn\n",
        "from torch.nn import CrossEntropyLoss\n",
        "import torch.nn.functional as F\n",
        "from numpy import genfromtxt\n",
        "from google.colab import drive\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from sklearn.cluster import KMeans\n",
        "from sklearn.impute import KNNImputer\n",
        "from sklearn.model_selection import TimeSeriesSplit\n",
        "import lightgbm as lgb\n",
        "\n",
        "\n",
        "import copy\n",
        "%matplotlib inline\n",
        "\n",
        "rng = 0\n",
        "\n",
        "drive.mount('/content/gdrive')\n",
        "%cd /content/gdrive/My\\ Drive/Colab\\ Notebooks"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/gdrive; to attempt to forcibly remount, call drive.mount(\"/content/gdrive\", force_remount=True).\n",
            "/content/gdrive/My Drive/Colab Notebooks\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r7RY3DCi4ssb"
      },
      "source": [
        "Load data   \n",
        "Split the dataset by city,drop 'week_start_date' since we don't need such fine-grained time data .  \n",
        "Check missing data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V0ciUQqAfO7U",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb853312-f416-4a56-f4f0-3ea1799d57be"
      },
      "source": [
        "train_features = pd.read_csv(\"./dengue_features_train.csv\")\n",
        "train_labels = pd.read_csv(\"./dengue_labels_train.csv\")\n",
        "test_features=pd.read_csv(\"./dengue_features_test.csv\")\n",
        "\n",
        "sj_train_features=train_features[train_features.city=='sj']\n",
        "sj_train_features.drop(['city','week_start_date'],axis=1, inplace=True)\n",
        "\n",
        "sj_train_labels=train_labels[train_labels.city=='sj']\n",
        "sj_train_labels.drop(['city','year','weekofyear'],axis=1, inplace=True)\n",
        "\n",
        "print('\\n San Juan any nulls?')\n",
        "print(pd.isnull(sj_train_features).any())\n",
        "print(pd.isna(sj_train_features).any())\n",
        "print(pd.isnull(sj_train_labels).any())\n",
        "print(pd.isna(sj_train_labels).any())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            " San Juan any nulls?\n",
            "year                                     False\n",
            "weekofyear                               False\n",
            "ndvi_ne                                   True\n",
            "ndvi_nw                                   True\n",
            "ndvi_se                                   True\n",
            "ndvi_sw                                   True\n",
            "precipitation_amt_mm                      True\n",
            "reanalysis_air_temp_k                     True\n",
            "reanalysis_avg_temp_k                     True\n",
            "reanalysis_dew_point_temp_k               True\n",
            "reanalysis_max_air_temp_k                 True\n",
            "reanalysis_min_air_temp_k                 True\n",
            "reanalysis_precip_amt_kg_per_m2           True\n",
            "reanalysis_relative_humidity_percent      True\n",
            "reanalysis_sat_precip_amt_mm              True\n",
            "reanalysis_specific_humidity_g_per_kg     True\n",
            "reanalysis_tdtr_k                         True\n",
            "station_avg_temp_c                        True\n",
            "station_diur_temp_rng_c                   True\n",
            "station_max_temp_c                        True\n",
            "station_min_temp_c                        True\n",
            "station_precip_mm                         True\n",
            "dtype: bool\n",
            "year                                     False\n",
            "weekofyear                               False\n",
            "ndvi_ne                                   True\n",
            "ndvi_nw                                   True\n",
            "ndvi_se                                   True\n",
            "ndvi_sw                                   True\n",
            "precipitation_amt_mm                      True\n",
            "reanalysis_air_temp_k                     True\n",
            "reanalysis_avg_temp_k                     True\n",
            "reanalysis_dew_point_temp_k               True\n",
            "reanalysis_max_air_temp_k                 True\n",
            "reanalysis_min_air_temp_k                 True\n",
            "reanalysis_precip_amt_kg_per_m2           True\n",
            "reanalysis_relative_humidity_percent      True\n",
            "reanalysis_sat_precip_amt_mm              True\n",
            "reanalysis_specific_humidity_g_per_kg     True\n",
            "reanalysis_tdtr_k                         True\n",
            "station_avg_temp_c                        True\n",
            "station_diur_temp_rng_c                   True\n",
            "station_max_temp_c                        True\n",
            "station_min_temp_c                        True\n",
            "station_precip_mm                         True\n",
            "dtype: bool\n",
            "total_cases    False\n",
            "dtype: bool\n",
            "total_cases    False\n",
            "dtype: bool\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/pandas/core/frame.py:4174: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  errors=errors,\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "529DeE9o6Xt8"
      },
      "source": [
        "## Classification"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qx1JzDNa56fT"
      },
      "source": [
        "We want to divide the categories based on quartiles. Because quartiles can help us identify different levels of data and outliers. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "4FJVkFOb5rHL",
        "outputId": "359912b3-49d4-45e2-b8f5-539d892477f6"
      },
      "source": [
        "sj_train_labels.describe()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>total_cases</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>count</th>\n",
              "      <td>936.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mean</th>\n",
              "      <td>34.180556</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>std</th>\n",
              "      <td>51.381372</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>min</th>\n",
              "      <td>0.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>25%</th>\n",
              "      <td>9.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>50%</th>\n",
              "      <td>19.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>75%</th>\n",
              "      <td>37.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>max</th>\n",
              "      <td>461.000000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "       total_cases\n",
              "count   936.000000\n",
              "mean     34.180556\n",
              "std      51.381372\n",
              "min       0.000000\n",
              "25%       9.000000\n",
              "50%      19.000000\n",
              "75%      37.000000\n",
              "max     461.000000"
            ]
          },
          "metadata": {},
          "execution_count": 97
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JvEcpN_86nzb"
      },
      "source": [
        "Draw graphs to see the distribution of totol_cases.   \n",
        "We can see that most of the data are between 0-50. And in the box plot, data points greater than upper edge are outliers. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 352
        },
        "id": "6X24B4yaaI2j",
        "outputId": "e0b1c092-22b2-493a-efae-ac551fffe60e"
      },
      "source": [
        " _, axs = plt.subplots(1, 2,figsize=(20, 5))\n",
        "sns.histplot(x=sj_train_labels['total_cases'],kde=False,color='#65b87b', alpha=.7,ax=axs[0])\n",
        "sns.boxplot(x=sj_train_labels['total_cases'],color='#6fb9bd',ax=axs[1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7fa5670e58d0>"
            ]
          },
          "metadata": {},
          "execution_count": 98
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABJIAAAE+CAYAAADWCzotAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dfbRlZX0n+O8PKoDRDCBUA/JW2CBZJpO0rtIY7ZQIdgc6dpDVLhpBRC0bG0tMQlAxZg0zI2ZpksFELB1RaZB2NLSRliSSjPJWmRjR8oUqFEkqagUIBSUCiUYgRT3zxz1V3rqv+9atc/apqs9nrbPuOc9+9vP8zt6nuJvv3Xufaq0FAAAAAOazT98FAAAAALB7ECQBAAAA0IkgCQAAAIBOBEkAAAAAdCJIAgAAAKATQRIAAAAAnSzpu4DFOPTQQ9uyZcv6LgMAGJKvfOUr32utLe27DnbkGAwA9mxzHYPt1kHSsmXLsnbt2r7LAACGpKo29l0D0zkGA4A921zHYC5tAwAAAKATQRIAAAAAnQiSAAAAAOhEkAQAAABAJ4IkAAAAADoRJAEAAADQiSAJAAAAgE4ESQAAAAB0IkgCAAAAoBNBEgAAAACdCJIAAAAA6GRJ3wXsblZddGE2P/rQtPalBx6S1Zdf0UNFAAAAAKMhSFqgzY8+lBWrTpvWvmb1jT1UAwAAADA6Lm0DAAAAoBNBEgAAAACdCJIAAAAA6GRoQVJVXVVVD1bVnVPaL6yqb1XVN6rqdye1v72qNlTV3VX1y8OqCwAAAICdM8ybbV+d5P1JPratoapekuT0JD/fWnu8qv7VoP3ZSc5K8jNJnpHk81X1rNbak0OsDwAAAIAFGNoZSa21NUm+P6X5giTvbq09Pujz4KD99CSfbK093lr7TpINSZ4/rNoAAAAAWLhR3yPpWUl+qapur6rbqup5g/Yjk9wzqd+9gzYAAAAAxsQwL22bbb6nJ3lBkuclua6qnrmQAarq/CTnJ8kxxxyzywsEAAAAYGajPiPp3iSfbhO+lGRrkkOT3Jfk6En9jhq0TdNau7K1try1tnzp0qVDLxgAAACACaMOkv5nkpckSVU9K8l+Sb6X5IYkZ1XV/lV1XJITknxpxLUBAAAAMIehXdpWVZ9IclKSQ6vq3iSXJrkqyVVVdWeSJ5Kc11prSb5RVdcl+WaSLUlW+cY2AAAAgPEytCCptfbKWRa9apb+70ryrmHVAwDA7u/aa6/Nxo0b5+23adOmJMnhhx++6DmPPfbYnHvuuYseBwD2BKO+2TYAAOy0jRs35lsbNmS/gw6es98TP/hBkuSfv/fQouZ74pGHF7U+AOxpBEkAAOxW9jvo4Bz+klPm7LPplpuSZN5+89k2DgAwYdQ32wYAAABgNyVIAgAAAKATQRIAAAAAnQiSAAAAAOhEkAQAAABAJ4IkAAAAADoRJAEAAADQiSAJAAAAgE4ESQAAAAB0IkgCAAAAoBNBEgAAAACdCJIAAAAA6GRJ3wXsKdavW5czV569Q9vSAw/J6suv6KkiAAAAgF1LkLSLbN2nZcWq03ZoW7P6xp6qAQAAANj1XNoGAAAAQCeCJAAAAAA6ESQBAAAA0IkgCQAAAIBOBEkAAAAAdCJIAgAAAKATQRIAAAAAnQwtSKqqq6rqwaq6c4Zlv1lVraoOHbyuqnpfVW2oqnVV9dxh1QUAAADAzhnmGUlXJzl1amNVHZ3k3yf5+0nNpyU5YfA4P8kHh1gXAAAAADthaEFSa21Nku/PsOi9Sd6apE1qOz3Jx9qELyY5qKqOGFZtAAAAACzcSO+RVFWnJ7mvtXbHlEVHJrln0ut7B20AAAAAjIklo5qoqn4yyW9l4rK2xYxzfiYuf8sxxxyzCyoDAAAAoItRnpH0r5Mcl+SOqvpukqOSfLWqDk9yX5KjJ/U9atA2TWvtytba8tba8qVLlw65ZAAAAAC2GVmQ1Fpb31r7V621Za21ZZm4fO25rbVNSW5I8urBt7e9IMmjrbX7R1UbAAAAAPMbWpBUVZ9I8tdJTqyqe6tq5RzdP5vk20k2JPlwkjcOqy4AAAAAds7Q7pHUWnvlPMuXTXrekqwaVi0AAAAALN5Iv7UNAAAAgN2XIAkAAACATgRJAAAAAHQiSAIAAACgE0ESAAAAAJ0IkgAAAADoRJAEAAAAQCeCJAAAAAA6ESQBAAAA0IkgCQAAAIBOBEkAAAAAdCJIAgAAAKATQRIAAAAAnQiSAAAAAOhEkAQAAABAJ0v6LmBcrbrowmx+9KFp7XfdfVdW5LQeKgIAAADolyBpFpsffSgrVk0PjO644I4eqgEAAADon0vbAAAAAOhEkAQAAABAJ4IkAAAAADoRJAEAAADQiSAJAAAAgE6GFiRV1VVV9WBV3Tmp7feq6ltVta6qrq+qgyYte3tVbaiqu6vql4dVFwAA4+naa6/Ntdde23cZux3bDYBRGuYZSVcnOXVK2+eS/Gxr7eeS/E2StydJVT07yVlJfmawzgeqat8h1gYAwJjZuHFjNm7c2HcZux3bDYBRGlqQ1Fpbk+T7U9r+39balsHLLyY5avD89CSfbK093lr7TpINSZ4/rNoAAAAAWLg+75H0uiQ3Dp4fmeSeScvuHbQBAAAAMCZ6CZKq6h1JtiT5+E6se35Vra2qtZs3b971xQEAAAAwo5EHSVX1miQvS3JOa60Nmu9LcvSkbkcN2qZprV3ZWlveWlu+dOnSodYKAAAAwI+NNEiqqlOTvDXJr7bW/nnSohuSnFVV+1fVcUlOSPKlUdYGAAAAwNyWDGvgqvpEkpOSHFpV9ya5NBPf0rZ/ks9VVZJ8sbX2X1tr36iq65J8MxOXvK1qrT05rNoAAAAAWLihBUmttVfO0PzROfq/K8m7hlUPAAAAAIvT57e2AQAAALAbESQBAAAA0IkgCQAAAIBOBEkAAAAAdCJIAgAAAKATQRIAAAAAnQiSAAAAAOhEkAQAAABAJ4IkAAAAADoRJAEAAADQiSAJAAAAgE4ESQAAAAB0IkgCAAAAoBNBEgAAAACdCJIAAAAA6ESQBAAAAEAngiQAAAAAOhEkAQAAANCJIAkAAACATgRJAAAAAHQiSAIAAACgE0ESAAAAAJ0MLUiqqquq6sGqunNS29Or6nNV9beDnwcP2quq3ldVG6pqXVU9d1h1AQAAALBzhnlG0tVJTp3SdkmSm1prJyS5afA6SU5LcsLgcX6SDw6xLgAAAAB2wtCCpNbamiTfn9J8epJrBs+vSfLySe0faxO+mOSgqjpiWLUBAAAAsHCjvkfSYa21+wfPNyU5bPD8yCT3TOp376ANAAAAgDHR2822W2stSVvoelV1flWtraq1mzdvHkJlAAAAAMxk1EHSA9suWRv8fHDQfl+Soyf1O2rQNk1r7crW2vLW2vKlS5cOtVgAAAAAfmzUQdINSc4bPD8vyWcmtb968O1tL0jy6KRL4AAAAAAYA0uGNXBVfSLJSUkOrap7k1ya5N1JrquqlUk2Jjlz0P2zSf5Dkg1J/jnJa4dVFwAAAAA7Z2hBUmvtlbMsOmWGvi3JqmHVAgAAAMDi9XazbQAAAAB2L4IkAAAAADrpFCRV1Yu6tAEAAACw5+p6RtIVHdsAAAAA2EPNebPtqvrFJC9MsrSqLpq06H9Jsu8wCwMAAABgvMz3rW37JXnaoN9PTWr/xySvGFZRAAAAAIyfOYOk1tptSW6rqqtbaxtHVBMAAAAAY2i+M5K22b+qrkyybPI6rbWTh1EUAAAAAOOna5D0P5L830k+kuTJ4ZUDAAAAwLjqGiRtaa19cKiVAAAAADDW9unY70+q6o1VdURVPX3bY6iVAQAAADBWugZJ5yV5S5IvJPnK4LF2WEUBAAAL893vfjcrV67MxRdfnNe97nW5+OKL89rXvjave93rsnHjxPfmrFu3Lq961aty8cUX521ve1tWrly5fdlkDz/8cN75zndm48aNecc73pGVK1fmzjvvzDvf+c6sX78+r3/967e/fuSRR5IkX/jCF3LOOefki1/8Yh5++OFceumlufTSS/PII49sH29b36lzXXLJJTnnnHNy0UUXZeXKlVm/fv0O/SfXs6193bp1Oeecc/KWt7xl+zwzjT25jsljzdR/PjONN1u/qfXON27XmhY69lzjdHkvozLfZ2S+97qY/bqY9Rc772Lm2tVzzzbeTO27Yu4+tnlfn5Nh6LOWTkFSa+24GR7PHHZxAABANx/4wAfy2GOP5f7778/jjz+e+++/P0888UQef/zxrF69Okny/ve/P6213H///bn33nvz2GOPbV822fXXX5+77747q1evzne/+9089thjed/73pe77747V1xxRX70ox9tf3399dcnST70oQ8lST74wQ/m+uuvz4YNG7Jhw4Zcf/3128fb1nfqXPfcc0+S5IEHHshjjz2WK664Yof+k+vZ1v7+978/SfIP//AP2+eZaezJdUwea6b+85lpvNn6Ta13vnG71rTQsecap8t7GZX5PiPzvdfF7NfFrL/YeRcz166ee7bxZmrfFXP3sc37+pwMQ5+1dAqSqurVMz2GXRwAADC/H/3oR7nvvvtmXX7ffffl85//fH74wx/OuGzyWUkPP/xw1qxZk9baDmP+8Ic/TGtt+xjbXq9Zsyaf//zns2XLliTJli1bcvPNN29f79Zbb90+3po1a6ad1XDbbbdNq2ny2Bs3btyhntZabr311mnv5bbbbptz7Ntuu22HsabWMp+Zxpvt7Jmp9c411+T+89W00LHnG2e+9zIqc22DLttnIdtwofMPY72dMXWuxXyWu4w/+aynqe274n33sc37+pwMQ9+1dL3Z9vMmPT8gySlJvprkY7u8IgAA9kqbNm3K448/nssuu2zWPhs3bsyW1kZW05Yf/FM2/vAHc9bUt40bN+axxx6bt9/VV18967LVq1fnd3/3d5NM/JW7LWAbb926ddrYk9ffsmVLqmp73+uvvz6vfe1rt8+1LYCabezVq1dPq2emdbZs2TJt7CeffHKH5ZPHmlrLfGYab6b1Z9p+c801uf98NS107Lney+RtONt7GZW5tkGX7bOQbbjQ+Yex3s6YOtdiPstdxt823kztrbVFz93HNu/rczIMfdfS9dK2Cyc9/kuS5yZ52nBLAwBgXFTV+VW1tqrWbt68ue9ymGLr1q3z9pkrHJp85tEXvvCFOcOdqbZs2TJv8LRt+ZYtW/JXf/VXO8w139j33Xdfp3paa9PGnlzXtrN4Jp85Nbn/fGYab6b1Z9p+c801uf98NS107LnG6fJeRmWubdBl+yxkGy50/mGstzOmzrWYz3KX8beNN1P7rnjffWzzvj4nw9B3LV3PSJrqh0mO25WFAAAwvlprVya5MkmWL18+lFOCDj/88CTJb//2b8/a57LLLsu3v/fQMKaf0ZKn/VSOPfSQOWvq22WXXZa/+7u/yxNPPDFnv6qaNfA58sgjtz9/4QtfmNtuu61zmLRkyZI8+eSTc4ZJ2+ZesmRJXvSiF+0w10033TTn2IcddlgeeOCBeeupqmlj33zzzdvrqqo84xnP2D7W1FrmM9N4M60/0/aba67J/eeraaFjL/a9jMpc26DL9lnINlzo/MNYb2dMnWvyv4tdMfds72Wm9tbaot93H9u8r8/JMPRdS9d7JP1JVd0wePxZkruT9H93qTG3ft26nLny7GmPVRdd2HdpAADsQZ7xjGfM2+c1r3nNrMtWrVq1/fkZZ5yx/VK0LvbZZ59pY09ef8mSJVmyZMn2vmecccYOc21bNtvYq1atmlbPTOssWbJk2tj77rvvDssnjzW1lvnMNN5M68+0/eaaa3L/+Wpa6NhzjTN5G872XkZlrm3QZfssZBsudP5hrLczps61mM9yl/G3jTdT+654331s874+J8PQdy2dgqQkv5/k/xo8fifJitbaJUOrag+xdZ+WFatOm/bY/Ojo/ooGAMCe7ylPecoOZxVNdeSRR+alL31pnvrUp8647Nhjj93++uCDD86KFStSVTuM+dSnPjVVtX2Mba9XrFiRl770pduDiSVLluTkk0/evt5JJ520fbwVK1bkoIMO2mGuF7/4xdNqmjz2scceu0M9VZWTTjpp2nt58YtfPOfYL37xi3cYa2ot85lpvJnWn7r95ptrcv/5alro2PONM997GZW5tkGX7bOQbbjQ+Yex3s6YOtdiPstdxt823kztu+J997HN+/qcDEPftXS9R9JtSb6V5KeSHJxk7vNmAQCAkXrjG9+YAw44IEcccUT233//HHHEEdlvv/2y//77bz/j6E1velOqKkcccUSOOuqoHHDAATucjbTNGWeckRNPPDGrVq3KsmXLcsABB+TNb35zTjzxxFx44YV5ylOesv31tr+Ev+ENb0iSXHDBBTnjjDNy/PHH5/jjj99+BsPkvlPnOvroo5Mkhx12WA444IBceOGFO/SfXM+29je96U1JJs7G2jbPTGNPrmPyWDt7FsXU8WbrN7Xe+cbtWtNCx55rnC7vZVTm+4zM914Xs18Xs/5i513MXLt67tnGm6l9V8zdxzbv63MyDH3WUl2+kaGqzkzye0luTVJJfinJW1prnxpqdfNYvnx5W7t27VDGPnPl2Vmx6rRp7Vdc8O5c+MHpJ2PN1D5b3zWrb8x1H/1/dl2xALCHqqqvtNaW910HOxrWMdi2b0brco+kw19yypxjbbpl4r478/Wbz6Zbbsozd4N7JCVzbzcAWIi5jsG63mz7HUme11p7cDDg0iSfT9JrkAQAAADA6HS9R9I+20KkgYcWsO40VfUbVfWNqrqzqj5RVQdU1XFVdXtVbaiqP6qq/XZ2fAAAAAB2va5h0J9X1V9U1Wuq6jVJ/izJZ3dmwqo6Msmbkyxvrf1skn2TnJXkPUne21o7PsnDSVbuzPgAAAAADMecQVJVHV9VL2qtvSXJh5L83ODx10muXMS8S5I8paqWJPnJJPcnOTk/vlTumiQvX8T4AAAAAOxi852R9AdJ/jFJWmufbq1d1Fq7KMn1g2UL1lq7L8nvJ/n7TARIjyb5SpJHWmtbBt3uTTL795cCAAAAMHLzBUmHtdbWT20ctC3bmQmr6uAkpyc5Lskzkjw1yakLWP/8qlpbVWs3b968MyUAAAAAsBPmC5IOmmPZU3Zyzpcm+U5rbXNr7V+SfDrJi5IcNLjULUmOSnLfTCu31q5srS1vrS1funTpTpYAAAAAwEItmWf52qr6L621D09urKrXZ+JytJ3x90leUFU/meRHSU5JsjbJLUlekeSTSc5L8pmdHH/srV+3LmeuPHta+9IDD8nqy6/ooSIAAACA+c0XJP16kuur6pz8ODhanmS/JGfszISttdur6lNJvppkS5KvZeLG3X+W5JNVddmg7aM7M/7uYOs+LStWnTatfc3qG3uoBgAAAKCbOYOk1toDSV5YVS9J8rOD5j9rrd28mElba5cmuXRK87eTPH8x4wIAAAAwPPOdkZQkaa3dkolLzwAAAADYS813s20AAAAASCJIAgAAAKAjQRIAAAAAnXS6RxKjsX7dupy58uwd2pYeeEhWX35FTxUBAAAA/JggaYxs3adlxarTdmhbs/rGnqoBAAAA2JFL2wAAAADoRJAEAAAAQCeCJAAAAAA6ESQBAAAA0IkgCQAAAIBOBEkAAAAAdCJIAgAAAKATQRIAAAAAnQiSAAAAAOhEkAQAAABAJ4IkAAAAADoRJAEAAADQiSAJAAAAgE4ESQAAAAB0IkgCAAAAoBNBEgAAAACd9BIkVdVBVfWpqvpWVd1VVb9YVU+vqs9V1d8Ofh7cR20AAAAAzKyvM5L+MMmft9Z+OsnPJ7krySVJbmqtnZDkpsFrAAAAAMbEyIOkqjowyYokH02S1toTrbVHkpye5JpBt2uSvHzUtQEAAAAwuz7OSDouyeYk/62qvlZVH6mqpyY5rLV2/6DPpiSH9VAbAAAAALPoI0hakuS5ST7YWntOkh9mymVsrbWWpM20clWdX1Vrq2rt5s2bh14sAAAAABP6CJLuTXJva+32wetPZSJYeqCqjkiSwc8HZ1q5tXZla215a2350qVLR1IwAAAAAD0ESa21TUnuqaoTB02nJPlmkhuSnDdoOy/JZ0ZdGwAAAACzW9LTvBcm+XhV7Zfk20lem4lQ67qqWplkY5Ize6oNAAAAgBn0EiS11r6eZPkMi04ZdS0AAAAAdNPHPZIAAAAA2A0JkgAAAADoRJAEAAAAQCeCJAAAAAA6ESQBAAAA0IkgCQAAAIBOBEkAAAAAdLKk7wIAACBJjj322L5L2C3ZbgCMkiAJAICxcO655/Zdwm7JdgNglFzaBgAAAEAngiQAAAAAOhEkAQAAANCJIAkAAACATgRJAAAAAHQiSAIAAACgE0ESAAAAAJ0IkgAAAADoRJAEAAAAQCeCJAAAAAA6ESQBAAAA0IkgCQAAAIBOBEkAAAAAdCJIAgAAAKCT3oKkqtq3qr5WVX86eH1cVd1eVRuq6o+qar++agMAAABguj7PSPq1JHdNev2eJO9trR2f5OEkK3upCgAAAIAZ9RIkVdVRSX4lyUcGryvJyUk+NehyTZKX91EbAAAAADPr64ykP0jy1iRbB68PSfJIa23L4PW9SY7sozAAAAAAZjbyIKmqXpbkwdbaV3Zy/fOram1Vrd28efMurg4AAACA2fRxRtKLkvxqVX03ySczcUnbHyY5qKqWDPocleS+mVZurV3ZWlveWlu+dOnSUdQLAAAAQHoIklprb2+tHdVaW5bkrCQ3t9bOSXJLklcMup2X5DOjrg0AAACA2S2Zv8vIvC3JJ6vqsiRfS/LRnusZC+vXrcuZK8+e1r70wEOy+vIreqgIAAAA2Fv1GiS11m5Ncuvg+beTPL/PesbR1n1aVqw6bVr7mtU39lANAAAAsDfr61vbAAAAANjNCJIAAAAA6ESQBAAAAEAngiQAAAAAOhEkAQAAANCJIAkAAACATgRJAAAAAHQiSAIAAACgE0ESAAAAAJ0IkgAAAADoRJAEAAAAQCeCJAAAAAA6ESQBAAAA0MmSvgtg56xfty5nrjx7WvvSAw/J6suv6KEiAAAAYE8nSNpNbd2nZcWq06a1r1l9Yw/VAAAAAHsDl7YBAAAA0IkzkvYwM13ytuFbf5Pjf/pZ0/q6DA4AAABYCEHSHmamS97uuOAOl8EBAAAAi+bSNgAAAAA6ESQBAAAA0IkgCQAAAIBOBEkAAAAAdDLyIKmqjq6qW6rqm1X1jar6tUH706vqc1X1t4OfB4+6NgAAAABm18cZSVuS/GZr7dlJXpBkVVU9O8klSW5qrZ2Q5KbBawAAAADGxMiDpNba/a21rw6e/1OSu5IcmeT0JNcMul2T5OWjrg0AAACA2fV6j6SqWpbkOUluT3JYa+3+waJNSQ7rqSwAAAAAZrCkr4mr6mlJ/jjJr7fW/rGqti9rrbWqarOsd36S85PkmGOOGUWpe51VF12YzY8+NK196YGHZPXlV/RQEQAAADAOegmSquonMhEifby19ulB8wNVdURr7f6qOiLJgzOt21q7MsmVSbJ8+fIZwyYWZ/OjD2XFqtOmta9ZfWMP1QAAAADjoo9vbaskH01yV2vt8kmLbkhy3uD5eUk+M+raAAAAAJhdH2ckvSjJuUnWV9XXB22/leTdSa6rqpVJNiY5s4faAAAYc0888nA23XLTvH2SzNuvy1w59JBFjQEAe5KRB0mttf8vSc2y+JRR1rK3W79uXc5cefa09rvuvisrMv3SNgCAvh177LGd+m3a8i9JksMXGwIdekjnOQFgb9Dbzbbp39Z92oz3Qrrjgjt6qAYAYH7nnntu3yUAwF5NkERnM53B5JvcAAAAYO8hSKKzmc5g8k1uAAAAsPcY+be2AQAAALB7EiQBAAAA0IkgCQAAAIBOBEkAAAAAdCJIAgAAAKATQRIAAAAAnSzpuwB2b+vXrcuZK8+e1r70wEOy+vIreqgIAAAAGBZBEouydZ+WFatOm9a++g3vETABAADAHkaQxFDMFjCtWX1jD9UAAAAAu4J7JAEAAADQiSAJAAAAgE4ESQAAAAB04h5JMMmqiy7M5kcf2qHNDcIBAABggiAJJtn86EPTbhLuBuEAAAAwQZAEO2mms5cSZzABAACw5xIkMVLr163LmSvP3qFtdw1eZjp7KXEGEwAAAHsuQRIjtXWf5tIxAAAA2E0Jkhhbs106tuFbf5Pjf/pZ87Ylu+/ZTgAAADCOBEmMrdkuHbvjgjumtc/UliSr3/CeaZfSJQImAAAA2BljFyRV1alJ/jDJvkk+0lp7d88lsRub6VK6xOV0AAAAsDPGKkiqqn2TrE7y75Lcm+TLVXVDa+2b/VbGMM10A+4kuevuu7Ii00OgUdsV9e2Kb3hb6Bgz9d9VZ2LtirGHWR97Lt+WCAAA/RqrICnJ85NsaK19O0mq6pNJTk8iSNqDzXbW0B0X3NFDNdPtivpmu0xvIZfeLfRb4mbqP1vfhf7P+ULGns2uGGNXWEigtZD7ds01Ttc6+hhjIWMP895ks72Xu+6+K29430XT2hfy2RmXbT1O4fBCjEsdAAD0Y9yCpCOT3DPp9b1JfqGnWmDoxuXSu4WGVHuShQRaC7lv11zjLGTsUY+xkLF3xfteyHzb5hzW2OO+v8YlfB2XOgAA6Ee11vquYbuqekWSU1trrx+8PjfJL7TW3jSpz/lJzh+8PDHJ3UMq59Ak3xvS2Cyc/TFe7I/xYn+MF/tj1zq2tba07yLYUVVtTrJxSMP7NzRe7I/xYn+MF/tjvNgfu9asx2DjdkbSfUmOnvT6qEHbdq21K5NcOexCqmpta235sOehG/tjvNgf48X+GC/2B3uDYYZ7/g2NF/tjvNgf48X+GC/2x+js03cBU3w5yQlVdVxV7ZfkrCQ39FwTAAAAABmzM5Jaa1uq6k1J/iLJvkmuaq19o+eyAAAAAMiYBUlJ0lr7bJLP9l1HRnD5HAtif4wX+2O82B/jxf6AxfFvaLzYH+PF/hgv9sd4sT9GZKxutg0AAADA+Bq3eyQBAAAAMKYESTOoqlOr6u6q2lBVl/Rdz96gqq6qqger6s5JbU+vqs9V1d8Ofh48aK+qet9g/6yrqiA9s8wAAAdVSURBVOf2V/meqaqOrqpbquqbVfWNqvq1Qbt90oOqOqCqvlRVdwz2x/8xaD+uqm4fbPc/GnxJQapq/8HrDYPly/qsf09UVftW1deq6k8Hr+0LWCTHX/1wDDY+HH+NF8df48kx2HgQJE1RVfsmWZ3ktCTPTvLKqnp2v1XtFa5OcuqUtkuS3NRaOyHJTYPXycS+OWHwOD/JB0dU495kS5LfbK09O8kLkqwa/DuwT/rxeJKTW2s/n+TfJDm1ql6Q5D1J3ttaOz7Jw0lWDvqvTPLwoP29g37sWr+W5K5Jr+0LWATHX726Oo7BxoXjr/Hi+Gs8OQYbA4Kk6Z6fZENr7duttSeSfDLJ6T3XtMdrra1J8v0pzacnuWbw/JokL5/U/rE24YtJDqqqI0ZT6d6htXZ/a+2rg+f/lIn/WB8Z+6QXg+36g8HLnxg8WpKTk3xq0D51f2zbT59KckpV1YjK3eNV1VFJfiXJRwavK/YFLJbjr544Bhsfjr/Gi+Ov8eMYbHwIkqY7Msk9k17fO2hj9A5rrd0/eL4pyWGD5/bRCA1OA31Okttjn/RmcBrv15M8mORzSf4uySOttS2DLpO3+fb9MVj+aJJDRlvxHu0Pkrw1ydbB60NiX8Bi+T0yXvy+75njr/Hg+GvsOAYbE4Ikdgtt4usFfcXgiFXV05L8cZJfb6394+Rl9slotdaebK39myRHZeIv9z/dc0l7pap6WZIHW2tf6bsWgFHw+370HH+ND8df48Mx2HgRJE13X5KjJ70+atDG6D2w7fTcwc8HB+320QhU1U9k4iDm4621Tw+a7ZOetdYeSXJLkl/MxCnsSwaLJm/z7ftjsPzAJA+NuNQ91YuS/GpVfTcTl96cnOQPY1/AYvk9Ml78vu+J46/x5PhrLDgGGyOCpOm+nOSEwd3f90tyVpIbeq5pb3VDkvMGz89L8plJ7a8efFPFC5I8Oul0X3aBwfXDH01yV2vt8kmL7JMeVNXSqjpo8PwpSf5dJu6bcEuSVwy6Td0f2/bTK5LcPPgLJovUWnt7a+2o1tqyTPx+uLm1dk7sC1gsx1/jxe/7Hjj+Gi+Ov8aLY7DxUrbldFX1HzJx/eW+Sa5qrb2r55L2eFX1iSQnJTk0yQNJLk3yP5Ncl+SYJBuTnNla+/7gl+z7M/ENI/+c5LWttbV91L2nqqp/m+Qvk6zPj69B/q1MXKdvn4xYVf1cJm4WuG8m/gBwXWvt/6yqZ2biLzJPT/K1JK9qrT1eVQckuTYT91b4fpKzWmvf7qf6PVdVnZTk4tbay+wLWDzHX/1wDDY+HH+NF8df48sxWP8ESQAAAAB04tI2AAAAADoRJAEAAADQiSAJAAAAgE4ESQAAAAB0IkgCAAAAoBNBEgAAAACdCJKARamqg6rqjfP0WVZVZ3cYa1lV3bnrqgMA2DM5BgP6IkgCFuugJHMexCRZlmTegxgAADpzDAb0QpAELNa7k/zrqvp6Vf3e4HFnVa2vqv88qc8vDfr8xuCvXn9ZVV8dPF7YZaKq2reqfn8w/rqqunDQ/r9V1ZcH7VdWVQ3a31xV3xz0/eSg7alVdVVVfamqvlZVpw/af2bQ9vVB/xN2+ZYCANh1HIMBvajWWt81ALuxqlqW5E9baz9bVf8pyX9NcmqSQ5N8OckvJDkxycWttZcN1vnJJFtba48NDhY+0VpbPnmsWea6IMkpSc5qrW2pqqe31r6/7eegz7VJrmut/UlV/UOS41prj1fVQa21R6rqd5J8s7X236vqoCRfSvKcTBxofbG19vGq2i/Jvq21Hw1hkwEALJpjMKAvzkgCdqV/m4kDkidbaw8kuS3J82bo9xNJPlxV65P8jyTP7jj+S5N8qLW2JUm2HbgkeUlV3T4Y7+QkPzNoX5fk41X1qiRbBm3/PsklVfX1JLcmOSDJMUn+OslvVdXbkhzrAAYA2I04BgNGZknfBQB7pd9I8kCSn89EoP3Yzg5UVQck+UCS5a21e6rqf8/EgUmS/EqSFUn+Y5J3VNX/mqSS/KfW2t1Thrqrqm4frPPZqnpDa+3mna0LAGAMOQYDFs0ZScBi/VOSnxo8/8sk/3lwHf3STBxAfGlKnyQ5MMn9rbWtSc5Nsm/HuT6X5A1VtSRJqurp+fEBy/eq6mlJXjFYtk+So1trtyR522DOpyX5iyQXTrqG/zmDn89M8u3W2vuSfCbJzy1oKwAAjJZjMKAXzkgCFqW19lBV/VVNfGXsjZk4lfmOJC3JW1trm6rqoSRPVtUdSa7OxF+v/riqXp3kz5P8sON0H0nyrCTrqupfkny4tfb+qvpwkjuTbMrEPQGSiQOj/15VB2biL2DvG1yf/84kfzAYY58k30nysiRnJjl3MO6mJL+ziM0CADBUjsGAvrjZNgAAAACduLQNAAAAgE5c2gaMnar65STvmdL8ndbaGX3UAwCwN3AMBnTh0jYAAAAAOnFpGwAAAACdCJIAAAAA6ESQBAAAAEAngiQAAAAAOhEkAQAAANDJ/w813YjTqo6Y5wAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 1440x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jYuRVvBO7rMP"
      },
      "source": [
        "We calculate the upper edge using quartiles. Upper edge is the non-anomalous maximum.  \n",
        "We think that data should be ranged as (lower edge,q1),(q1,q3),(q3,upper edge),(upper edge,).These categories correspond to lower values, intermediate values, higher values, and outliers.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4IMoFqHgaI7-"
      },
      "source": [
        "#In boxplot, data is divided by: lower--q1--(q2)--q3--upper---\n",
        "q1=9\n",
        "q2=19\n",
        "q3=37\n",
        "lower=q1-(1.5*(q3-q1)) if q1-(1.5*(q3-q1))>0 else 0 #Non-anomalous minimum,lower edge of boxplot\n",
        "upper=q3+(1.5*(q3-q1)) #Non-anomalous maximum,upper edge of boxplot. outlier= data > upper"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YELhVrzTxNer"
      },
      "source": [
        "Logic by using a static algorithm to sort the labels into range_groups"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zUFw8Ae1rD0N"
      },
      "source": [
        "def get_range_group_from_cases(cases):\n",
        "    if cases<q1:\n",
        "        return 0\n",
        "    elif cases<q3:\n",
        "        return 1\n",
        "    elif cases <upper:\n",
        "        return 2\n",
        "    else:\n",
        "        return 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5lPkflF0KEDo"
      },
      "source": [
        "Knn imputer to impute missing features to values closer to them of the same cluster.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wZaMqDxSJ0xN"
      },
      "source": [
        "knnImputer = KNNImputer(n_neighbors=4,\n",
        "                        weights=\"distance\",\n",
        "                        copy=False)\n",
        "sj_train_features = knnImputer.fit_transform(sj_train_features)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4IZ1Jrv187U-"
      },
      "source": [
        "After preprocessing,transform data to tensor type."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vEnaf9gzfTac"
      },
      "source": [
        "\n",
        "sj_train_features_t=torch.tensor(sj_train_features,dtype=torch.float)\n",
        "sj_train_labels_t=torch.tensor(sj_train_labels.to_numpy(),dtype=torch.float).view(-1,1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gAfLQ2pRoRsv"
      },
      "source": [
        "Initialise neural network linearly."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bEIWv7R4EmhP"
      },
      "source": [
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.layer1 = nn.Linear(22,15)# 15 seems to work better than 10\n",
        "        self.layer2 = nn.Linear(15,4)\n",
        "        # self.layer3 = nn.Linear(9,4)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.layer1(x)\n",
        "        x = self.layer2(x)\n",
        "        # x = self.layer3(x)\n",
        "        return x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lmkJrMI0gmeR"
      },
      "source": [
        "\n",
        "Training NN model.\n",
        "\n",
        "ADAM optimizer is used for it's stochastic gradient descent method to update biases\n",
        "\n",
        "Backpropagation is also used.\n",
        "\n",
        "Cross Entropy loss is used for classification problem.It supports labels in long type."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lfH0m8T0fY_u"
      },
      "source": [
        "def train_net(net,\n",
        "          train_features,\n",
        "          train_labels,\n",
        "          test_features=None,\n",
        "          test_labels=None,\n",
        "          num_epochs = 10,\n",
        "          learning_rate=0.1,\n",
        "          batch_size=10):\n",
        "    train_ls=[] \n",
        "    dataset=TensorDataset(train_features,train_labels)\n",
        "    train_iter=DataLoader(dataset,batch_size,shuffle=True)\n",
        "    optimizer=optim.Adam(params=net.parameters(),\n",
        "                         lr=learning_rate)\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    net=net.float()\n",
        "    for epoch in range(num_epochs):\n",
        "        for x , y in train_iter:\n",
        "            optimizer.zero_grad()\n",
        "            output=net(x.float())\n",
        "            loss=criterion(output,y)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "        print(\"loss: {}\".format(loss))\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nqx8IVUox8H_"
      },
      "source": [
        "net = Net()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-mHEHRjT7gCE"
      },
      "source": [
        "Changed y values in test from number of cases to cluster number"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xBW7Wpvz9wTg"
      },
      "source": [
        "train_features_in_range_groups save the features of different cluster.  \n",
        "train_labels_in_range_groups save the total_cases of differnet cluser.  \n",
        "y_range_groups save the cluster number of each input data. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rtrGcUaVxXW8"
      },
      "source": [
        "sj_train_labels = sj_train_labels.total_cases\n",
        "y_range_groups = torch.tensor(sj_train_labels)\n",
        "train_features_in_range_groups = [[],[],[],[]]\n",
        "train_labels_in_range_groups = [[],[],[],[]]\n",
        "for i,y in enumerate(sj_train_labels):\n",
        "  range_group = get_range_group_from_cases(int(y))\n",
        "  range_group = torch.tensor([range_group])\n",
        "  \n",
        "  train_features_in_range_groups[range_group].append(sj_train_features[i]) \n",
        "  train_labels_in_range_groups[range_group].append(sj_train_labels[i])\n",
        "  y_range_groups[i] = range_group"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oQ4ubeIz-eYV"
      },
      "source": [
        "Train NN."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p0_NqOFu6wUb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "25e50ef6-9a8a-47be-b017-72270e7c9748"
      },
      "source": [
        "train_net(net=net,num_epochs=20,\n",
        "                 train_features=sj_train_features_t,\n",
        "                 train_labels=y_range_groups)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss: 62.902400970458984\n",
            "loss: 2.2867653369903564\n",
            "loss: 0.9966108798980713\n",
            "loss: 1.2429308891296387\n",
            "loss: 2.9608070850372314\n",
            "loss: 2.507720708847046\n",
            "loss: 1.3941351175308228\n",
            "loss: 145.21734619140625\n",
            "loss: 525.6661987304688\n",
            "loss: 166.0164794921875\n",
            "loss: 4.489466667175293\n",
            "loss: 3.8252506256103516\n",
            "loss: 0.7415211200714111\n",
            "loss: 4.273420810699463\n",
            "loss: 2.483079671859741\n",
            "loss: 1.3282173871994019\n",
            "loss: 1.0296787023544312\n",
            "loss: 1.5835208892822266\n",
            "loss: 1.6243513822555542\n",
            "loss: 1.909854531288147\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wORPO1D6jbSL"
      },
      "source": [
        "# Regression fitting per range class\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G65YtqlRWtpZ"
      },
      "source": [
        "import lightgbm as lgb"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ORUE7MmC-vJh"
      },
      "source": [
        "We use LightGBM as regression model from the experience in Approach2.The parameters are the best parameter from approach2 too.For each range group, we train different model for it and store model in regressors_per_range_group."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rnB4eBowjRyP"
      },
      "source": [
        "regressors_per_range_group = []\n",
        "for i, range_group_features in enumerate(train_features_in_range_groups):\n",
        "  model_lgb = lgb.LGBMRegressor(objective='regression',learning_rate=0.05,n_estimators=800,\n",
        "                              max_bin=55, bagging_fraction=0.8, min_sum_hessian_in_leaf=11)\n",
        "  range_group_labels = train_labels_in_range_groups[i]\n",
        "  model_lgb.fit(range_group_features,range_group_labels)\n",
        "  regressors_per_range_group.append(copy.deepcopy(model_lgb))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q75F9hhx_b_5"
      },
      "source": [
        "# Predict"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rlfoUDV-Ia5t"
      },
      "source": [
        "Test with sj_test_features"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2kgtlEMOjki2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2e11d131-f813-43b7-f171-bd1f1dbc4272"
      },
      "source": [
        "sj_test_features=test_features[test_features.city=='sj']\n",
        "sj_test_features.drop(['city','week_start_date'],axis=1,inplace=True)\n",
        "sj_test_features_t=knnImputer.fit_transform(sj_test_features)\n",
        "sj_test_features_t=torch.tensor(sj_test_features.to_numpy(),dtype=torch.float)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/pandas/core/frame.py:4174: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  errors=errors,\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DDjznz60UP2-"
      },
      "source": [
        "#predict sj_test\n",
        "sj_test_features_tensor = torch.tensor(sj_test_features.to_numpy(),dtype=torch.float)\n",
        "\n",
        "outputs = net(sj_test_features_tensor)\n",
        "_, predicted = torch.max(outputs,1)\n",
        "predicted = predicted + 1\n",
        "\n",
        "\n",
        "sj_predictions=[]\n",
        "test_features_per_range_group =[[],[],[],[]] \n",
        "test_index_per_range_group=[[],[],[],[]] #record index \n",
        "\n",
        "for i,y in enumerate(predicted):\n",
        "  range_group = int(y)-1\n",
        "  test_features_per_range_group[range_group].append(np.array(sj_test_features.iloc[i,:]))\n",
        "  test_index_per_range_group[range_group].append(int(i))\n",
        "\n",
        "for i in range(0,len(test_features_per_range_group)):\n",
        "  regressor = regressors_per_range_group[i]\n",
        "  try:\n",
        "    range_group_prediction= regressor.predict(test_features_per_range_group[i])\n",
        "    sj_predictions.append(range_group_prediction)\n",
        "  except:\n",
        "    # some class don't have data,ignore them\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nFEGYe2z_hAv"
      },
      "source": [
        "Transform predictions to df, restore the order of input "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zv3_aFHSeA8I"
      },
      "source": [
        "test_ind=np.hstack([ind for ind in test_index_per_range_group])\n",
        "sj_result=pd.DataFrame(np.hstack([a for a in sj_predictions]),columns=['cases'])\n",
        "\n",
        "sj_result['ind']=test_ind\n",
        "sj_result.set_index('ind')\n",
        "sj_result.drop('ind',axis=1,inplace=True)\n",
        "sj_result.sort_index()\n",
        "sj_result['cases']=sj_result.cases.apply(lambda x: round(x))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 424
        },
        "id": "Dyx8BS0vfxjX",
        "outputId": "b312672b-db57-49ca-ba07-97f86794f4e3"
      },
      "source": [
        "sj_result"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>cases</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>4</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>4</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>4</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>4</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>255</th>\n",
              "      <td>51</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>256</th>\n",
              "      <td>61</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>257</th>\n",
              "      <td>60</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>258</th>\n",
              "      <td>58</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>259</th>\n",
              "      <td>54</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>260 rows × 1 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "     cases\n",
              "0        4\n",
              "1        4\n",
              "2        4\n",
              "3        4\n",
              "4        5\n",
              "..     ...\n",
              "255     51\n",
              "256     61\n",
              "257     60\n",
              "258     58\n",
              "259     54\n",
              "\n",
              "[260 rows x 1 columns]"
            ]
          },
          "metadata": {},
          "execution_count": 113
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vjJNaiwQsI5h"
      },
      "source": [
        "Preperations for ax optimisations.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5nL5iw8qw9y0"
      },
      "source": [
        "Abitrary list of parameters values:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dD1wMHFQsHrq"
      },
      "source": [
        "#gbr = gradientBoostingRegression \n",
        "parameterScope=[\n",
        "        {\"name\":\"knn_n_components\" ,\"type\": \"range\", \"bounds\": [15,20]},\n",
        "\n",
        "        {\"name\":\"nn_learning_rate\" ,\n",
        "         \"type\": \"choice\",\n",
        "         \"value_type\":\"float\", \n",
        "         \"values\": [0.07,0.06,0.05]},\n",
        "        {\"name\":\"nn_num_epochs\" ,\"type\": \"range\", \"bounds\": [15,25]},\n",
        "        {\"name\":\"nn_batch_size\" ,\"type\": \"range\", \"bounds\": [5,25]},\n",
        "\n",
        "        \n",
        "        {\"name\":\"gbr_learning_rate\" ,\"type\": \"choice\",\"value_type\":\"float\", \n",
        "         \"values\": [0.07,0.06,0.05]},\n",
        "        {\"name\":\"gbr_n_estimators\" ,\"type\": \"range\", \"bounds\": [150,200]},\n",
        "]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MJ6eheqyr_g4"
      },
      "source": [
        "from sklearn.metrics import accuracy_score\n",
        "def train_estimator(estimator,x_train,y_train):\n",
        "    estimator.fit(x_train,y_train)\n",
        "    return estimator\n",
        "\n",
        "def evaluate(predictions,y_test):\n",
        "    return mean_absolute_error(y_test,predictions)\n",
        "\n",
        "def train_evaluate(parameters):\n",
        "    predictions = train_predict(parameters)\n",
        "    return evaluate(predictions,y_test) \n",
        "\n",
        "def train_predict(parameters):\n",
        "     preprocessing = Pipeline(steps=[\n",
        "       (\"knnImputer\", KNNImputer(n_neighbors=parameters[\"knnImputer_n_clusters\"], \n",
        "                                 weights=\"uniform\",  \n",
        "                                 copy=False)),\n",
        "     ])\n",
        "\n",
        "     estimator = Pipeline(steps=[\n",
        "            ('proc', preprocessing),   \n",
        "            (\"neural_network\",Net(learning_rate = parameters[\"nn_learning_rate\"],\n",
        "                                  num_epochs= parameters[\"nn_num_epochs\"]\n",
        "                                  )\n",
        "            ),\n",
        "            # (\"gbr\",GradientBoostingRegressor())#to be changed\n",
        "     ]) \n",
        "     train_estimator(estimator,x_train,y_train)\n",
        "     return estimator.predict(x_test)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w8EgrjHBhLrU"
      },
      "source": [
        "**Iq city preprocessing, training and prediction**  \n",
        "Same as sj"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-hoYVY7yKKNc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7e0f6506-c9ae-410d-b9c4-6b97972abfad"
      },
      "source": [
        "#preprocess of iq\n",
        "iq_train_features=train_features[train_features.city=='iq']\n",
        "iq_train_features.drop(['city','week_start_date'],axis=1, inplace=True)\n",
        "\n",
        "iq_train_labels=train_labels[train_labels.city=='iq']\n",
        "iq_train_labels.drop(['city','year','weekofyear'],axis=1, inplace=True)\n",
        "iq_train_features = knnImputer.fit_transform(iq_train_features)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(520, 1)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/pandas/core/frame.py:4174: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  errors=errors,\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QmhvbarUiUE-"
      },
      "source": [
        "iq_train_features_t=torch.tensor(iq_train_features,dtype=torch.float)\n",
        "iq_train_labels_t=torch.tensor(iq_train_labels.to_numpy(),dtype=torch.float).view(-1,1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WgOiVAaZKMlU"
      },
      "source": [
        "iq_train_labels =iq_train_labels.total_cases\n",
        "iq_y_range_groups = torch.tensor(iq_train_labels.values)\n",
        "iq_train_features_in_range_groups = [[],[],[],[]]\n",
        "iq_train_labels_in_range_groups = [[],[],[],[]]\n",
        "\n",
        "for i,y in enumerate(iq_train_labels):\n",
        "  range_group = get_range_group_from_cases(int(y))\n",
        "  range_group = torch.tensor([range_group])\n",
        "  \n",
        "  iq_train_features_in_range_groups[range_group].append(iq_train_features[i]) \n",
        "  iq_train_labels_in_range_groups[range_group].append(iq_train_labels.iloc[i]) #use iloc since the first index is 936 instead of 0\n",
        "  iq_y_range_groups[i] = range_group"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LMiaFd914CRV",
        "outputId": "c2929f23-d8a5-4898-98ca-21f92b8a7ecb"
      },
      "source": [
        "train_net(net,iq_train_features_t,iq_y_range_groups)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([520, 1])\n",
            "loss: 110.2440185546875\n",
            "loss: 0.006762204226106405\n",
            "loss: 26.079029083251953\n",
            "loss: 28.5085506439209\n",
            "loss: 678.765380859375\n",
            "loss: 12.284777641296387\n",
            "loss: 6.22613525390625\n",
            "loss: 136.0769805908203\n",
            "loss: 71.99121856689453\n",
            "loss: 22.750024795532227\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E4ZmcXWxiPRe"
      },
      "source": [
        "Regression"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UjDkr4zkiL3L"
      },
      "source": [
        "iq_regressors_per_range_group = []\n",
        "for i, range_group_features in enumerate(iq_train_features_in_range_groups):\n",
        "  model_lgb = lgb.LGBMRegressor(objective='regression',learning_rate=0.05,n_estimators=800,\n",
        "                              max_bin=55, bagging_fraction=0.8, min_sum_hessian_in_leaf=11)\n",
        "  range_group_labels = iq_train_labels_in_range_groups[i]\n",
        "  model_lgb.fit(range_group_features,range_group_labels)\n",
        "  iq_regressors_per_range_group.append(copy.deepcopy(model_lgb))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1kz5ILFDkkOX"
      },
      "source": [
        "Test iq_features and Predict"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d2HQMi8DkbBG",
        "outputId": "29578b1f-afb8-4ac5-d5da-fcabf63edff7"
      },
      "source": [
        "iq_test_features=test_features[test_features.city=='iq']\n",
        "iq_test_features.drop(['city','week_start_date'],axis=1,inplace=True)\n",
        "iq_test_features_t=knnImputer.fit_transform(iq_test_features)\n",
        "iq_test_features_t=torch.tensor(iq_test_features.to_numpy(),dtype=torch.float)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/pandas/core/frame.py:4174: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  errors=errors,\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aaqYtW8Ykhz7"
      },
      "source": [
        "iq_test_features_tensor = torch.tensor(iq_test_features.to_numpy(),dtype=torch.float)\n",
        "\n",
        "outputs = net(iq_test_features_tensor)\n",
        "_, predicted = torch.max(outputs,1)\n",
        "predicted = predicted + 1\n",
        "\n",
        "iq_predictions=[]\n",
        "iq_test_features_per_range_group =[[],[],[],[]] \n",
        "iq_test_index_per_range_group=[[],[],[],[]] #record index \n",
        "\n",
        "for i,y in enumerate(predicted):\n",
        "  range_group = int(y)-1\n",
        "  iq_test_features_per_range_group[range_group].append(np.array(iq_test_features.iloc[i,:]))\n",
        "  iq_test_index_per_range_group[range_group].append(int(i))\n",
        "\n",
        "\n",
        "for i in range(0,len(iq_test_features_per_range_group)):\n",
        "  regressor = iq_regressors_per_range_group[i]\n",
        "  try:\n",
        "    range_group_prediction= regressor.predict(iq_test_features_per_range_group[i])\n",
        "    iq_predictions.append(predictions)\n",
        "  except:\n",
        "    # some class don't have data,ignore them\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "juxQSpTtlPd8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 428
        },
        "outputId": "0a08001a-f337-4a83-8bce-c2783f50dbd1"
      },
      "source": [
        "# Transform predictions to df, restore the order of input \n",
        "test_ind=np.hstack([ind for ind in iq_test_index_per_range_group])\n",
        "iq_result=pd.DataFrame(np.hstack([a for a in iq_predictions]),columns=['cases'])\n",
        "iq_result['ind']=test_ind\n",
        "iq_result.set_index('ind')\n",
        "iq_result.drop('ind',axis=1,inplace=True)\n",
        "iq_result.sort_index()\n",
        "iq_result['cases']=iq_result.cases.apply(lambda x: round(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-123-03b7201c66c1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Transform predictions to df, restore the order of input\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mtest_ind\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mind\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mind\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miq_test_index_per_range_group\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0miq_result\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDataFrame\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0ma\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miq_predictions\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'cases'\u001b[0m\u001b[0;34m]\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      4\u001b[0m \u001b[0miq_result\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'ind'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtest_ind\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0miq_result\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'ind'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mhstack\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/shape_base.py\u001b[0m in \u001b[0;36mhstack\u001b[0;34m(tup)\u001b[0m\n\u001b[1;32m    344\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0m_nx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marrs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    345\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 346\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0m_nx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marrs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\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    347\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    348\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mconcatenate\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: need at least one array to concatenate"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Oqo0r-ljlfe4"
      },
      "source": [
        "iq_result"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FeO_CeE6liaE"
      },
      "source": [
        "all_result=pd.concat([sj_result,iq_result],ignore_index=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "phSaflG9ltI0"
      },
      "source": [
        "all_result.to_csv('Approach3_Results.csv')"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}