RBNF_classifier.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "5MrpAZuF-sRZ"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import scipy as sp\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.model_selection import validation_curve\n",
        "from sklearn.model_selection import learning_curve"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "db = pd.read_csv(\"gender_submission.csv\")\n",
        "print(\"Database raw shape (%s,%s)\" % np.shape(db))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "buRseMp_-xP3",
        "outputId": "9c8b403a-85d3-4c42-e4a5-532e8ed917ed"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Database raw shape (418,2)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train = pd.read_csv('train.csv')\n",
        "test = pd.read_csv('test.csv')\n",
        "train.info()\n",
        "# test.info"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4QjTGxM0_qQO",
        "outputId": "40151937-878c-4768-9aa9-2bdfb43e9551"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 891 entries, 0 to 890\n",
            "Data columns (total 12 columns):\n",
            " #   Column       Non-Null Count  Dtype  \n",
            "---  ------       --------------  -----  \n",
            " 0   PassengerId  891 non-null    int64  \n",
            " 1   Survived     891 non-null    int64  \n",
            " 2   Pclass       891 non-null    int64  \n",
            " 3   Name         891 non-null    object \n",
            " 4   Sex          891 non-null    object \n",
            " 5   Age          714 non-null    float64\n",
            " 6   SibSp        891 non-null    int64  \n",
            " 7   Parch        891 non-null    int64  \n",
            " 8   Ticket       891 non-null    object \n",
            " 9   Fare         891 non-null    float64\n",
            " 10  Cabin        204 non-null    object \n",
            " 11  Embarked     889 non-null    object \n",
            "dtypes: float64(2), int64(5), object(5)\n",
            "memory usage: 83.7+ KB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "train['Title'] = train.Name.apply(lambda name: name.split(',')[1].split('.')[0].strip())\n",
        "test['Title'] = test.Name.apply(lambda name: name.split(',')[1].split('.')[0].strip())\n",
        "# normalize the titles\n",
        "normalized_titles = {\n",
        "    \"Capt\":       \"Officer\",\n",
        "    \"Col\":        \"Officer\",\n",
        "    \"Major\":      \"Officer\",\n",
        "    \"Jonkheer\":   \"Royalty\",\n",
        "    \"Don\":        \"Royalty\",\n",
        "    \"Sir\" :       \"Royalty\",\n",
        "    \"Dr\":         \"Officer\",\n",
        "    \"Rev\":        \"Officer\",\n",
        "    \"the Countess\":\"Royalty\",\n",
        "    \"Dona\":       \"Royalty\",\n",
        "    \"Mme\":        \"Mrs\",\n",
        "    \"Mlle\":       \"Miss\",\n",
        "    \"Ms\":         \"Mrs\",\n",
        "    \"Mr\" :        \"Mr\",\n",
        "    \"Mrs\" :       \"Mrs\",\n",
        "    \"Miss\" :      \"Miss\",\n",
        "    \"Master\" :    \"Master\",\n",
        "    \"Lady\" :      \"Royalty\"\n",
        "}\n",
        "\n",
        "train.Title = train.Title.map(normalized_titles)\n",
        "test.Title = train.Title.map(normalized_titles)\n",
        "\n",
        "train.Title.replace(['Mr', 'Miss', 'Mrs', 'Master', 'Officer', 'Royalty'], [1, 2, 3, 4, 5, 6], inplace=True)\n",
        "test.Title.replace(['Mr', 'Miss', 'Mrs', 'Master', 'Officer', 'Royalty'], [1, 2, 3, 4, 5, 6], inplace=True)\n"
      ],
      "metadata": {
        "id": "kWMBuRj1_sQH"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Drop the name feature\n",
        "train = train.drop('Name', 1)\n",
        "test = test.drop('Name', 1)\n",
        "# Encoding the features\n",
        "train.Embarked.replace(['S', 'C', 'Q'], [1, 2, 3], inplace=True)\n",
        "train.Sex.replace(['male', 'female'], [1, 2], inplace=True)\n",
        "test.Embarked.replace(['S', 'C', 'Q'], [1, 2, 3], inplace=True)\n",
        "test.Sex.replace(['male', 'female'], [1, 2], inplace=True)\n",
        "\n",
        "# Temporary drop of some columns\n",
        "train = train.drop('Ticket', 1)\n",
        "train = train.drop('Cabin', 1)\n",
        "test = test.drop('Ticket', 1)\n",
        "test = test.drop('Cabin', 1)\n",
        "\n",
        "#Fill NaN values of Age with the mean Age\n",
        "train['Age'] = train['Age'].fillna(train['Age'].sum()/len(train))\n",
        "test['Age'] = test['Age'].fillna(test['Age'].sum()/len(test))\n",
        "#Drop other raw where there is a NaN value\n",
        "train= train.dropna(how='any',axis=0)  \n",
        "test = test.fillna(0)\n",
        "\n",
        "train.info()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aDGYPnMM_u2W",
        "outputId": "752c9a9a-ce4f-4810-bd75-dda94bbe0e8b"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "Int64Index: 889 entries, 0 to 890\n",
            "Data columns (total 10 columns):\n",
            " #   Column       Non-Null Count  Dtype  \n",
            "---  ------       --------------  -----  \n",
            " 0   PassengerId  889 non-null    int64  \n",
            " 1   Survived     889 non-null    int64  \n",
            " 2   Pclass       889 non-null    int64  \n",
            " 3   Sex          889 non-null    int64  \n",
            " 4   Age          889 non-null    float64\n",
            " 5   SibSp        889 non-null    int64  \n",
            " 6   Parch        889 non-null    int64  \n",
            " 7   Fare         889 non-null    float64\n",
            " 8   Embarked     889 non-null    float64\n",
            " 9   Title        889 non-null    int64  \n",
            "dtypes: float64(3), int64(7)\n",
            "memory usage: 76.4 KB\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:2: FutureWarning: In a future version of pandas all arguments of DataFrame.drop except for the argument 'labels' will be keyword-only\n",
            "  \n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:3: FutureWarning: In a future version of pandas all arguments of DataFrame.drop except for the argument 'labels' will be keyword-only\n",
            "  This is separate from the ipykernel package so we can avoid doing imports until\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:11: FutureWarning: In a future version of pandas all arguments of DataFrame.drop except for the argument 'labels' will be keyword-only\n",
            "  # This is added back by InteractiveShellApp.init_path()\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:12: FutureWarning: In a future version of pandas all arguments of DataFrame.drop except for the argument 'labels' will be keyword-only\n",
            "  if sys.path[0] == '':\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:13: FutureWarning: In a future version of pandas all arguments of DataFrame.drop except for the argument 'labels' will be keyword-only\n",
            "  del sys.path[0]\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:14: FutureWarning: In a future version of pandas all arguments of DataFrame.drop except for the argument 'labels' will be keyword-only\n",
            "  \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Data_train = train.values\n",
        "Data_test = test.values\n",
        "\n",
        "# m = number of input samples\n",
        "m_train = len(Data_train)\n",
        "m_test = len(Data_test)\n",
        "# prediction for training\n",
        "Ytrain = Data_train[:m_train,1]\n",
        "# features for training\n",
        "Xtrain = Data_train[:m_train,2:]\n",
        "# features for testing\n",
        "Xtest = Data_test[:m_test,1:]\n",
        "\n",
        "parameters = {'C': [1, 10, 50, 100,200,300, 1000],'gamma':[0.0001,0.001,0.01,0.1,1.]}\n",
        "#run SVM with rbf kernel\n",
        "rbf_SVM = SVC(kernel='rbf')\n",
        "# ADD CODE: DO THE SAME AS ABOVE FOR RBF KERNEL\n",
        "clf = GridSearchCV(rbf_SVM,parameters,cv=5)\n",
        "clf.fit(Xtrain,Ytrain)\n",
        "\n",
        "print ('\\n RESULTS FOR rbf KERNEL \\n')\n",
        "\n",
        "best_param = clf.best_params_\n",
        "value_best_param_rbf_gammma = best_param['gamma']\n",
        "value_best_param_rbf_c = best_param['C']\n",
        "estim_best = clf.best_estimator_\n",
        "print(\"Best Estimator: \", estim_best)\n",
        "print(\"Best parameters set found:\",best_param)\n",
        "\n",
        "#get training and test error for the best SVM model from CV\n",
        "best_SVM = SVC(C = value_best_param_rbf_c, gamma = value_best_param_rbf_gammma, kernel='rbf')\n",
        "\n",
        "best_SVM.fit(Xtrain,Ytrain)\n",
        "\n",
        "training_error = 1. - best_SVM.score(Xtrain,Ytrain)\n",
        "print(\"Training error: \", training_error)\n",
        "\n",
        "Ytest_predicted = best_SVM.predict(Xtest)\n",
        "\n",
        "print(\"Accuracy =\",1-training_error);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-C4oklBO_w-X",
        "outputId": "1d9d3c4f-d822-45d9-96a5-2787cdec0ab8"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            " RESULTS FOR rbf KERNEL \n",
            "\n",
            "Best Estimator:  SVC(C=1000, gamma=0.0001)\n",
            "Best parameters set found: {'C': 1000, 'gamma': 0.0001}\n",
            "Training error:  0.17210348706411693\n",
            "Accuracy = 0.8278965129358831\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,\n",
        "                        n_jobs=-1, train_sizes= np.linspace(.1, 1.0, 10)):\n",
        "    \"\"\"Generate a simple plot of the test and training learning curve\"\"\"\n",
        "    plt.figure()\n",
        "    plt.title(title)\n",
        "    if ylim is not None:\n",
        "        plt.ylim(*ylim)\n",
        "    plt.xlabel(\"Training examples\")\n",
        "    plt.ylabel(\"Score\")\n",
        "    train_sizes, train_scores, test_scores = learning_curve(\n",
        "        estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)\n",
        "    train_scores_mean = np.mean(train_scores, axis=1)\n",
        "    train_scores_std = np.std(train_scores, axis=1)\n",
        "    test_scores_mean = np.mean(test_scores, axis=1)\n",
        "    test_scores_std = np.std(test_scores, axis=1)\n",
        "    plt.grid()\n",
        "\n",
        "    plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\n",
        "                     train_scores_mean + train_scores_std, alpha=0.1,\n",
        "                     color=\"r\")\n",
        "    plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\n",
        "                     test_scores_mean + test_scores_std, alpha=0.1, color=\"g\")\n",
        "    plt.plot(train_sizes, train_scores_mean, 'o-', color=\"r\",\n",
        "             label=\"Training score\")\n",
        "    plt.plot(train_sizes, test_scores_mean, 'o-', color=\"g\",\n",
        "             label=\"Cross-validation score\")\n",
        "\n",
        "    plt.legend(loc=\"best\")\n",
        "    return plt\n",
        "\n",
        "plot_learning_curve(estim_best,\"SVC learning curves\",Xtrain,Ytrain,cv=5)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "hbtDdn3C_zqg",
        "outputId": "f16ad020-58fd-4a40-d5ef-82b68f77cf8c"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}