p3_musk.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import os\n",
    "from sklearn import datasets\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools as it\n",
    "from sklearn.neighbors import LocalOutlierFactor\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV, KFold\n",
    "from sklearn.discriminant_analysis import (LinearDiscriminantAnalysis,\n",
    "                                           QuadraticDiscriminantAnalysis)\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "from sklearn.utils import shuffle\n",
    "from scipy import stats\n",
    "from statsmodels.stats.multicomp import (pairwise_tukeyhsd,\n",
    "                                         MultiComparison)\n",
    "from statsmodels.sandbox.stats.multicomp import TukeyHSDResults\n",
    "from sklearn.metrics import roc_curve\n",
    "from sklearn import preprocessing\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.model_selection import StratifiedKFold, cross_val_score\n",
    "from sklearn.utils.class_weight import compute_class_weight\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "import pickle\n",
    "import random\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cargamos dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds = pd.read_csv('./musk.data', header = None)\n",
    "# Quitamos las dos primeras columnas ya que son nombres simbólicos\n",
    "ds = ds.drop([0,1], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds.columns -= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "output = ds.shape[1]-1 # Columna de output\n",
    "y = ds[output].values\n",
    "X = ds.drop(output,axis=1).values\n",
    "seed = 42\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocesado de datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Comprobamos que no haya \"missing values\"**  \n",
    "Según https://archive.ics.uci.edu/ml/datasets, no tiene Missing Values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Comprobamos que no haya variables con \"near-zero variance\"**  \n",
    "Vemos que no hay ninguna."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([], dtype='int64')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ds.columns[ds.std() < 0.001]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Comprobamos que las clases no estén desbalanceadas**  \n",
    "Están desbalanceadas. Como trabajo futuro podríamos hacer oversampling o undersampling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proporción clase 0:  0.8458623825401637\n",
      "Proporción clase 1:  0.1541376174598363\n"
     ]
    }
   ],
   "source": [
    "print('Proporción clase 0: ',np.mean(y==0))\n",
    "print('Proporción clase 1: ',np.mean(y==1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Estandarizamos los datos**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = (X - np.mean(X)) / np.std(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Desordenamos los datos**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "X,y = shuffle(X,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Entrenamiento de Modelos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**kFold - Decision Tree Classifier**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exec_DT():\n",
    "    global resultados_train\n",
    "    global resultados_test\n",
    "    global res_train\n",
    "    global res_test\n",
    "    global model\n",
    "    global train_indices\n",
    "    global test_indices\n",
    "    global etiquetas\n",
    "    etiquetas.extend(['DT Normal',\n",
    "                 'DT Profundidad',\n",
    "                 'DT Minimo de muestras por hoja',\n",
    "                 'DT Minimo de muestras en subarbol',\n",
    "                 'DT Minimo de impureza',\n",
    "                 'LDA lsqr',\n",
    "                 'LDA eigen',\n",
    "                 'LDA svd',\n",
    "                 'QDA'])\n",
    "    dicc = [{'max_depth': None, 'min_samples_leaf': 1, \n",
    "             'min_samples_split': 2, 'min_impurity_decrease': 0.0},\n",
    "            {'max_depth': 5,    'min_samples_leaf': 1, \n",
    "             'min_samples_split': 2, 'min_impurity_decrease': 0.0},\n",
    "            {'max_depth': None, 'min_samples_leaf': 3, \n",
    "             'min_samples_split': 2, 'min_impurity_decrease': 0.0},\n",
    "            {'max_depth': None, 'min_samples_leaf': 1, \n",
    "             'min_samples_split': 5, 'min_impurity_decrease': 0.0},\n",
    "            {'max_depth': None, 'min_samples_leaf': 1, \n",
    "             'min_samples_split': 2, 'min_impurity_decrease': 0.2}]\n",
    "\n",
    "    for i in range(len(dicc)):\n",
    "        train_indices2 = []\n",
    "        test_indices2 = []\n",
    "        for j in range(3):\n",
    "            for train_index, test_index in kf.split(X):\n",
    "                X_train, X_test = X[train_index],X[test_index]\n",
    "                y_train, y_test = y[train_index],y[test_index]\n",
    "                train_indices2.append(train_index)\n",
    "                test_indices2.append(test_index)\n",
    "                alg = DecisionTreeClassifier(**dicc[i])\n",
    "                alg.fit(X_train, y_train)\n",
    "                model.append(alg)\n",
    "                resultados_train.append(alg.score(X_train, y_train))\n",
    "                resultados_test.append(alg.score(X_test, y_test))\n",
    "        res_train = np.hstack((res_train, np.array(resultados_train,ndmin=2).T))\n",
    "        res_test = np.hstack((res_test, np.array(resultados_test,ndmin=2).T))\n",
    "        resultados_train = []\n",
    "        resultados_test = []\n",
    "        train_indices.append(train_indices2)\n",
    "        test_indices.append(test_indices2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**kFold - Linear Discriminant Analysis**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exec_LDC():\n",
    "    global resultados_train\n",
    "    global resultados_test\n",
    "    global res_train\n",
    "    global res_test\n",
    "    global model\n",
    "    global train_indices\n",
    "    global test_indices\n",
    "    for tipo in ('lsqr', 'eigen', 'svd'):\n",
    "        train_indices2 = []\n",
    "        test_indices2 = []\n",
    "        for _ in range(3):\n",
    "            for train_index, test_index in kf.split(X):\n",
    "                X_train, X_test = X[train_index],X[test_index]\n",
    "                y_train, y_test = y[train_index],y[test_index]\n",
    "                alg = LinearDiscriminantAnalysis(solver=tipo, shrinkage=None)\n",
    "                train_indices2.append(train_index)\n",
    "                test_indices2.append(test_index)\n",
    "                alg.fit(X_train, y_train)\n",
    "                model.append(alg)\n",
    "                resultados_train.append(alg.score(X_train, y_train))\n",
    "                resultados_test.append(alg.score(X_test, y_test))\n",
    "        res_train = np.hstack((res_train, np.array(resultados_train,ndmin=2).T))\n",
    "        res_test = np.hstack((res_test, np.array(resultados_test,ndmin=2).T))\n",
    "        resultados_train = []\n",
    "        resultados_test = []\n",
    "        train_indices.append(train_indices2)\n",
    "        test_indices.append(test_indices2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**kFold - Quadratic Discriminant Analysis**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exec_QDA():\n",
    "    global resultados_train\n",
    "    global resultados_test\n",
    "    global res_train\n",
    "    global res_test\n",
    "    global model\n",
    "    global train_indices\n",
    "    global test_indices\n",
    "    train_indices2 = []\n",
    "    test_indices2 = []\n",
    "    for _ in range(3):\n",
    "        for train_index, test_index in kf.split(X):\n",
    "            X_train, X_test = X[train_index],X[test_index]\n",
    "            y_train, y_test = y[train_index],y[test_index]\n",
    "            train_indices2.append(train_index)\n",
    "            test_indices2.append(test_index)\n",
    "            alg = QuadraticDiscriminantAnalysis()\n",
    "            alg.fit(X_train, y_train)\n",
    "            model.append(alg)\n",
    "            resultados_train.append(alg.score(X_train, y_train))\n",
    "            resultados_test.append(alg.score(X_test, y_test))\n",
    "    res_train = np.hstack((res_train, np.array(resultados_train,ndmin=2).T))\n",
    "    res_test = np.hstack((res_test, np.array(resultados_test,ndmin=2).T))\n",
    "    resultados_train = []\n",
    "    resultados_test = []\n",
    "    train_indices.append(train_indices2)\n",
    "    test_indices.append(test_indices2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**kFold - Support Vector Classification**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exec_SVC():\n",
    "    global resultados_train\n",
    "    global resultados_test\n",
    "    global res_train\n",
    "    global res_test\n",
    "    global model\n",
    "    global train_indices\n",
    "    global test_indices\n",
    "    global etiquetas\n",
    "    etiquetas.extend(['SVM poly 2º C1',\n",
    "                 'SVM poly 3º C1',\n",
    "                 'SVM poly 4º C1',\n",
    "                 'SVM rfb auto C1',\n",
    "                 'SVM rfb 0.05 C1',\n",
    "                 'SVM rfb 0.1 C1',\n",
    "                 'SVM rfb 0.2 C1'])\n",
    "    # etiquetas.extend(['SVM linear C100',\n",
    "    #              'SVM poly 2º C100',\n",
    "    #              'SVM poly 3º C100',\n",
    "    #              'SVM poly 4º C100',\n",
    "    #              'SVM rfb auto C100',\n",
    "    #              'SVM rfb 0.05 C100',\n",
    "    #              'SVM rfb 0.1 C100',\n",
    "    #              'SVM rfb 0.2 C100'])\n",
    "    dicc = [{'C': 1.0, 'kernel': 'poly', 'degree': 2, \n",
    "             'gamma': 'auto', 'class_weight': 'balanced'},\n",
    "            {'C': 1.0, 'kernel': 'poly', 'degree': 3, \n",
    "             'gamma': 'auto', 'class_weight': 'balanced'},\n",
    "            {'C': 1.0, 'kernel': 'poly', 'degree': 4, \n",
    "             'gamma': 'auto', 'class_weight': 'balanced'},\n",
    "            {'C': 1.0, 'kernel': 'rbf', 'degree': 2,  \n",
    "             'gamma': 'auto', 'class_weight': 'balanced'},\n",
    "            {'C': 1.0, 'kernel': 'rbf', 'degree': 2,  \n",
    "             'gamma': 0.05, 'class_weight': 'balanced'},\n",
    "            {'C': 1.0, 'kernel': 'rbf', 'degree': 2,  \n",
    "             'gamma': 0.1, 'class_weight': 'balanced'},\n",
    "            {'C': 1.0, 'kernel': 'rbf', 'degree': 2,  \n",
    "             'gamma': 0.2, 'class_weight': 'balanced'}]\n",
    "\n",
    "    for i in range(len(dicc)):\n",
    "        train_indices2 = []\n",
    "        test_indices2 = []\n",
    "        for j in range(3):\n",
    "            for train_index, test_index in kf.split(X):\n",
    "                X_train, X_test = X[train_index],X[test_index]\n",
    "                y_train, y_test = y[train_index],y[test_index]\n",
    "                train_indices2.append(train_index)\n",
    "                test_indices2.append(test_index)\n",
    "                alg = SVC(**dicc[i])\n",
    "                alg.fit(X_train, y_train)\n",
    "                model.append(alg)\n",
    "                resultados_train.append(alg.score(X_train, y_train))\n",
    "                resultados_test.append(alg.score(X_test, y_test))\n",
    "        res_train = np.hstack((res_train, np.array(resultados_train,ndmin=2).T))\n",
    "        res_test = np.hstack((res_test, np.array(resultados_test,ndmin=2).T))\n",
    "        resultados_train = []\n",
    "        resultados_test = []\n",
    "        train_indices.append(train_indices2)\n",
    "        test_indices.append(test_indices2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**kFold - Multi-layer Perceptron Classifier**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exec_MLPC():\n",
    "    global resultados_train\n",
    "    global resultados_test\n",
    "    global res_train\n",
    "    global res_test\n",
    "    global model\n",
    "    global train_indices\n",
    "    global test_indices\n",
    "    global etiquetas\n",
    "    etiquetas.extend(['MLPR sgd 10 relu',\n",
    "                 'MLPR sgd 30 relu',\n",
    "                 'MLPR sgd 50 relu',\n",
    "                 'MLPR adam 10 relu',\n",
    "                 'MLPR adam 30 relu',\n",
    "                 'MLPR adam 50 relu'])\n",
    "    etiquetas.extend(['MLPR sgd 10 tanh',\n",
    "                 'MLPR sgd 30 tanh',\n",
    "                 'MLPR sgd 50 tanh',\n",
    "                 'MLPR adam 10 tanh',\n",
    "                 'MLPR adam 30 tanh',\n",
    "                 'MLPR adam 50 tanh'])\n",
    "    dicc = [{'hidden_layer_sizes': (10,), 'solver': 'sgd',  \n",
    "             'activation': 'relu','early_stopping': True, 'max_iter': 1500},\n",
    "            {'hidden_layer_sizes': (30,), 'solver': 'sgd',  \n",
    "             'activation': 'relu','early_stopping': True, 'max_iter': 1500},\n",
    "            {'hidden_layer_sizes': (50,), 'solver': 'sgd',  \n",
    "             'activation': 'relu','early_stopping': True, 'max_iter': 1500},\n",
    "            {'hidden_layer_sizes': (10,), 'solver': 'adam', \n",
    "             'activation': 'relu','early_stopping': True, 'max_iter': 1500},\n",
    "            {'hidden_layer_sizes': (30,), 'solver': 'adam', \n",
    "             'activation': 'relu','early_stopping': True, 'max_iter': 1500},\n",
    "            {'hidden_layer_sizes': (50,), 'solver': 'adam', \n",
    "             'activation': 'relu','early_stopping': True, 'max_iter': 1500},\n",
    "            {'hidden_layer_sizes': (10,), 'solver': 'sgd',  \n",
    "             'activation': 'tanh','early_stopping': True, 'max_iter': 1500},\n",
    "            {'hidden_layer_sizes': (30,), 'solver': 'sgd',  \n",
    "             'activation': 'tanh','early_stopping': True, 'max_iter': 1500},\n",
    "            {'hidden_layer_sizes': (50,), 'solver': 'sgd',  \n",
    "             'activation': 'tanh','early_stopping': True, 'max_iter': 1500},\n",
    "            {'hidden_layer_sizes': (10,), 'solver': 'adam', \n",
    "             'activation': 'tanh','early_stopping': True, 'max_iter': 1500},\n",
    "            {'hidden_layer_sizes': (30,), 'solver': 'adam', \n",
    "             'activation': 'tanh','early_stopping': True, 'max_iter': 1500},\n",
    "            {'hidden_layer_sizes': (50,), 'solver': 'adam', \n",
    "             'activation': 'tanh','early_stopping': True, 'max_iter': 1500}]\n",
    "\n",
    "    for i in range(len(dicc)):\n",
    "        train_indices2 = []\n",
    "        test_indices2 = []\n",
    "        for j in range(3):\n",
    "            for train_index, test_index in kf.split(X):\n",
    "                X_train, X_test = X[train_index],X[test_index]\n",
    "                y_train, y_test = y[train_index],y[test_index]\n",
    "                train_indices2.append(train_index)\n",
    "                test_indices2.append(test_index)\n",
    "                alg = MLPClassifier(**dicc[i])\n",
    "                alg.fit(X_train, y_train)\n",
    "                model.append(alg)\n",
    "                resultados_train.append(alg.score(X_train, y_train))\n",
    "                resultados_test.append(alg.score(X_test, y_test))\n",
    "        res_train = np.hstack((res_train, np.array(resultados_train,ndmin=2).T))\n",
    "        res_test = np.hstack((res_test, np.array(resultados_test,ndmin=2).T))\n",
    "        resultados_train = []\n",
    "        resultados_test = []\n",
    "        train_indices.append(train_indices2)\n",
    "        test_indices.append(test_indices2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decision Tree Classifier\n",
      "Wall time: 1min\n",
      "Lineal Discriminant Analysis\n",
      "Wall time: 17.3 s\n",
      "Quadratic Discriminant Analysis\n",
      "Wall time: 4.64 s\n",
      "Support Vector Classification\n",
      "Wall time: 26min 54s\n",
      "Multi-layer Perceptron Classifier\n",
      "Wall time: 10min 59s\n"
     ]
    }
   ],
   "source": [
    "# Definición de variables globales\n",
    "kf = KFold(n_splits=10,shuffle=True)\n",
    "resultados_train = []\n",
    "resultados_test = []\n",
    "model = []\n",
    "res_train = np.empty((30,0))\n",
    "res_test = np.empty((30,0))\n",
    "train_indices = []\n",
    "test_indices = []\n",
    "etiquetas = []\n",
    "# Ejecuciones\n",
    "print('Decision Tree Classifier')\n",
    "%time exec_DT()\n",
    "print('Lineal Discriminant Analysis')\n",
    "%time exec_LDC()\n",
    "print('Quadratic Discriminant Analysis')\n",
    "%time exec_QDA()\n",
    "print('Support Vector Classification')\n",
    "%time exec_SVC()\n",
    "print('Multi-layer Perceptron Classifier')\n",
    "%time exec_MLPC()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Persistencia**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('p3_musk-res_test.bin','wb') as file:\n",
    "    pickle.dump(res_test, file)\n",
    "with open('p3_musk-train_indices.bin','wb') as file:\n",
    "    pickle.dump(train_indices, file)\n",
    "with open('p3_musk-test_indices.bin','wb') as file:\n",
    "    pickle.dump(test_indices, file)\n",
    "with open('p3_musk-models.bin','wb') as file:\n",
    "    pickle.dump(model, file)\n",
    "with open('p3_musk-etiquetas.bin','wb') as file:\n",
    "    pickle.dump(etiquetas, file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('p3_musk-res_test.bin','rb') as file:\n",
    "    res_test = pickle.load(file)\n",
    "with open('p3_musk-train_indices.bin','rb') as file:\n",
    "    train_indices = pickle.load(file)\n",
    "with open('p3_musk-test_indices.bin','rb') as file:\n",
    "    test_indices = pickle.load(file)\n",
    "with open('p3_musk-models.bin','rb') as file:\n",
    "    model = pickle.load(file)\n",
    "with open('p3_musk-etiquetas.bin','rb') as file:\n",
    "    etiquetas = pickle.load(file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Test de normalidad**  \n",
    "No podemos rechazamos normalidad en el 85% de los modelos, por lo que realizamos un ANOVA (y Kruskal-Wallis para asegurarnos) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6.41781330e-01, 3.56934547e-01, 2.37274349e-01, 4.06896681e-01,\n",
       "       8.24977636e-01, 4.31955099e-01, 1.30944937e-01, 5.28166413e-01,\n",
       "       6.92675471e-01, 2.70530045e-01, 7.15229809e-01, 1.26872808e-01,\n",
       "       9.17859852e-01, 4.87028271e-01, 6.31274432e-02, 2.79743969e-01,\n",
       "       9.27778965e-05, 9.27439153e-01, 7.47246265e-01, 3.23169589e-01,\n",
       "       3.39797605e-03, 3.12038435e-04, 5.69412351e-01, 9.11463380e-01,\n",
       "       7.10717142e-02, 5.97309768e-02, 3.80838737e-02, 5.88941574e-02])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.apply_along_axis(lambda x: stats.shapiro(x)[1], axis=0, arr=res_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Test Anova**  \n",
    "Rechazamos que las precisiones sean similares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F_onewayResult(statistic=350.0213105964739, pvalue=0.0)\n"
     ]
    }
   ],
   "source": [
    "print(stats.f_oneway(*zip(*list(res_test))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Test de Kruskal-Wallis**  \n",
    "Rechazamos que las precisiones sean similares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KruskalResult(statistic=736.9516537594691, pvalue=6.837641730953702e-138)\n"
     ]
    }
   ],
   "source": [
    "print(stats.kruskal(*zip(*list(res_test))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = [etiquetas[i] for i in range(res_test.shape[1]) for _ in range(res_test.shape[0])]\n",
    "arr_test = res_test.flatten('F')\n",
    "resultados = pairwise_tukeyhsd(arr_test,labels)\n",
    "# resultados.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#seleccionamos el que tiene mejor media y vemos en el anterior cuales son iguales\n",
    "best_group = np.argmax(np.mean(res_test, axis = 0))\n",
    "best_group = etiquetas[int(best_group)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Figure(720x432)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(resultados.plot_simultaneous(comparison_name=best_group))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "resultados = resultados._results_table.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['MLPR adam 30 relu',\n",
       " 'MLPR adam 30 tanh',\n",
       " 'MLPR adam 50 relu',\n",
       " 'MLPR adam 50 tanh',\n",
       " 'SVM rfb 0.05 C1']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "group1 = resultados[0].index('group1')\n",
    "group2 = resultados[0].index('group2')\n",
    "reject = resultados[0].index('reject')\n",
    "best_groups = []\n",
    "for row in resultados[1:]:\n",
    "    if (row[group1] == str(best_group) or row[group2] == str(best_group)) and not row[reject]:\n",
    "        best_groups.append(row[group1])\n",
    "        best_groups.append(row[group2])\n",
    "best_groups.append(best_group)\n",
    "best_groups = set(best_groups)\n",
    "sorted(best_groups)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def performance_indexes(CM, PositiveClass):\n",
    "    classNum = len(CM)\n",
    "    TP = CM[PositiveClass, PositiveClass]\n",
    "    TN = 0\n",
    "    FP = 0\n",
    "    FN = 0\n",
    "    for real in range(classNum):\n",
    "        for predicted in range(classNum):\n",
    "            if (real != PositiveClass and predicted != PositiveClass):\n",
    "                TN += CM[real, predicted]\n",
    "            if (real != PositiveClass and predicted == PositiveClass):\n",
    "                FP += CM[real, predicted]\n",
    "            if (real == PositiveClass and predicted != PositiveClass):\n",
    "                FN += CM[real, predicted]\n",
    "    Sens = TP/(TP+FN)\n",
    "    Spec = TN/(TN+FP)\n",
    "    PPV = TP/(TP+FP)\n",
    "    NPV = TN/(TN+FN)\n",
    "    ACC = (TP+TN)/(TP+TN+FP+FN)\n",
    "    return Sens,Spec,PPV,NPV,ACC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MLPR adam 30 relu -> Sens: 0.92 +- 0.06, Spec: 0.99 +- 0.00, PPV: 0.96 +- 0.02, NPV: 0.99 +- 0.01, ACC: 0.98 +- 0.01\n",
      "MLPR adam 30 tanh -> Sens: 0.92 +- 0.05, Spec: 0.99 +- 0.00, PPV: 0.96 +- 0.03, NPV: 0.99 +- 0.01, ACC: 0.98 +- 0.01\n",
      "MLPR adam 50 relu -> Sens: 0.95 +- 0.05, Spec: 0.99 +- 0.00, PPV: 0.97 +- 0.02, NPV: 0.99 +- 0.01, ACC: 0.99 +- 0.01\n",
      "MLPR adam 50 tanh -> Sens: 0.95 +- 0.03, Spec: 1.00 +- 0.00, PPV: 0.97 +- 0.02, NPV: 0.99 +- 0.01, ACC: 0.99 +- 0.01\n",
      "SVM rfb 0.05 C1 -> Sens: 0.97 +- 0.02, Spec: 0.99 +- 0.00, PPV: 0.95 +- 0.02, NPV: 0.99 +- 0.00, ACC: 0.99 +- 0.00\n"
     ]
    }
   ],
   "source": [
    "for etiqueta in sorted(best_groups):\n",
    "    i = etiquetas.index(etiqueta)\n",
    "    m_min = i*30\n",
    "    m_max = (i+1)*30\n",
    "    current_model = model[m_min:m_max]\n",
    "    Sens_l = []\n",
    "    Spec_l = []\n",
    "    PPV_l = []\n",
    "    NPV_l = []\n",
    "    ACC_l = []\n",
    "    for idx, test_index in enumerate(test_indices[i]):\n",
    "        X_test, y_test = X[test_index], y[test_index]\n",
    "        y_pred = current_model[idx].predict(X_test)\n",
    "        CM = confusion_matrix(y_test, y_pred)\n",
    "        Sens,Spec,PPV,NPV,ACC = performance_indexes(CM,1)\n",
    "        Sens_l.append(Sens)\n",
    "        Spec_l.append(Spec)\n",
    "        PPV_l.append(PPV)\n",
    "        NPV_l.append(NPV)\n",
    "        ACC_l.append(ACC)\n",
    "    print(etiqueta,('-> Sens: {:.2f} +- {:.2f}, Spec: {:.2f} +- {:.2f}, ' +\n",
    "           'PPV: {:.2f} +- {:.2f}, NPV: {:.2f} +- {:.2f}, ACC: {:.2f} +- {:.2f}').format(\n",
    "        np.mean(Sens_l), np.std(Sens_l),\n",
    "        np.mean(Spec_l), np.std(Spec_l),\n",
    "        np.mean(PPV_l), np.std(PPV_l),\n",
    "        np.mean(NPV_l), np.std(NPV_l),\n",
    "        np.mean(ACC_l), np.std(ACC_l)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Escogemos el modelo SVM rbf con gamma = 0.05 como el más sencillo de los mejores**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------------------------------------------------------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DT Normal: 0.97 +- 0.01\n",
      "DT Profundidad: 0.94 +- 0.01\n",
      "DT Minimo de muestras por hoja: 0.97 +- 0.01\n",
      "DT Minimo de muestras en subarbol: 0.97 +- 0.01\n",
      "DT Minimo de impureza: 0.85 +- 0.01\n",
      "LDA lsqr: 0.94 +- 0.01\n",
      "LDA eigen: 0.85 +- 0.01\n",
      "LDA svd: 0.94 +- 0.01\n",
      "QDA: 0.97 +- 0.01\n",
      "SVM poly 2º C1: 0.94 +- 0.01\n",
      "SVM poly 3º C1: 0.95 +- 0.01\n",
      "SVM poly 4º C1: 0.95 +- 0.01\n",
      "SVM rfb auto C1: 0.96 +- 0.01\n",
      "SVM rfb 0.05 C1: 0.99 +- 0.00\n",
      "SVM rfb 0.1 C1: 0.98 +- 0.01\n",
      "SVM rfb 0.2 C1: 0.94 +- 0.01\n",
      "MLPR sgd 10 relu: 0.92 +- 0.02\n",
      "MLPR sgd 30 relu: 0.93 +- 0.01\n",
      "MLPR sgd 50 relu: 0.93 +- 0.01\n",
      "MLPR adam 10 relu: 0.97 +- 0.01\n",
      "MLPR adam 30 relu: 0.98 +- 0.01\n",
      "MLPR adam 50 relu: 0.99 +- 0.01\n",
      "MLPR sgd 10 tanh: 0.92 +- 0.01\n",
      "MLPR sgd 30 tanh: 0.93 +- 0.01\n",
      "MLPR sgd 50 tanh: 0.93 +- 0.01\n",
      "MLPR adam 10 tanh: 0.97 +- 0.01\n",
      "MLPR adam 30 tanh: 0.98 +- 0.01\n",
      "MLPR adam 50 tanh: 0.99 +- 0.01\n"
     ]
    }
   ],
   "source": [
    "for ind, tag in enumerate(etiquetas):\n",
    "    mean_test = np.mean(res_test[:,ind])\n",
    "    std_test = np.std(res_test[:,ind])\n",
    "    print('{}: {:.2f} +- {:.2f}'.format(tag, mean_test, std_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FIN"
   ]
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}