ML_cup_SVM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "383f7f58",
   "metadata": {},
   "source": [
    "# ML CUP 2022\n",
    "\n",
    "## Support Vector Machine\n",
    "\n",
    "This notebook creates two Support Vector Machine (SVM) models to generalize the problem of the ML cup 2022. It searches the best combination of hyperparameters performing a grid searches over a given range of values. Two different models are given as output in this phase, one for each target, and for both models there is a tuning phase based on the same hyperparameters. In the end of the notebook there is a comparison between the learning curves of KRR and SVR models.\n",
    "\n",
    "Hyperparameters considered for the grid search:\n",
    "\n",
    "1. kernel\n",
    "2. C\n",
    "3. epsilon\n",
    "4. gamma (only for rbf and poly kernels)\n",
    "5. degree (only for poly kernel)\n",
    "\n",
    "Model selection performed using a cross validation.\\\n",
    "The model assessment phase is not included in this notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ac196dd",
   "metadata": {},
   "source": [
    "### Importing libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2c48f2a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from numpy import linalg as LA\n",
    "import math\n",
    "import random\n",
    "\n",
    "from sklearn.metrics import make_scorer\n",
    "from sklearn.svm import SVR\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "import joblib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2c98b3c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# choosing a seed for reproducibility\n",
    "seed = 1\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f111416",
   "metadata": {},
   "source": [
    "### Definition of the Mean Euclidean Distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d831ebf2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_mean_euclidean_distance(y_true, y_pred):\n",
    "    points = len(y_true)\n",
    "    tot_sum = 0\n",
    "    for i in range (points):\n",
    "        tot_sum += LA.norm(y_true[i] - y_pred[i])\n",
    "    \n",
    "    return tot_sum / points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "40e3cd82",
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_euclidean_distance = make_scorer(my_mean_euclidean_distance, greater_is_better=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88e08769",
   "metadata": {},
   "source": [
    "### Loading data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "509d5ac0",
   "metadata": {},
   "outputs": [],
   "source": [
    "colnames = ['id', 'a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'a9', 'target1', 'target2']\n",
    "mlcup_tr = pd.read_csv(\"./dataset/ml_cup22/ML-CUP22-TR.csv\", sep = \",\", names=colnames)\n",
    "mlcup_tr = mlcup_tr.iloc[1:, :]\n",
    "mlcup_tr = mlcup_tr.drop('id', axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "cef8285e",
   "metadata": {},
   "outputs": [],
   "source": [
    "x_mlcup_tr = mlcup_tr.iloc[:, 0:9].values\n",
    "y_mlcup_tr = mlcup_tr.iloc[:, 9:11].values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bcb8578",
   "metadata": {},
   "source": [
    "We used the function below to normalize our training set (both input and target) according to a min-max normalization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "75b6514e",
   "metadata": {},
   "outputs": [],
   "source": [
    "x_cols = len(x_mlcup_tr[0])\n",
    "\n",
    "max_col_value_x = [None]*x_cols\n",
    "max_vl = None\n",
    "\n",
    "min_col_value_x = [None]*x_cols\n",
    "min_vl = None\n",
    "\n",
    "for i in range(x_cols):\n",
    "    col = x_mlcup_tr[:, i]\n",
    "    max_vl = np.amax(col)\n",
    "    min_vl = np.amin(col)\n",
    "    \n",
    "    x_mlcup_tr[:, i] = (x_mlcup_tr[:, i] - min_vl) / (max_vl - min_vl)\n",
    "    \n",
    "    max_col_value_x[i] = max_vl\n",
    "    min_col_value_x[i] = min_vl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4522379a",
   "metadata": {},
   "outputs": [],
   "source": [
    "y1_mlcup_tr = y_mlcup_tr[:, 0]\n",
    "y2_mlcup_tr = y_mlcup_tr[:, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "479b343a",
   "metadata": {},
   "source": [
    "### Grid search for target 1\n",
    "#### rbf kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "adfaa5ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best parameters are {'C': 16.387032963983955, 'epsilon': 0.18620968289033768, 'gamma': 1.259921049894872} with a score of -0.80710\n"
     ]
    }
   ],
   "source": [
    "C_range = np.logspace(-2, 5, 30, base = 2)\n",
    "gamma_range = np.logspace(-9, 3, 10, base = 2)\n",
    "epsilon_range = np.logspace(-10, 0.1, 5, base = 2)\n",
    "\n",
    "param_grid = [\n",
    "    {'gamma': gamma_range, 'C': C_range, 'epsilon': epsilon_range},\n",
    "    {'gamma': ['auto', 'scale'], 'C': C_range, 'epsilon': epsilon_range}\n",
    "]\n",
    "\n",
    "grid = GridSearchCV(\n",
    "    SVR(kernel = 'rbf'),\n",
    "    param_grid = param_grid,\n",
    "    cv = 4,\n",
    "    scoring = mean_euclidean_distance,\n",
    "    n_jobs = -1\n",
    ")\n",
    "\n",
    "grid.fit(x_mlcup_tr, y1_mlcup_tr)\n",
    "\n",
    "print(\n",
    "    \"The best parameters are %s with a score of %0.5f\"\n",
    "    % (grid.best_params_, grid.best_score_)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c32866e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "rbf_classifier_1 = grid.best_estimator_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e2d01b1",
   "metadata": {},
   "source": [
    "### linear kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "68b6aa4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best parameters are {'C': 2.2214707591454514, 'epsilon': 1.0717734625362931} with a score of -1.20211\n"
     ]
    }
   ],
   "source": [
    "C_range = np.logspace(-2, 10, 100, base = 2)\n",
    "epsilon_range = np.logspace(-10, 0.1, 5, base = 2)\n",
    "\n",
    "param_grid = dict(\n",
    "    C = C_range,\n",
    "    epsilon = epsilon_range\n",
    ")\n",
    "\n",
    "grid = GridSearchCV(\n",
    "    SVR(kernel = 'linear'),\n",
    "    param_grid = param_grid,\n",
    "    cv = 4,\n",
    "    scoring = mean_euclidean_distance,\n",
    "    n_jobs = -1 \n",
    ")\n",
    "\n",
    "grid.fit(x_mlcup_tr, y1_mlcup_tr)\n",
    "\n",
    "print(\n",
    "    \"The best parameters are %s with a score of %0.5f\"\n",
    "    % (grid.best_params_, grid.best_score_)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5940f552",
   "metadata": {},
   "outputs": [],
   "source": [
    "linear_classifier_1 = grid.best_estimator_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdc4fbc3",
   "metadata": {},
   "source": [
    "### polynomial kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c2412b54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best parameters are {'C': 3.7034988491491627, 'degree': 2, 'epsilon': 0.18620968289033768, 'gamma': 'scale'} with a score of -1.13341\n"
     ]
    }
   ],
   "source": [
    "degree_range = np.arange(2, 5, 1)\n",
    "C_range = np.logspace(-9, 5, 10, base = 2)\n",
    "gamma_range = np.logspace(-9, 1, 10, base = 2)\n",
    "epsilon_range = np.logspace(-10, 0.1, 5, base = 2)\n",
    "\n",
    "param_grid = [\n",
    "    {'gamma': gamma_range, 'C': C_range, 'epsilon': epsilon_range, 'degree': degree_range},\n",
    "    {'gamma': ['auto', 'scale'], 'C': C_range, 'epsilon': epsilon_range, 'degree': degree_range}\n",
    "]\n",
    "\n",
    "grid = GridSearchCV(\n",
    "    SVR(kernel = 'poly'),\n",
    "    param_grid = param_grid,\n",
    "    cv = 4,\n",
    "    scoring = mean_euclidean_distance,\n",
    "    n_jobs = -1\n",
    ")\n",
    "\n",
    "grid.fit(x_mlcup_tr, y1_mlcup_tr)\n",
    "\n",
    "print(\n",
    "    \"The best parameters are %s with a score of %0.5f\"\n",
    "    % (grid.best_params_, grid.best_score_)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "baa33e6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "poly_classifier_1 = grid.best_estimator_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abaa9154",
   "metadata": {},
   "source": [
    "### Grid search for target 2\n",
    "#### rbf kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9e8957a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best parameters are {'C': 1.8616111078399704, 'epsilon': 0.0009765625, 'gamma': 4.507769644929328} with a score of -1.02988\n"
     ]
    }
   ],
   "source": [
    "C_range = np.logspace(-2, 5, 30, base = 2)\n",
    "gamma_range = np.logspace(-9, 3, 30, base = 2)\n",
    "epsilon_range = np.logspace(-10, 0.1, 5, base = 2)\n",
    "\n",
    "param_grid = [\n",
    "    {'gamma': gamma_range, 'C': C_range, 'epsilon': epsilon_range},\n",
    "    {'gamma': ['auto', 'scale'], 'C': C_range, 'epsilon': epsilon_range}\n",
    "]\n",
    "\n",
    "grid = GridSearchCV(\n",
    "    SVR(kernel = 'rbf'),\n",
    "    param_grid = param_grid,\n",
    "    cv = 4,\n",
    "    scoring = mean_euclidean_distance,\n",
    "    n_jobs = -1\n",
    ")\n",
    "\n",
    "grid.fit(x_mlcup_tr, y2_mlcup_tr)\n",
    "\n",
    "print(\n",
    "    \"The best parameters are %s with a score of %0.5f\"\n",
    "    % (grid.best_params_, grid.best_score_)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8521db74",
   "metadata": {},
   "outputs": [],
   "source": [
    "rbf_classifier_2 = grid.best_estimator_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27490f27",
   "metadata": {},
   "source": [
    "#### linear kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "9672e8a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best parameters are {'C': 4.0, 'epsilon': 0.18620968289033768} with a score of -1.53101\n"
     ]
    }
   ],
   "source": [
    "C_range = np.logspace(-2, 10, 100, base = 2)\n",
    "epsilon_range = np.logspace(-10, 0.1, 5, base = 2)\n",
    "\n",
    "param_grid = dict(\n",
    "    C = C_range,\n",
    "    epsilon = epsilon_range\n",
    ")\n",
    "\n",
    "grid = GridSearchCV(\n",
    "    SVR(kernel = 'linear'),\n",
    "    param_grid = param_grid,\n",
    "    cv = 4,\n",
    "    scoring = mean_euclidean_distance,\n",
    "    n_jobs = -1\n",
    ")\n",
    "\n",
    "grid.fit(x_mlcup_tr, y2_mlcup_tr)\n",
    "\n",
    "print(\n",
    "    \"The best parameters are %s with a score of %0.5f\"\n",
    "    % (grid.best_params_, grid.best_score_)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5cdc4092",
   "metadata": {},
   "outputs": [],
   "source": [
    "linear_classifier_2 = grid.best_estimator_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a0cc16c",
   "metadata": {},
   "source": [
    "#### polynomial kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "840b040d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best parameters are {'C': 1.2599210498948736, 'degree': 2, 'epsilon': 0.03235202887004304, 'gamma': 'scale'} with a score of -1.36317\n"
     ]
    }
   ],
   "source": [
    "degree_range = np.arange(2, 5, 1)\n",
    "C_range = np.logspace(-9, 5, 10, base = 2)\n",
    "gamma_range = np.logspace(-9, 1, 10, base = 2)\n",
    "epsilon_range = np.logspace(-10, 0.1, 5, base = 2)\n",
    "\n",
    "param_grid = [\n",
    "    {'gamma': gamma_range, 'C': C_range, 'epsilon': epsilon_range, 'degree': degree_range},\n",
    "    {'gamma': ['auto', 'scale'], 'C': C_range, 'epsilon': epsilon_range, 'degree': degree_range}\n",
    "]\n",
    "\n",
    "grid = GridSearchCV(\n",
    "    SVR(kernel = 'poly'),\n",
    "    param_grid = param_grid,\n",
    "    cv = 4,\n",
    "    scoring = mean_euclidean_distance,\n",
    "    n_jobs = -1\n",
    ")\n",
    "\n",
    "grid.fit(x_mlcup_tr, y2_mlcup_tr)\n",
    "\n",
    "print(\n",
    "    \"The best parameters are %s with a score of %0.5f\"\n",
    "    % (grid.best_params_, grid.best_score_)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1ef0176f",
   "metadata": {},
   "outputs": [],
   "source": [
    "poly_classifier_2 = grid.best_estimator_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9505a174",
   "metadata": {},
   "source": [
    "## Model selection"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ae9ea5d",
   "metadata": {},
   "source": [
    "Since the best results are given by the Support Vector Machine classifier with the rbf kernel both on the first and second target, we choose these two models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "ee2238a1",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['./results/ml_cup/SVM/rbf_classifier_2.z']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "joblib.dump(rbf_classifier_1, './results/ml_cup/SVM/rbf_classifier_1.z')\n",
    "joblib.dump(rbf_classifier_2, './results/ml_cup/SVM/rbf_classifier_2.z')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08c94312",
   "metadata": {},
   "source": [
    "### MEE on both targets on the training set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "22b57e27",
   "metadata": {},
   "outputs": [],
   "source": [
    "svr1 = joblib.load('./results/ml_cup/SVM/rbf_classifier_1.z')\n",
    "svr2 = joblib.load('./results/ml_cup/SVM/rbf_classifier_2.z')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d9496548",
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_label_svr_1 = svr1.predict(x_mlcup_tr)\n",
    "pred_label_svr_2 = svr2.predict(x_mlcup_tr)\n",
    "pred_label_svr = np.vstack((pred_label_svr_1, pred_label_svr_2)).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "b7d92803",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MEE on the training set: 1.2742387408800833\n"
     ]
    }
   ],
   "source": [
    "# Mean euclidean distance\n",
    "points = x_mlcup_tr.shape[0]\n",
    "tot_sum = 0\n",
    "for i in range (points):\n",
    "    tot_sum += math.sqrt(math.pow((y_mlcup_tr[i][0] - pred_label_svr[i][0]), 2)\n",
    "                         + math.pow((y_mlcup_tr[i][1] - pred_label_svr[i][1]), 2))\n",
    "    \n",
    "print('MEE on the training set:', tot_sum / points)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "883b2655",
   "metadata": {},
   "source": [
    "### Comparison between SVM and KRR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "29321fcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import learning_curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "f505a33b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "\n",
    "svr = joblib.load('./results/ml_cup/SVM/rbf_classifier_1.z')\n",
    "kr = joblib.load('./results/ml_cup/KRR/rbf_krr_1.z')\n",
    "train_sizes, train_scores_svr, test_scores_svr = learning_curve(\n",
    "    svr,\n",
    "    x_mlcup_tr,\n",
    "    y1_mlcup_tr,\n",
    "    train_sizes = np.linspace(0.1, 1, 500),\n",
    "    scoring = mean_euclidean_distance,\n",
    "    cv = 5,\n",
    ")\n",
    "train_sizes_abs, train_scores_kr, test_scores_kr = learning_curve(\n",
    "    kr,\n",
    "    x_mlcup_tr,\n",
    "    y1_mlcup_tr,\n",
    "    train_sizes = np.linspace(0.1, 1, 500),\n",
    "    scoring = mean_euclidean_distance,\n",
    "    cv = 5,\n",
    ")\n",
    "\n",
    "plt.plot(train_sizes, -test_scores_kr.mean(1), color=\"black\", label=\"KRR\")\n",
    "plt.plot(train_sizes, -test_scores_svr.mean(1), color=\"grey\", label=\"SVR\")\n",
    "plt.xlabel(\"Train size\")\n",
    "plt.ylabel(\"Mean Euclidean Distance\")\n",
    "plt.title(\"Learning curves\")\n",
    "plt.legend(loc=\"best\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "ae5f9ff5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "\n",
    "svr = joblib.load('./results/ml_cup/SVM/rbf_classifier_2.z')\n",
    "kr = joblib.load('./results/ml_cup/KRR/rbf_krr_2.z')\n",
    "train_sizes, train_scores_svr, test_scores_svr = learning_curve(\n",
    "    svr,\n",
    "    x_mlcup_tr,\n",
    "    y2_mlcup_tr,\n",
    "    train_sizes = np.linspace(0.1, 1, 500),\n",
    "    scoring = mean_euclidean_distance,\n",
    "    cv = 5,\n",
    ")\n",
    "train_sizes_abs, train_scores_kr, test_scores_kr = learning_curve(\n",
    "    kr,\n",
    "    x_mlcup_tr,\n",
    "    y2_mlcup_tr,\n",
    "    train_sizes = np.linspace(0.1, 1, 500),\n",
    "    scoring = mean_euclidean_distance,\n",
    "    cv = 5,\n",
    ")\n",
    "\n",
    "plt.plot(train_sizes, -test_scores_kr.mean(1), color=\"black\", label=\"KRR\")\n",
    "plt.plot(train_sizes, -test_scores_svr.mean(1), color=\"grey\", label=\"SVR\")\n",
    "plt.xlabel(\"Train size\")\n",
    "plt.ylabel(\"Mean Euclidean Distance\")\n",
    "plt.title(\"Learning curves\")\n",
    "plt.legend(loc=\"best\")\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}