HIV_cleavage.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "vzbGdfFYWdiO",
    "outputId": "406789a8-6d06-4019-81d7-75f856e05908"
   },
   "outputs": [],
   "source": [
    "# for colab import\n",
    "#!pip install -q xlrd\n",
    "#!git clone https://github.com/onimaru/CursoBio.git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 69
    },
    "colab_type": "code",
    "id": "yYtdadB0YG9L",
    "outputId": "4166a0f5-63ce-4b37-e597-c035fce67bb8"
   },
   "outputs": [],
   "source": [
    "#!ls CursoBio/datasets/newHIV-1_data/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "spsJhOq0Wwt3"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BaVG1f3oW0Jm"
   },
   "outputs": [],
   "source": [
    "data_746_raw = pd.read_csv(r\".\\datasets\\newHIV-1_data\\746Data.txt\", header=None)\n",
    "data_1625_raw = pd.read_csv(r\".\\datasets\\newHIV-1_data\\1625Data.txt\", header=None)\n",
    "data_impens_raw = pd.read_csv(r\".\\datasets\\newHIV-1_data\\impensData.txt\", header=None)\n",
    "data_schilling_raw = pd.read_csv(r\".\\datasets\\newHIV-1_data\\schillingData.txt\", header=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XoWKT2nUW0VG"
   },
   "outputs": [],
   "source": [
    "data_7 = data_746_raw.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4aMbZ3iRYWYC"
   },
   "outputs": [],
   "source": [
    "data_1 = data_1625_raw.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zDuD1zuLYW1A"
   },
   "outputs": [],
   "source": [
    "data_i = data_impens_raw.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QsYRRTWWYW-T"
   },
   "outputs": [],
   "source": [
    "data_s = data_schilling_raw.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 202
    },
    "colab_type": "code",
    "id": "1NwKmzv8W0X1",
    "outputId": "a5a6b20a-17b5-4460-8824-2e61b60d6502"
   },
   "outputs": [],
   "source": [
    "data_s.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 219
    },
    "colab_type": "code",
    "id": "uEDLNInbW0al",
    "outputId": "4c1f193f-fc06-49e1-cd39-89425467120c"
   },
   "outputs": [],
   "source": [
    "data_s.columns = ['Peptide','Cleavage']\n",
    "print(data_s.shape)\n",
    "data_s.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 156
    },
    "colab_type": "code",
    "id": "J-HRvdVtW0d3",
    "outputId": "f350163e-90a1-4091-b214-53a1995d7a4f"
   },
   "outputs": [],
   "source": [
    "data_s['Prot_sum'] = data_s['Peptide'].apply(len)\n",
    "print('Número máximo:',max(data_s['Prot_sum']))\n",
    "print('Número mínimo:',min(data_s['Prot_sum']))\n",
    "print(data_s.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 202
    },
    "colab_type": "code",
    "id": "7XV7KXH9W0gm",
    "outputId": "eebd7614-e737-4bac-d2b0-06889bf77ccb"
   },
   "outputs": [],
   "source": [
    "# Separando a string em Peptide em uma coluna para cada proteína\n",
    "n = max(data_s['Peptide'].apply(len))\n",
    "for i in range(n):\n",
    "    data_s['Pep0'+str(i)] = data_s['Peptide'].str[i]\n",
    "data_s.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 219
    },
    "colab_type": "code",
    "id": "bWOcKo4xW0iw",
    "outputId": "df438925-9e11-4a1d-8a45-97d3a7e3a937"
   },
   "outputs": [],
   "source": [
    "# target feature\n",
    "y_s = pd.DataFrame(data_s['Cleavage'])\n",
    "y_s = y_s.replace(-1,0)\n",
    "print(y_s.shape)\n",
    "y_s.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 219
    },
    "colab_type": "code",
    "id": "09xwK8xvW0mC",
    "outputId": "e0b18d8e-17f9-4c8c-ade9-b86835b578de"
   },
   "outputs": [],
   "source": [
    "# X features\n",
    "X_s = data_s.drop(['Peptide','Cleavage','Prot_sum'],axis=1)\n",
    "print(X_s.shape)\n",
    "X_s.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 269
    },
    "colab_type": "code",
    "id": "P8V0rIpkW0ox",
    "outputId": "d1e1f978-9b36-48c6-f5f1-63175c2fbdf6"
   },
   "outputs": [],
   "source": [
    "X_s_enc = pd.get_dummies(X_s)\n",
    "print(X_s_enc.shape)\n",
    "X_s_enc.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HsrI9H3lW0q_"
   },
   "outputs": [],
   "source": [
    "features = X_s_enc.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 286
    },
    "colab_type": "code",
    "id": "WiRjo9u4qfQT",
    "outputId": "ec6e55cc-3786-4ea4-a919-86542d37e106"
   },
   "outputs": [],
   "source": [
    "# preparing other datasets\n",
    "data_7.columns = ['Peptide','Cleavage']\n",
    "n = max(data_7['Peptide'].apply(len))\n",
    "for i in range(n):\n",
    "    data_7['Pep0'+str(i)] = data_7['Peptide'].str[i]\n",
    "y_7 = pd.DataFrame(data_7['Cleavage'])\n",
    "y_7 = y_7.replace(-1,0)\n",
    "X_7 = data_7.drop(['Peptide','Cleavage'],axis=1)\n",
    "X_7_enc = pd.get_dummies(X_7)\n",
    "print(X_7_enc.shape)\n",
    "print(y_7.shape)\n",
    "X_7_enc.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Rj071_HgsFxF"
   },
   "outputs": [],
   "source": [
    "X = X_s_enc.values\n",
    "y = y_s.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ONHVGzZBrzkO"
   },
   "outputs": [],
   "source": [
    "X_test = X_7_enc.values\n",
    "y_test = y_7.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "t2rtg4wlr6EM"
   },
   "outputs": [],
   "source": [
    "# save files\n",
    "X_s_enc.to_csv(r'.\\datasets\\newHIV-1_data\\X_s.csv')\n",
    "y_s.to_csv(r'.\\datasets\\newHIV-1_data\\y_s.csv')\n",
    "\n",
    "X_7_enc.to_csv(r'.\\datasets\\newHIV-1_data\\X_7.csv')\n",
    "y_7.to_csv(r'.\\datasets\\newHIV-1_data\\y_7.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Y6DlNKnsa_ME"
   },
   "source": [
    "***Training phase***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Qqv2tPE8W0we"
   },
   "outputs": [],
   "source": [
    "# machine learning libraries\n",
    "from sklearn.model_selection import StratifiedShuffleSplit, cross_val_predict, GridSearchCV, cross_val_score, train_test_split\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis, QuadraticDiscriminantAnalysis\n",
    "from sklearn.linear_model import LogisticRegression, SGDClassifier\n",
    "from sklearn.cross_validation import KFold\n",
    "\n",
    "# metrics\n",
    "from sklearn.metrics import accuracy_score, log_loss, make_scorer, confusion_matrix, f1_score, precision_score,\\\n",
    "        recall_score, precision_recall_curve, roc_curve, roc_auc_score\n",
    "\n",
    "# aditional libraries\n",
    "import time\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3oGiqt5MkkC0"
   },
   "outputs": [],
   "source": [
    "import itertools\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yOOa0XFPkpBe"
   },
   "outputs": [],
   "source": [
    "def classifier_scores(true_labels,prediction_labels):\n",
    "    f1 = f1_score(true_labels,prediction_labels)\n",
    "    pre = precision_score(true_labels,prediction_labels)\n",
    "    rec = recall_score(true_labels,prediction_labels)\n",
    "    acc = accuracy_score(true_labels,prediction_labels)\n",
    "    auc = roc_auc_score(true_labels,prediction_labels)\n",
    "    report = pd.DataFrame({'AUC':np.around([auc],3),'Precision':np.around([pre],3), 'Recall':np.around([rec],3),'F1':np.around([f1],3),'Accuracy':np.around([acc],3)})\n",
    "    print(report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Ja0-CZdMciyf"
   },
   "outputs": [],
   "source": [
    "#  list of classifiers\n",
    "classifiers = [\n",
    "    KNeighborsClassifier(5),\n",
    "    SVC(probability=True),\n",
    "    DecisionTreeClassifier(),\n",
    "    RandomForestClassifier(),\n",
    "    AdaBoostClassifier(),\n",
    "    GradientBoostingClassifier(),\n",
    "    GaussianNB(),\n",
    "    LinearDiscriminantAnalysis(),\n",
    "    QuadraticDiscriminantAnalysis(),\n",
    "    SGDClassifier(),\n",
    "    LogisticRegression()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "u6r9ibV0W0yO"
   },
   "outputs": [],
   "source": [
    "# graph to compare different regressors with the same chosen metric\n",
    "# classifiers = list of classifiers we want to use\n",
    "# cv = number of desired folds\n",
    "def scoringGraph(classifiers,cv,X,y):\n",
    "  init = time.time()\n",
    "  \n",
    "  log_cols = [\"Classifier\", \"F1_score\"]\n",
    "  log \t = pd.DataFrame(columns=log_cols)\n",
    "  splits = 5\n",
    "  sss = StratifiedShuffleSplit(n_splits=splits, test_size=0.1, random_state=0)\n",
    "\n",
    "  acc_dict = {}\n",
    "\n",
    "  for train_index, test_index in sss.split(X, y):\n",
    "    X_train, X_test = X[train_index], X[test_index]\n",
    "    y_train, y_test = y[train_index], y[test_index]\n",
    "\n",
    "    for clf in classifiers:\n",
    "      name = clf.__class__.__name__\n",
    "      clf.fit(X_train, y_train)\n",
    "      y_pred = clf.predict(X_test)\n",
    "      acc = f1_score(y_test, y_pred)\n",
    "      if name in acc_dict:\n",
    "        acc_dict[name] += acc\n",
    "      else:\n",
    "        acc_dict[name] = acc\n",
    "\n",
    "  for clf in acc_dict:\n",
    "    acc_dict[clf] = acc_dict[clf] / splits\n",
    "    log_entry = pd.DataFrame([[clf, acc_dict[clf]]], columns=log_cols)\n",
    "    log = log.append(log_entry)\n",
    "\n",
    "  plt.xlabel('F1_score')\n",
    "  plt.title('Classifier F1_score')\n",
    "\n",
    "  sns.set_color_codes(\"muted\")\n",
    "  sns.barplot(x='F1_score', y='Classifier', data=log, color=\"b\");\n",
    "\n",
    "  print('Tempo total: {:.2f}'.format(time.time()-init))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 312
    },
    "colab_type": "code",
    "id": "4Ni6LuEXd-YN",
    "outputId": "45c38440-6900-4f7d-8060-150653889720"
   },
   "outputs": [],
   "source": [
    "scoringGraph(classifiers,4,X,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sgS__exSfLZa"
   },
   "source": [
    "***Melhorando os modelos***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xpKiCtTNfKGT"
   },
   "outputs": [],
   "source": [
    "clf = DecisionTreeClassifier()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "N9B0zZmofKJC",
    "outputId": "adb2bae6-e46e-47a3-d6c9-d131f1fd7c93"
   },
   "outputs": [],
   "source": [
    "scorer = make_scorer(roc_auc_score)\n",
    "score = cross_val_score(clf,X,y,cv=5,scoring=scorer)\n",
    "score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 52
    },
    "colab_type": "code",
    "id": "mtibNKa6fKN_",
    "outputId": "27d9c3a0-7c9d-4074-af1e-1b6430391d2b"
   },
   "outputs": [],
   "source": [
    "y_pred = cross_val_predict(clf,X,y,cv=5)\n",
    "classifier_scores(y,y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 329
    },
    "colab_type": "code",
    "id": "EMc-1RWnfKWA",
    "outputId": "ffc01507-9eb1-40c4-d627-19c941de7a9a"
   },
   "outputs": [],
   "source": [
    "plot_confusion_matrix(cm_sgd,classes=['Negative cleavage','Positive cleavage'],normalize=False,title='Not-Normalized confusion matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TvDXdCdWjBYg"
   },
   "outputs": [],
   "source": [
    "y_scores = cross_val_predict(clf,X, y,cv=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "x6sI6CrhjBbx"
   },
   "outputs": [],
   "source": [
    "precisions, recalls, thresholds = precision_recall_curve(y,y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 285
    },
    "colab_type": "code",
    "id": "6V-6pBD_jBeh",
    "outputId": "11a546c8-6539-4c8e-f261-46cf86c77b6a"
   },
   "outputs": [],
   "source": [
    "#Plot precision and recall as functions of the threshold value\n",
    "def  plot_precision_recall_vs_threshold(precisions, recalls, thresholds):\n",
    "    plt.plot(thresholds, precisions[:-1], \"b--\", label=\"Precision\", linewidth=2)\n",
    "    plt.plot(thresholds, recalls[:-1], \"g-\", label=\"Recall\", linewidth=2)\n",
    "    plt.xlabel(\"Threshold\", fontsize=16)\n",
    "    plt.legend(loc=\"upper left\", fontsize=16)\n",
    "plt.figure(figsize=(8, 4))\n",
    "plot_precision_recall_vs_threshold(precisions, recalls, thresholds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 302
    },
    "colab_type": "code",
    "id": "6QYAc6dPjBg3",
    "outputId": "a17178c4-2701-4383-8d96-ce1f6be4e1dc"
   },
   "outputs": [],
   "source": [
    "plt.plot(precisions,recalls)\n",
    "plt.xlabel(\"Precision\", fontsize=16)\n",
    "plt.ylabel(\"Recall\", fontsize=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 415
    },
    "colab_type": "code",
    "id": "YpAfKfKGjBkJ",
    "outputId": "d0828eb4-bd6c-4413-8dd1-1693139b949f"
   },
   "outputs": [],
   "source": [
    "fpr, tpr, thresholds = roc_curve(y,y_scores)\n",
    "print('AUC: {:.2f}'.format(roc_auc_score(y,y_scores)))\n",
    "\n",
    "def  plot_roc_curve(fpr, tpr, label=None):\n",
    "    plt.plot(fpr, tpr, linewidth=2, label=label)\n",
    "    plt.plot([0, 1], [0, 1], 'k--')\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "    plt.xlabel('False Positive Rate', fontsize=16)\n",
    "    plt.ylabel('True Positive Rate', fontsize=16)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_roc_curve(fpr, tpr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9SljK_Wljaw9"
   },
   "source": [
    "## GridSerarchCV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "k_Bh7cduslNn"
   },
   "source": [
    "**DecisionTreeClassifier**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 191
    },
    "colab_type": "code",
    "id": "A7Gn4LOfjBoX",
    "outputId": "7e0dbae5-9182-4193-d1a4-c95ca10419d9"
   },
   "outputs": [],
   "source": [
    "classifier = DecisionTreeClassifier()\n",
    "\n",
    "# escolhemos alguns parâmetros para a procura\n",
    "parameters = {'criterion':['gini','entropy'],'min_samples_split':[3,7,10],'max_features':['auto','sqrt','log2',None]}\n",
    "\n",
    "# escolhemos uma métrica\n",
    "scorer = make_scorer(roc_auc_score)\n",
    "\n",
    "# rodamos o grid search no training set\n",
    "grid_obj = GridSearchCV(classifier, parameters, scoring=scorer)\n",
    "grid_obj = grid_obj.fit(X, y)\n",
    "\n",
    "# definimos o classificador knn com os melhores parâmetros\n",
    "classifier = grid_obj.best_estimator_\n",
    "best_dt = grid_obj.best_estimator_\n",
    "# e então treinamos o algoritmo com esta combinação\n",
    "classifier.fit(X, y)\n",
    "\n",
    "print(classifier.__class__.__name__)\n",
    "print('Train set results:')\n",
    "y_pred_train = classifier.predict(X)\n",
    "classifier_scores(y,y_pred_train)\n",
    "print('')\n",
    "print('Test set results:')\n",
    "y_pred_test = classifier.predict(X_test)\n",
    "classifier_scores(y_test,y_pred_test)\n",
    "print('')\n",
    "# aditional info\n",
    "feat = classifier.feature_importances_\n",
    "print('Max feature importance: {:.2f}'.format(max(feat)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "stfZCpHQswxu"
   },
   "source": [
    "***RandomForestClassifier***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 191
    },
    "colab_type": "code",
    "id": "UeyHDWnejBt6",
    "outputId": "77da1bcc-5772-43ba-d7b5-8a380d34a070"
   },
   "outputs": [],
   "source": [
    "classifier = RandomForestClassifier()\n",
    "\n",
    "# escolhemos alguns parâmetros para a procura\n",
    "parameters = {'n_estimators':[10,15,20],'criterion':['gini','entropy'],'min_samples_split':[3,7,10],'max_features':['auto','sqrt','log2',None]}\n",
    "\n",
    "scorer = make_scorer(roc_auc_score)\n",
    "grid_obj = GridSearchCV(classifier, parameters, scoring=scorer)\n",
    "grid_obj = grid_obj.fit(X, y)\n",
    "classifier = grid_obj.best_estimator_\n",
    "classifier.fit(X, y)\n",
    "\n",
    "print(classifier.__class__.__name__)\n",
    "print('Train set results:')\n",
    "y_pred_train = classifier.predict(X)\n",
    "classifier_scores(y,y_pred_train)\n",
    "print('')\n",
    "print('Test set results:')\n",
    "y_pred_test = classifier.predict(X_test)\n",
    "classifier_scores(y_test,y_pred_test)\n",
    "print('')\n",
    "# aditional info\n",
    "feat = classifier.feature_importances_\n",
    "print('Max feature importance: {:.2f}'.format(max(feat)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "i2ngaRKPIiV7"
   },
   "source": [
    "**SVC**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 173
    },
    "colab_type": "code",
    "id": "DZb53RmRIilO",
    "outputId": "0728d0d0-3ecc-4bc0-9c47-78f67455ca4e"
   },
   "outputs": [],
   "source": [
    "classifier = SVC()\n",
    "\n",
    "# escolhemos alguns parâmetros para a procura\n",
    "parameters = {'C':[0.001,0.01,1.,10.],'kernel':['linear','poly','rbf','sigmoid'],'degree':[1,2,3,4]}\n",
    "\n",
    "scorer = make_scorer(roc_auc_score)\n",
    "grid_obj = GridSearchCV(classifier, parameters, scoring=scorer)\n",
    "grid_obj = grid_obj.fit(X, y)\n",
    "classifier = grid_obj.best_estimator_\n",
    "classifier.fit(X, y)\n",
    "\n",
    "print(classifier.__class__.__name__)\n",
    "print('Train set results:')\n",
    "y_pred_train = classifier.predict(X)\n",
    "classifier_scores(y,y_pred_train)\n",
    "print('')\n",
    "print('Test set results:')\n",
    "y_pred_test = classifier.predict(X_test)\n",
    "classifier_scores(y_test,y_pred_test)\n",
    "print('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qzbng2oAtIi4"
   },
   "source": [
    "**AdaBoostClassifier**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 173
    },
    "colab_type": "code",
    "id": "80xVvbxIjBmn",
    "outputId": "f19fd7da-88a0-4e71-e5c1-79217be2223f"
   },
   "outputs": [],
   "source": [
    "classifier = AdaBoostClassifier()\n",
    "\n",
    "# escolhemos alguns parâmetros para a procura\n",
    "parameters = {'n_estimators':[30,50,70,90],'algorithm':['SAMME', 'SAMME.R']}\n",
    "\n",
    "scorer = make_scorer(roc_auc_score)\n",
    "grid_obj = GridSearchCV(classifier, parameters, scoring=scorer)\n",
    "grid_obj = grid_obj.fit(X, y)\n",
    "classifier = grid_obj.best_estimator_\n",
    "classifier.fit(X, y)\n",
    "\n",
    "print(classifier.__class__.__name__)\n",
    "print('Train set results:')\n",
    "y_pred_train = classifier.predict(X)\n",
    "classifier_scores(y,y_pred_train)\n",
    "print('')\n",
    "print('Test set results:')\n",
    "y_pred_test = classifier.predict(X_test)\n",
    "classifier_scores(y_test,y_pred_test)\n",
    "print('')\n",
    "# aditional info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5VojV16AtLDG"
   },
   "source": [
    "**GradientBoostingClassifier**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 173
    },
    "colab_type": "code",
    "id": "8iqYypX8tF3z",
    "outputId": "6a203137-2566-4284-b992-2b426fb9fb57"
   },
   "outputs": [],
   "source": [
    "classifier = GradientBoostingClassifier()\n",
    "\n",
    "# escolhemos alguns parâmetros para a procura\n",
    "parameters = {'loss':['deviance', 'exponential'],'learning_rate':[0.01,0.1,1.],'min_samples_split':[3,7,10],'max_features':['auto','sqrt','log2',None]}\n",
    "\n",
    "scorer = make_scorer(roc_auc_score)\n",
    "grid_obj = GridSearchCV(classifier, parameters, scoring=scorer)\n",
    "grid_obj = grid_obj.fit(X, y)\n",
    "classifier = grid_obj.best_estimator_\n",
    "classifier.fit(X, y)\n",
    "\n",
    "print(classifier.__class__.__name__)\n",
    "print('Train set results:')\n",
    "y_pred_train = classifier.predict(X)\n",
    "classifier_scores(y,y_pred_train)\n",
    "print('')\n",
    "print('Test set results:')\n",
    "y_pred_test = classifier.predict(X_test)\n",
    "classifier_scores(y_test,y_pred_test)\n",
    "print('')\n",
    "# aditional info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hHiVPQq-uGnk"
   },
   "source": [
    "**SGDClassifier**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 173
    },
    "colab_type": "code",
    "id": "-3FMgWQztF9R",
    "outputId": "5e6503cf-49a6-4c86-c01e-56edc600672c"
   },
   "outputs": [],
   "source": [
    "classifier = SGDClassifier()\n",
    "\n",
    "# escolhemos alguns parâmetros para a procura\n",
    "parameters = {'eta0':[0.0001],'loss':['hinge','log','modified_huber','squared_hinge','perceptron'],'penalty':[None,'l2','l1','elasticnet'],'max_iter':[5,10,15],'learning_rate':['constant','optimal','invscaling']}\n",
    "\n",
    "scorer = make_scorer(roc_auc_score)\n",
    "grid_obj = GridSearchCV(classifier, parameters, scoring=scorer)\n",
    "grid_obj = grid_obj.fit(X, y)\n",
    "classifier = grid_obj.best_estimator_\n",
    "classifier.fit(X, y)\n",
    "\n",
    "print(classifier.__class__.__name__)\n",
    "print('Train set results:')\n",
    "y_pred_train = classifier.predict(X)\n",
    "classifier_scores(y,y_pred_train)\n",
    "print('')\n",
    "print('Test set results:')\n",
    "y_pred_test = classifier.predict(X_test)\n",
    "classifier_scores(y_test,y_pred_test)\n",
    "print('')"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "HIV cleavage.ipynb",
   "private_outputs": true,
   "provenance": [],
   "version": "0.3.2"
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}