Ada_Boosting.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ada_Boosting.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 674
        },
        "id": "HiaMIyUpfYrh",
        "outputId": "20f4e66b-57af-468f-d092-7266edd0f929"
      },
      "source": [
        "# Reference: https://www.python-course.eu/Boosting.php\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import sklearn\n",
        "from sklearn.tree import DecisionTreeClassifier\n",
        "from sklearn.preprocessing import LabelEncoder\n",
        "from sklearn.model_selection import cross_validate\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "dataset = pd.read_csv(\"/content/tic-tac-toe_train.csv\", header=None)\n",
        "dataset = dataset.sample(frac=1)\n",
        "dataset.columns = [\"A\", \"B\", \"C\", \"D\", \"E\",\n",
        "                   \"F\", \"G\", \"H\", \"I\", \"Decision\"]\n",
        "\n",
        "test_dataset = pd.read_csv(\"/content/tic-tac-toe_test.csv\", header=None)\n",
        "test_dataset = dataset.sample(frac=1)\n",
        "test_dataset.columns = [\"A\", \"B\", \"C\", \"D\", \"E\",\n",
        "                        \"F\", \"G\", \"H\", \"I\", \"Decision\"]\n",
        "\n",
        "for label in dataset.columns:\n",
        "    dataset[label] = LabelEncoder().fit(\n",
        "        dataset[label]).transform(dataset[label])\n",
        "\n",
        "Tree_model = DecisionTreeClassifier(criterion=\"entropy\", max_depth=1)\n",
        "X = dataset.drop('Decision', axis=1)\n",
        "Y = dataset['Decision'].where(dataset['Decision'] == 1, -1)\n",
        "predictions = np.mean(cross_validate(Tree_model, X, Y, cv=80)['test_score'])\n",
        "print('The accuracy is: ', predictions*100, '%')\n",
        "\n",
        "\n",
        "class Boosting:\n",
        "\n",
        "    def __init__(self, dataset, T, test_dataset):\n",
        "        self.dataset = dataset\n",
        "        self.T = T\n",
        "        self.test_dataset = test_dataset\n",
        "        self.alphas = None\n",
        "        self.models = None\n",
        "        self.accuracy = []\n",
        "        self.predictions = None\n",
        "\n",
        "    def fit(self):\n",
        "        # Set the descriptive features and the target feature\n",
        "        X = self.dataset.drop(['Decision'], axis=1)\n",
        "        Y = self.dataset['Decision'].where(self.dataset['Decision'] == 1, -1)\n",
        "\n",
        "        # Initialize the weights of each sample with wi = 1/N and create a dataframe in which the evaluation is computed\n",
        "        Evaluation = pd.DataFrame(Y.copy())\n",
        "        # Set the initial weights w = 1/N\n",
        "        Evaluation['weights'] = 1/len(self.dataset)\n",
        "\n",
        "        # Run the boosting algorithm by creating T \"weighted models\"\n",
        "\n",
        "        alphas = []\n",
        "        models = []\n",
        "\n",
        "        for t in range(self.T):\n",
        "\n",
        "            # Train the Decision Stump(s)\n",
        "            # Mind the deth one --> Decision Stump\n",
        "            Tree_model = DecisionTreeClassifier(\n",
        "                criterion=\"entropy\", max_depth=1)\n",
        "\n",
        "            model = Tree_model.fit(\n",
        "                X, Y, sample_weight=np.array(Evaluation['weights']))\n",
        "\n",
        "            # Append the single weak classifiers to a list which is later on used to make the\n",
        "            # weighted decision\n",
        "            models.append(model)\n",
        "            predictions = model.predict(X)\n",
        "            score = model.score(X, Y)\n",
        "\n",
        "            # Add values to the Evaluation DataFrame\n",
        "            Evaluation['predictions'] = predictions\n",
        "            Evaluation['evaluation'] = np.where(\n",
        "                Evaluation['predictions'] == Evaluation['Decision'], 1, 0)\n",
        "            Evaluation['misclassified'] = np.where(\n",
        "                Evaluation['predictions'] != Evaluation['Decision'], 1, 0)\n",
        "\n",
        "            # Calculate the misclassification rate and accuracy\n",
        "            accuracy = sum(Evaluation['evaluation']) / \\\n",
        "                len(Evaluation['evaluation'])\n",
        "            misclassification = sum(\n",
        "                Evaluation['misclassified'])/len(Evaluation['misclassified'])\n",
        "\n",
        "            # Caclulate the error\n",
        "            err = np.sum(\n",
        "                Evaluation['weights']*Evaluation['misclassified'])/np.sum(Evaluation['weights'])\n",
        "\n",
        "            # Calculate the alpha values\n",
        "            alpha = np.log((1-err)/err)\n",
        "            alphas.append(alpha)\n",
        "\n",
        "            # Update the weights wi --> These updated weights are used in the sample_weight parameter\n",
        "            # for the training of the next decision stump.\n",
        "            Evaluation['weights'] *= np.exp(alpha*Evaluation['misclassified'])\n",
        "\n",
        "            #print('The Accuracy of the {0}. model is : '.format(t+1),accuracy*100,'%')\n",
        "            #print('The missclassification rate is: ',misclassification*100,'%')\n",
        "\n",
        "        self.alphas = alphas\n",
        "        self.models = models\n",
        "\n",
        "    def predict(self):\n",
        "        X_test = self.test_dataset.drop(['Decision'], axis=1).reindex(\n",
        "            range(len(self.test_dataset)))\n",
        "        Y_test = self.test_dataset['Decision'].reindex(\n",
        "            range(len(self.test_dataset))).where(self.dataset['Decision'] == 1, -1)\n",
        "\n",
        "        # With each model in the self.model list, make a prediction\n",
        "\n",
        "        accuracy = []\n",
        "        predictions = []\n",
        "\n",
        "        for alpha, model in zip(self.alphas, self.models):\n",
        "            # We use the predict method for the single decisiontreeclassifier models in the list\n",
        "            prediction = alpha*model.predict(X_test)\n",
        "            predictions.append(prediction)\n",
        "            self.accuracy.append(np.sum(np.sign(\n",
        "                np.sum(np.array(predictions), axis=0)) == Y_test.values)/len(predictions[0]))\n",
        "\n",
        "        self.predictions = np.sign(np.sum(np.array(predictions), axis=0))\n",
        "\n",
        "\n",
        "##Plot the accuracy of the model against the number of stump-models used##########\n",
        "number_of_base_learners1 = 10\n",
        "number_of_base_learners2 = 25\n",
        "number_of_base_learners3 = 50\n",
        "fig = plt.figure(figsize=(10, 10))\n",
        "ax0 = fig.add_subplot(111)\n",
        "\n",
        "\n",
        "for i in range(number_of_base_learners1):\n",
        "    model = Boosting(dataset, i, dataset)\n",
        "    model.fit()\n",
        "    model.predict()\n",
        "\n",
        "ax0.plot(range(len(model.accuracy)), model.accuracy, '-b')\n",
        "ax0.set_xlabel('# models used for Boosting ')\n",
        "ax0.set_ylabel('accuracy')\n",
        "print('With a number of ', number_of_base_learners1,\n",
        "      'base models we receive an accuracy of ', model.accuracy[-1]*100, '%')\n",
        "\n",
        "plt.show()\n",
        "\n",
        "for i in range(number_of_base_learners2):\n",
        "    model = Boosting(dataset, i, dataset)\n",
        "    model.fit()\n",
        "    model.predict()\n",
        "\n",
        "ax0.plot(range(len(model.accuracy)), model.accuracy, '-b')\n",
        "ax0.set_xlabel('# models used for Boosting ')\n",
        "ax0.set_ylabel('accuracy')\n",
        "print('With a number of ', number_of_base_learners2,\n",
        "      'base models we receive an accuracy of ', model.accuracy[-1]*100, '%')\n",
        "\n",
        "plt.show()\n",
        "\n",
        "for i in range(number_of_base_learners3):\n",
        "    model = Boosting(dataset, i, dataset)\n",
        "    model.fit()\n",
        "    model.predict()\n",
        "\n",
        "ax0.plot(range(len(model.accuracy)), model.accuracy, '-b')\n",
        "ax0.set_xlabel('# models used for Boosting ')\n",
        "ax0.set_ylabel('accuracy')\n",
        "print('With a number of ', number_of_base_learners3,\n",
        "      'base models we receive an accuracy of ', model.accuracy[-1]*100, '%')\n",
        "\n",
        "plt.show()\n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The accuracy is:  66.14583333333334 %\n",
            "With a number of  10 base models we receive an accuracy of  73.2 %\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "With a number of  25 base models we receive an accuracy of  76.4 %\n",
            "With a number of  50 base models we receive an accuracy of  78.4 %\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}