RB-Boost.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import NearestNeighbors\n",
    "import glob\n",
    "import random\n",
    "import numpy as np\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "import pandas as pd\n",
    "from pandas_ml import ConfusionMatrix\n",
    "import matplotlib.pyplot as plt\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = ['/Users/soroush/Desktop/1/*.txt', '/Users/soroush/Desktop/2/*.txt', '/Users/soroush/Desktop/3/*.txt',\n",
    "             '/Users/soroush/Desktop/4/*.txt', '/Users/soroush/Desktop/5/*.txt']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_set = []\n",
    "test_set = []\n",
    "training_labels = []\n",
    "test_labels = []\n",
    "# feature vector size\n",
    "feature_size = 0\n",
    "minority_class = []\n",
    "majority_class = []\n",
    "k_kkn = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_data(path, return_feature_size=True):\n",
    "    del training_set[:]\n",
    "    del test_set[:]\n",
    "    del training_labels[:]\n",
    "    del test_labels[:]\n",
    "    del minority_class[:]\n",
    "    del majority_class[:]\n",
    "\n",
    "    files = glob.glob(path)\n",
    "    for fle in files:\n",
    "        with open(fle) as f:\n",
    "            if \"tra\" in fle:\n",
    "                lines = f.readlines()\n",
    "                for line in lines:\n",
    "                    temp = line.split(\",\")\n",
    "                    label = temp[-1]\n",
    "                    del temp[-1]\n",
    "                    temp = [float(i) for i in temp]\n",
    "\n",
    "                    if label == ' negative\\n':\n",
    "                        training_labels.append(-1)\n",
    "                        majority_class.append(temp)\n",
    "                    else:\n",
    "                        training_labels.append(1)\n",
    "                        minority_class.append(temp)\n",
    "\n",
    "                    training_set.append(temp)\n",
    "            elif \"tst\" in fle:\n",
    "                lines = f.readlines()\n",
    "                for line in lines:\n",
    "                    temp = line.split(\",\")\n",
    "                    label = temp[-1]\n",
    "                    del temp[-1]\n",
    "                    temp = [float(i) for i in temp]\n",
    "\n",
    "                    if label == ' negative\\n':\n",
    "                        test_labels.append(-1)\n",
    "                    else:\n",
    "                        test_labels.append(1)\n",
    "\n",
    "                    test_set.append(temp)\n",
    "\n",
    "    if return_feature_size:\n",
    "        return len(training_set[0])\n",
    "    else:\n",
    "        return\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def smote(n, k, sample_class):\n",
    "    \"\"\" smote method main function\n",
    "    :param n: number of new sample\n",
    "    :param k: k of knn\n",
    "    :param sample_class : all minority sample\n",
    "    :return:\n",
    "    \"\"\"\n",
    "\n",
    "    # for tracking number of generated synthetic samples\n",
    "    newindex = 0\n",
    "    synthetic = []\n",
    "\n",
    "    while n != 0:\n",
    "        i = random.randint(1, len(sample_class)) - 1\n",
    "        populate(i, get_nearest_neighbor(sample_class[i], k), k, synthetic, newindex, sample_class)\n",
    "        n = n - 1\n",
    "\n",
    "    return synthetic\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_nearest_neighbor(x_test, k):\n",
    "    \"\"\" calculate k nearest neighbor and return their indices\n",
    "    :param x_test: the current data we want to find his neighbor\n",
    "    :param k: k of knn\n",
    "    :return: k nearest neighbor indices\n",
    "    \"\"\"\n",
    "    # create list for distances and targets\n",
    "    distances = []\n",
    "    targets_index = []\n",
    "\n",
    "    for i in range(len(minority_class)):\n",
    "        if minority_class[i][:] != x_test:\n",
    "            # first we compute the euclidean distance\n",
    "            distance = np.sqrt(np.sum(np.square(np.array(x_test) - np.array(minority_class[i][:]))))\n",
    "            # add it to list of distances\n",
    "            distances.append([distance, i])\n",
    "\n",
    "    # sort the list\n",
    "    distances = sorted(distances)\n",
    "\n",
    "    # make a list of the k neighbors' targets\n",
    "    for i in range(k):\n",
    "        targets_index.append(distances[i][1])\n",
    "\n",
    "    # return most common target\n",
    "    return targets_index\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def populate(i, nnarray, k, synthetic, new_index, sample_class):\n",
    "    \"\"\" \n",
    "    :param n:  number of smoting\n",
    "    :param i: index of current sample\n",
    "    :param nnarray: index of items that got from nearest neighbor method\n",
    "    :param k : k of knn\n",
    "    :param synthetic : list of synthetic objects\n",
    "    :param new_index : number of generated object\n",
    "    :param sample_class : all minority samples\n",
    "    :return:\n",
    "    \"\"\"\n",
    "\n",
    "    # while n != 0:\n",
    "    nn = random.randint(1, k) - 1\n",
    "    temp = []\n",
    "    for feature_position in range(0, feature_size):\n",
    "        dif = sample_class[nnarray[nn]][feature_position] - sample_class[i][feature_position]\n",
    "        gap = random.random()\n",
    "        temp.insert(feature_position, sample_class[i][feature_position] + gap * dif)\n",
    "\n",
    "    synthetic.insert(new_index, temp)\n",
    "\n",
    "    new_index += 1\n",
    "    # n = n - 1\n",
    "\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def random_balance():\n",
    "    new_training_set = []\n",
    "    new_training_labels = []\n",
    "\n",
    "    total_size = len(training_set)\n",
    "    minority_size = len(minority_class)\n",
    "    majority_size = len(majority_class)\n",
    "\n",
    "    new_majority_size = random.randint(2, total_size - 2)\n",
    "    new_minority_size = total_size - new_majority_size\n",
    "\n",
    "    # print(\"{} is mainority size \".format(new_minority_size/total_size))\n",
    "\n",
    "    if new_majority_size < majority_size:\n",
    "\n",
    "        new_training_set.extend(minority_class)\n",
    "        new_training_labels.extend([1] * minority_size)\n",
    "\n",
    "        new_training_set.extend(random.sample(majority_class, new_majority_size))\n",
    "        new_training_labels.extend([-1] * new_majority_size)\n",
    "        # create reminded minority class with SMOTE method\n",
    "        new_training_set.extend(smote(new_minority_size - minority_size, k_kkn, minority_class))\n",
    "        new_training_labels.extend([1] * (new_minority_size - minority_size))\n",
    "    else:\n",
    "\n",
    "        new_training_set.extend(majority_class)\n",
    "        new_training_labels.extend([-1] * majority_size)\n",
    "\n",
    "        new_training_set.extend(random.sample(minority_class, new_minority_size))\n",
    "        new_training_labels.extend([1] * new_minority_size)\n",
    "\n",
    "        # create reminded majority class with SMOTE method\n",
    "        new_training_set.extend(smote(new_majority_size - majority_size, k_kkn, majority_class))\n",
    "        new_training_labels.extend([-1] * (new_majority_size - majority_size))\n",
    "\n",
    "    return new_training_set, new_training_labels\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rb_boost(training_set, ensemble_size):\n",
    "    classifier_list = []\n",
    "    beta_list = []\n",
    "\n",
    "    distribution = [1 / len(training_set)] * len(training_set)\n",
    "    t = 0\n",
    "    while t < ensemble_size:\n",
    "\n",
    "        iteration_distribution = [0] * len(training_set)\n",
    "        new_training_set, new_training_labels = random_balance()\n",
    "\n",
    "        for index in range(0, len(training_set)):\n",
    "            if new_training_set[index] in training_set:  # set weight for original object\n",
    "                iteration_distribution[index] = distribution[index]\n",
    "            else:  # set weight for artificial object\n",
    "                iteration_distribution[index] = 1 / len(training_set)\n",
    "\n",
    "        # normalize iteration distribution\n",
    "        # iteration_distribution = [float(i) / sum(iteration_distribution) for i in iteration_distribution]\n",
    "        decision_tree_cl = DecisionTreeClassifier(max_depth=1)\n",
    "        decision_tree_cl.fit(new_training_set, new_training_labels, iteration_distribution)\n",
    "\n",
    "        accuracy_new_training = accuracy_score(new_training_labels, decision_tree_cl.predict(new_training_set))\n",
    "        accuracy_original_training = accuracy_score(training_labels, decision_tree_cl.predict(training_set))\n",
    "\n",
    "        # check tree accuracy , remove if it was below .5\n",
    "        # print(\"{}th ensembel accuracy rate is {}\".format(t, accuracy))\n",
    "        if accuracy_original_training < .5 or accuracy_new_training < .5:\n",
    "            # print(\"this tree was removed\")\n",
    "            continue\n",
    "\n",
    "        classifier_list.append(decision_tree_cl)\n",
    "\n",
    "        iteration_predict = decision_tree_cl.predict(new_training_set)\n",
    "        iteration_proba = decision_tree_cl.predict_proba(new_training_set)\n",
    "\n",
    "        # error of this iteration DecisionTree\n",
    "        error = 0\n",
    "\n",
    "        for i in range(0, len(iteration_predict)):\n",
    "            if iteration_predict[i] != new_training_labels[i]:\n",
    "                error = error + (iteration_distribution[index] * (\n",
    "                    1 - iteration_proba[index][\n",
    "                        decision_tree_cl.classes_.tolist().index(iteration_predict[index])] +\n",
    "                    iteration_proba[index][decision_tree_cl.classes_.tolist().index(new_training_labels[i])]))\n",
    "\n",
    "        # print(\"{}th ensembel error rate is {}\".format(t, error))\n",
    "\n",
    "        beta = error / (1 - error)\n",
    "        if math.isnan(beta) or beta == 0:\n",
    "            beta = 1\n",
    "\n",
    "        # print(\"{}th ensembel beta is {}\".format(t, beta))\n",
    "\n",
    "        beta_list.append(beta)\n",
    "\n",
    "        # if not math.isnan(beta):\n",
    "        for index in range(0, len(training_set)):\n",
    "            if new_training_set[index] in training_set:  # set weight for original object\n",
    "                power_value = (\n",
    "                                  1 + iteration_proba[index][\n",
    "                                      decision_tree_cl.classes_.tolist().index(iteration_predict[index])] -\n",
    "                                  iteration_proba[index][\n",
    "                                      decision_tree_cl.classes_.tolist().index(new_training_labels[i])]) / 2\n",
    "\n",
    "                distribution[training_set.index(new_training_set[index])] = distribution[training_set.index(\n",
    "                    new_training_set[index])] * pow(beta, power_value)\n",
    "\n",
    "        distribution = [float(i) / sum(distribution) for i in distribution]\n",
    "\n",
    "        t += 1\n",
    "\n",
    "    # print(len(classifier_list))\n",
    "\n",
    "    return classifier_list, beta_list\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rb_boost_test(classifier_list, beta_list, tests):\n",
    "    classes = classifier_list[0].classes_.tolist()\n",
    "    final_proba = np.zeros((len(tests), 2))\n",
    "    for t in range(0, len(classifier_list)):\n",
    "        # accuracy_train = accuracy_score(training_labels, classifier_list[t].predict(training_set))\n",
    "        # if accuracy_train < .5:\n",
    "        #     # print(\"this tree was removed\")\n",
    "        #     continue\n",
    "        proba = classifier_list[t].predict_proba(tests)\n",
    "        for j in range(0, len(tests)):\n",
    "            proba[j] = [math.log(1 / beta_list[t]) * float(i) for i in proba[j]]\n",
    "\n",
    "        final_proba = final_proba + np.array(proba)\n",
    "\n",
    "    # convert list to selected label\n",
    "    predict_label = []\n",
    "    for l in final_proba:\n",
    "        predict_label.append(classes[l.tolist().index(max(l))])\n",
    "\n",
    "    # print(final_proba)\n",
    "    # print(predict_label)\n",
    "\n",
    "    return predict_label\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94.64646464646464\n",
      "92.86868686868686\n",
      "91.97979797979798\n",
      "93.75757575757575\n",
      "93.31313131313131\n",
      "93.31313131313131\n",
      "93.74747474747474\n",
      "94.64646464646464\n",
      "95.0909090909091\n",
      "{'Rb Boost': [94.64646464646464, 92.86868686868686, 91.97979797979798], 'Adaboost': [93.75757575757575, 93.31313131313131, 93.31313131313131], 'Random Forest': [93.74747474747474, 94.64646464646464, 95.0909090909091]}\n"
     ]
    }
   ],
   "source": [
    "total_accuracy = {'Rb Boost': [], 'Adaboost': [], 'Random Forest': []}\n",
    "\n",
    "\n",
    "# Rb boost section\n",
    "for t in [10, 50, 100]:\n",
    "    folds_acc = 0\n",
    "    for i in range(0, 5):\n",
    "        feature_size = prepare_data(data_path[i])\n",
    "        classifiers, betas = rb_boost(training_set, t)\n",
    "        given_labels = rb_boost_test(classifiers, betas, test_set)\n",
    "        folds_acc += accuracy_score(test_labels, given_labels)\n",
    "        # print(accuracy_score(test_labels, given_labels))\n",
    "        \n",
    "    total_accuracy['Rb Boost'].append((folds_acc / 5)*100)\n",
    "    print((folds_acc / 5)*100)\n",
    "\n",
    "# Adaboost section\n",
    "for t in [10, 50, 100]:\n",
    "    adaboost_clf = AdaBoostClassifier(n_estimators = t)\n",
    "    folds_acc = 0\n",
    "    for i in range(0, 5):\n",
    "        feature_size = prepare_data(data_path[i])\n",
    "        adaboost_clf.fit(training_set, training_labels)\n",
    "        given_labels = adaboost_clf.predict(test_set)\n",
    "        folds_acc += accuracy_score(test_labels, given_labels)\n",
    "        # print(accuracy_score(test_labels, given_labels))\n",
    "\n",
    "    total_accuracy['Adaboost'].append((folds_acc / 5)*100)\n",
    "    print((folds_acc / 5)*100)\n",
    "    \n",
    "# Random Forest section\n",
    "\n",
    "for t in [10, 50, 100]:\n",
    "    random_forest_clf = RandomForestClassifier(n_estimators=t)\n",
    "    folds_acc = 0\n",
    "    for i in range(0, 5):\n",
    "        feature_size = prepare_data(data_path[i])\n",
    "        random_forest_clf.fit(training_set, training_labels)\n",
    "        given_labels = random_forest_clf.predict(test_set)\n",
    "        folds_acc += accuracy_score(test_labels, given_labels)\n",
    "        # print(accuracy_score(test_labels, given_labels))\n",
    "\n",
    "    total_accuracy['Random Forest'].append((folds_acc / 5)*100)\n",
    "    print((folds_acc / 5)*100)\n",
    "    \n",
    "print(total_accuracy)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Adaboost  Random Forest   Rb Boost\n",
      "10   93.757576      93.747475  94.646465\n",
      "50   93.313131      94.646465  92.868687\n",
      "100  93.313131      95.090909  91.979798\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10add0c50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAD8CAYAAABw1c+bAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10ae84860>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.DataFrame(data=total_accuracy,index= [10, 50, 100])\n",
    "# df = df.cumsum()\n",
    "print(df)\n",
    "plt.figure()\n",
    "df.plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}