diff --git a/2017/07-decision-tree/resp_DecisionTree_FranciscoMatheusPinheiroNeryBarbosa.ipynb b/2017/07-decision-tree/resp_DecisionTree_FranciscoMatheusPinheiroNeryBarbosa.ipynb new file mode 100644 index 0000000..a27c80a --- /dev/null +++ b/2017/07-decision-tree/resp_DecisionTree_FranciscoMatheusPinheiroNeryBarbosa.ipynb @@ -0,0 +1,551 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Decision Tree" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Você pode baixar o dataset em https://archive.ics.uci.edu/ml/datasets/Car+Evaluation." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import math\n", + "import numpy as np\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "headers = [\"buying\", \"maint\", \"doors\", \"persons\",\"lug_boot\", \"safety\", \"class\"]\n", + "data = pd.read_csv(\"carData.csv\", header=None, names=headers)\n", + "\n", + "data = data.take(np.random.permutation(len(data)))\n", + "#data.sample(frac=1).reset_index(drop=true) #shuffle (Felipe)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "No código acima, faremos a leitura do arquivo, informando que não há cabeçário (obrigatório) e a nossa coluna 6 (0-6) representa a label" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
buyingmaintdoorspersonslug_bootsafetyclass
583highhigh34bigmedacc
508highvhigh4moremedmedunacc
1098medmed2moresmalllowunacc
680highmed32medhighunacc
795highlow34medlowunacc
\n", + "
" + ], + "text/plain": [ + " buying maint doors persons lug_boot safety class\n", + "583 high high 3 4 big med acc\n", + "508 high vhigh 4 more med med unacc\n", + "1098 med med 2 more small low unacc\n", + "680 high med 3 2 med high unacc\n", + "795 high low 3 4 med low unacc" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "buying object\n", + "maint object\n", + "doors object\n", + "persons object\n", + "lug_boot object\n", + "safety object\n", + "class object\n", + "dtype: object" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.dtypes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "O problema é que nossos dados categóricos são strings. Então precisamos converter em representantes numéricos para aplicarmos no algoritmo" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
buyingmaintdoorspersonslug_bootsafety
class
0001102
2032212
2220221
2021010
2011111
\n", + "
" + ], + "text/plain": [ + " buying maint doors persons lug_boot safety\n", + "class \n", + "0 0 0 1 1 0 2\n", + "2 0 3 2 2 1 2\n", + "2 2 2 0 2 2 1\n", + "2 0 2 1 0 1 0\n", + "2 0 1 1 1 1 1" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "for h in headers:\n", + " data[h] = data[h].astype('category')\n", + " data[h] = data[h].cat.codes\n", + "\n", + "data.set_index(\"class\", inplace=True)\n", + "data.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Faremos a separação dos dados em conjunto de treino e teste" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "size = len(data)\n", + "trainSize = int(math.floor(size * 0.7))\n", + "trainData = data[:trainSize]\n", + "testData = data[trainSize:]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Agora ok!\n", + "Vamos ao que interessa..." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mnery/miniconda3/envs/ds/lib/python3.6/site-packages/ipykernel_launcher.py:2: DeprecationWarning: \n", + ".ix is deprecated. Please use\n", + ".loc for label based indexing or\n", + ".iloc for positional indexing\n", + "\n", + "See the documentation here:\n", + "http://pandas.pydata.org/pandas-docs/stable/indexing.html#ix-indexer-is-deprecated\n", + " \n" + ] + }, + { + "data": { + "text/plain": [ + "DecisionTreeClassifier(class_weight=None, criterion='entropy', max_depth=None,\n", + " max_features=None, max_leaf_nodes=None,\n", + " min_impurity_decrease=0.0, min_impurity_split=None,\n", + " min_samples_leaf=1, min_samples_split=2,\n", + " min_weight_fraction_leaf=0.0, presort=False, random_state=None,\n", + " splitter='best')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dTree = DecisionTreeClassifier(criterion=\"entropy\")\n", + "dTree.fit(trainData.ix[:,0:6], trainData.index)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mnery/miniconda3/envs/ds/lib/python3.6/site-packages/ipykernel_launcher.py:1: DeprecationWarning: \n", + ".ix is deprecated. Please use\n", + ".loc for label based indexing or\n", + ".iloc for positional indexing\n", + "\n", + "See the documentation here:\n", + "http://pandas.pydata.org/pandas-docs/stable/indexing.html#ix-indexer-is-deprecated\n", + " \"\"\"Entry point for launching an IPython kernel.\n" + ] + }, + { + "data": { + "text/plain": [ + "0.96146435452793833" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dTree.predict(testData.ix[:, 0:6])\n", + "dTree.score(testData.ix[:, 0:6], testData.index)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### Atividades\n", + "\n", + "1. Utilizamos a medida de Entropia como fator de decisão (medida de impureza de um nó). Teste o mesmo conjunto \n", + "randômico de dados para a medida Gini e compare os resultados.\n", + "Ref1.: http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier\n", + "Ref2.: https://en.wikipedia.org/wiki/Decision_tree_learning\n", + "\n", + "2. Aplique Decision Tree em outro dataset (link abaixo) e analise os resultados. Procure identificar (se há) relações entre as features (correlacionadas, por exemplo) e faça testes eliminando as que você achar desnecessárias, de forma a tentar melhorar seu classificador, seja em predição ou perfomance.\n", + "Dataset: https://archive.ics.uci.edu/ml/datasets/Wine+Quality\n", + "\n", + "3. Execute a função abaixo para gerar a árvore que representa seu classificador (ambos utilizando entropia e gini como medidas). Analise a saida, entendendo como ela foi criada e os seus respectivos valores em relação a medida utilizada. Reflexão: seria possível construir nosso classificador apenas utilizando a estrutura condicional if-else?\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_tree(tree, feature_names):\n", + " \"\"\"Cria png que representa a arvore gerada.\n", + "\n", + " Args\n", + " ----\n", + " tree -- DecsisionTree.\n", + " feature_names -- vetor com os nomes das features.\n", + " \"\"\"\n", + " with open(\"dt.dot\", 'w') as f:\n", + " export_graphviz(tree, out_file=f,\n", + " feature_names=feature_names)\n", + "\n", + " command = [\"dot\", \"-Tpng\", \"dt.dot\", \"-o\", \"dt.png\"]\n", + " try:\n", + " subprocess.check_call(command)\n", + " except:\n", + " exit(\"Nao foi possivel gerar a arvore.\")\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "rf = []\n", + "for i in range(1,100):\n", + " d_tree = RandomForestClassifier(n_estimators=i, criterion='gini')\n", + " d_tree.fit(trainData, trainData.index)\n", + " d_tree.predict(testData.iloc[:, 0:6])\n", + " rf.append(d_tree.score(testData, testData.index))" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(rf)\n", + "plt.xlabel('Arv')\n", + "plt.ylabel('scr')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.976878612717\n", + "63\n" + ] + } + ], + "source": [ + "print(rf[np.argmax(rf)])\n", + "print(np.argmax(rf))" + ] + }, + { + "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": 1 +}