Consumo de Álcool por Estudantes

Universidade Federal do Rio de Janeiro Escola Politécnica COC361 - Inteligência Computacional Consumo de Álcool por Estudantes Professor: Alexandre Evsukoff Período: 2016/2 Estudantes: Rafael Gonçalves Damasceno DRE: 114009017 Rodrigo Carvalho Ribeiro de Jesus DRE: 114039371 Rio de Janeiro, RJ 11 de dezembro de 2016

Sumário Introdução 2 Propósito do Documento 2 Escopo do Projeto e formulação do problema 2 Apresentação da Tecnologia 2 Metodologia 3 Resultados 5 Regressão Logística 5 Bayesiano Multinomial 6 Redes Neurais 7 Duas camadas intermediárias com 2 neurônios cada 8 Duas camadas intermediárias com 5 neurônios cada 9 Duas camadas intermediárias com 10 neurônios cada 10 Duas camadas intermediárias com 20 neurônios cada 11 Support Vector Machine (SVM) 11 Linear 12 Polinomial 13 Função de Base Radial (RBF) 14 Árvore de Decisão 14 Sem Limite 16 Profundidade 3 17 Profundidade 5 18 Floresta Aleatória 19 100 árvores 19 500 árvores 20 Avaliação e Conclusões 21 Pesquisa Bibliográfica 23 1

1. Introdução 1.1. Propósito do Documento Este documento representa o relatório final da disciplina Inteligência Computacional [COC361], ministrada pelo professor Alexandre Evsukoff, no período 2016/2. O objetivo deste relatório é documentar a classificação do dataset previamente selecionado para o relatório preliminar através de diversos modelos lineares e não-lineares, explicitando as escolhas feitas e uma análise comparativa dos resultados. Além disso, procura-se discutir os resultados obtidos neste relatório e como eles se relacionam com os encontrados utilizando elementos da análise estatística no relatório preliminar. O documento expõe a solidificação do entendimento dos conceitos e técnicas utilizadas dentro do propósito da disciplina. 1.2 Escopo do Projeto e formulação do problema Inspirado no contexto de consumo de álcool entre estudantes, o projeto elaborado faz uso de um dataset disponibilizado no portal UC Irvine Machine Learning Repository, o mesmo utilizado no relatório preliminar. Esse dataset também traz informações sobre a vida doméstica dos alunos e sobre seu desempenho acadêmico. O projeto, desenvolvido em Python, tem como objetivo analisar os dados em relação ao consumo de álcool e as características pertencentes aos estudantes entrevistados. Dessa forma, espera-se realizar a classificação dentro deste dataset e desenvolver a capacidade de predição do consumo de álcool de acordo com as características dos atributos envolvidos. 2. Apresentação da Tecnologia Para desenvolver o escopo do projeto foi decidido utilizar a linguagem Python, devido não só à sua versatilidade mas também por ser uma linguagem com a qual os participantes do projeto já tinham trabalhado anteriormente. Além disso, é uma linguagem amplamente usada por cientistas de dados do planeta inteiro, o que gera uma grande disponibilidade de bibliotecas voltadas para o assunto e também conteúdo de suporte a essas bibliotecas. Dessa forma, foram selecionadas algumas dessas bibliotecas para auxiliar no trabalho de data analysis, data mining e machine learning. Dessas bibliotecas, podemos destacar: matplotlib - biblioteca para gerar gráficos a partir do Python. pandas - estruturas específicas para análise de dados. numpy - pacote de computação numérica otimizado para processos que envolvam arrays e matrizes. scipy - rotinas para trabalhar em diversas áreas como integração numérica, otimização e processamento de sinais. scikit-learn - ferramentas para análise e mineração de dados. patsy - ferramentas para utilização em modelos estatísticos. 2

Além dessas bibliotecas, usamos também o software ipython, um interpretador interativo que traz diversas melhorias em relação ao interpretador padrão do Python, podendo ser destacadas a possibilidade de syntax highlighting, guardar comandos entre sessões, autocomplete, e também de exportar os comandos usados em uma determinada sessão para um arquivo externo. A decisão por usar um interpretador está relacionada com a possibilidade de acompanhar o resultado diretamente quando o comando é inserido, o que facilita a exploração dos dados. 3. Metodologia O dataset escolhido possui 1044 registros, distribuídos em 649 registros relacionados à disciplina de português e 395 à matemática. Após o relatório preliminar, no qual foi realizada uma análise estatística nos dois arquivos separadamente, procurou-se juntar os dois arquivos para o tratamento do relatório final. Entretanto, haviam 382 registros de intercessão entre os arquivos, de forma que só seriam adicionado 13 registros, e perderíamos informações como as notas dos alunos. Dessa forma, para o trabalho de classificação foi decidido utilizar o arquivo relacionado à disciplina de português, por possuir um número maior de registros. Dentre as variáveis do dataset, duas estão relacionadas ao consumo de álcool entre os estudantes, Walc e Dalc, que representam, respectivamente, o consumo no fim de semana e durante a semana. Essas variáveis estão codificadas em uma escala de 1 a 5, variando de "muito baixo" até "muito alto". Através da análise do dataset podemos observar que se trata de um problema desbalanceado. A distribuição pode ser observado nos gráficos apresentados na Figura 1. Figura 1 : Distribuição das variáveis Dalc e Walc. Munidos dessas informações, definimos Walc como target, já que essa variável possui uma distribuição menos assimétrica. Podemos observar pelos gráficos da Figura 1 que uma parcela significativa dos estudantes não consome álcool (ou consome muito 3

pouco) durante a semana, mas esse número é drasticamente reduzido se avaliarmos o consumo durante os finais de semana. Como o problema ainda se trata de uma distribuição significativamente desbalanceada das classes, decidimos por recodificar as variáveis Walc e Dalc através da união das opções 4 e 5 (que representam consumo de álcool "alto" e "muito alto"), de forma que o problema se encontre mais próximo de uma distribuição uniforme. Além disso, considerando que os dados foram levantados através de um questionário e são informações subjetivas, o significado de "alto" e "muito alto" pode ser interpretado de forma diferente entre os estudantes. A outra opção seria fazer um downsample dos registros, mas julgamos que o dataset não era grande o suficiente para que isso pudesse ser feito sem perdas significativas. O resultado da nova distribuição pode ser observado nos gráficos apresentados na Figura 2. Figura 2 : Distribuição das variáveis Dalc e Walc recodificadas. Podemos observar que a classe 1 continua com um número relativo de registros muito maior, mas a expectativa foi de que a combinação das duas menores classes gerasse resultados mais satisfatórios, pela utilização de uma distribuição mais balanceada. Neste relatório iremos avaliar o problema de 4 classes com a presença da variável Dalc (o quanto os alunos bebem durante a semana) dentro do modelo e sem a presença da mesma, procurando verificar a influência dessa variável nos resultados. Para classificar os registros foram utilizadas ferramentas presentes no scikit-learn para avaliar diferentes modelos, desde os mais simples até outros mais complexos, buscando aquele dentro do problema proposto que pudesse obter os melhores resultados. Ao final comparamos os resultados para decidir os modelos que melhor se aplicam ao problema. Para a avaliação dos resultados foi utilizado validação cruzada de 10 ciclos, evitando possível overfitting, e métricas como precisão (fração de instâncias recuperadas que foram previstas corretamente), recall (fração de instâncias de uma classe que foram previstas como sendo daquela classe), f1 (média ponderada entre precisão e recall para cada classe), f1-weighted (média ponderada dos resultados do f1-score levando em conta o 4

tamanho de cada classe) e erro quadrático médio (média da diferença entre o valor do estimador e do valor real ao quadrado) de cada modelo. 4. Resultados Nesta seção serão apresentadas as descrições dos modelos usados e breves comentários sobre as peculiaridades encontradas dentro deles. Na seção 5 esses resultados serão analisados de forma complementar, chegando às conclusões do relatório. 4.1. Regressão Logística A Regressão Logística se trata de um modelo relativamente simples, que assume que há um limite de decisão linear descoberto através de suposições probabilísticas. É importante ressaltar que o fato de não ser um algoritmo tão complexo não significa que os resultados serão necessariamente menos eficazes, pois essa relação depende do problema a ser analisado. No problema deste relatório a regressão logística teve resultados melhores do que outros modelos mais complexos, o que pode ser percebido dentro das comparações na seção 5. Figura 3 : Matriz d e Confusão Normalizada para o modelo de Regressão Logística. Tabela 1: Resultados do modelo de Regressão Logística com Dalc. 1.0 0.54 0.81 0.65 247 2.0 0.24 0.14 0.18 150 3.0 0.26 0.07 0.12 120 4.0 0.58 0.69 0.63 132 5

avg / total 0.43 0.49 0.44 649 Tabela 2: Resultados do modelo de Regressão Logística sem Dalc. 1.0 0.50 0.73 0.59 247 2.0 0.26 0.16 0.20 150 3.0 0.08 0.02 0.03 120 4.0 0.50 0.64 0.56 132 avg / total 0.37 0.45 0.39 649 4.2. Bayesiano Multinomial A família de classificadores Bayesianos são baseados a partir da aplicação do Teorema de Bayes, o algoritmo é visto como relativamente simples por considerar que existe uma forte independência entre os atributos. Essa suposição é considerada como uma suposição inocente, o que dá o nome desse classificador em inglês: Naive Bayes, ou, em tradução livre, "Bayes Inocente". Dentro da ferramenta usada, scikit-learn, existem três modelos de classificação bayesiana disponíveis: Bernoulli, Multinomial, e Gaussiano. Analisando as opções, Bernoulli foi descartado por tomar como certo que as variáveis seriam todas binárias, o que não corresponde ao dataset utilizado nesse problema. Gaussiano toma como certo que as variáveis seguem uma distribuição normal, o que também não é verdade. Por isso, o modelo de classificação bayesiana apresentado neste relatório é o Bayesiano Multinomial. Os outros modelos foram executados a título de curiosidade e foi possível verificar experimentalmente que o Multinomial apresentava a melhor previsão para o problema em questão. Figura 4 : Matriz de Confusão Normalizada para o modelo Bayesiano Multinomial. 6

Tabela 3: Resultados do modelo Bayesiano Multinomial com Dalc. 1.0 0.47 0.74 0.58 247 2.0 0.26 0.13 0.17 150 3.0 0.14 0.02 0.03 120 4.0 0.45 0.59 0.51 132 avg / total 0.36 0.44 0.37 649 Tabela 4: Resultados do modelo Bayesiano Multinomial sem Dalc. 1.0 0.46 0.73 0.56 247 2.0 0.24 0.09 0.13 150 3.0 0.16 0.03 0.04 120 4.0 0.40 0.54 0.46 132 avg / total 0.34 0.41 0.35 649 4.3. Redes Neurais Redes neurais fazem uma abordagem diferente para resolver os problemas de classificação, usando certo número de unidades simples de processamento altamente interconectadas (neurônios) que se esforçam paralelamente na busca da classificação seguindo os padrões presentes. Neste relatório usamos redes neurais com duas camadas intermediárias, com número de neurônios/camada variando de 2 até 20. O resultado dessas alterações afetam o aprendizado que cada camada pode fazer sobre os dados; o objetivo é evitar o overlearning devido ao excesso no número de neurônios nas camadas intermediárias e também evitar a ausência de um ajuste fino o suficiente para representar de maneira acurada o problema. O primeiro modelo testado, com duas camadas intermediárias de dois neurônios cada, apresentou o problema citado anteriormente relacionado à ausência da possibilidade de um ajuste fino. Pode-se notar como o modelo realizou a classificação atribuindo todos os registros do dataset como sendo da classe 1, a classe majoritária. Esse enviesamento da classificação diminuiu com o aumento da capacidade de ajuste das camadas, ou seja, o aumento no número de neurônios. 7

4.3.1. Duas camadas intermediárias com 2 neurônios cada Figura 5 : Matriz de Confusão Normalizada para o modelo de Rede Neural (2, 2). Tabela 5: Resultados do modelo Rede Neural (2, 2) com Dalc. 1.0 0.38 1.00 0.55 247 2.0 0.00 0.00 0.00 150 3.0 0.00 0.00 0.00 120 4.0 0.00 0.00 0.00 132 avg / total 0.14 0.38 0.21 649 Tabela 6: Resultados do modelo Rede Neural (2, 2) sem Dalc. 1.0 0.38 1.00 0.55 247 2.0 0.00 0.00 0.00 150 3.0 0.00 0.00 0.00 120 4.0 0.00 0.00 0.00 132 avg / total 0.14 0.38 0.21 649 8

4.3.4. Duas camadas intermediárias com 20 neurônios cada Figura 8 : Matriz de Confusão Normalizada para o modelo de Rede Neural (20, 20). Tabela 11: Resultados do modelo Rede Neural (20, 20) com Dalc. 1.0 0.59 0.74 0.65 247 2.0 0.28 0.25 0.27 150 3.0 0.28 0.16 0.20 120 4.0 0.59 0.61 0.60 132 avg / total 0.46 0.49 0.47 649 Tabela 12: Resultados do modelo Rede Neural (20, 20) sem Dalc. 1.0 0.49 0.71 0.58 247 2.0 0.23 0.17 0.19 150 3.0 0.17 0.03 0.06 120 4.0 0.47 0.57 0.51 132 avg / total 0.37 0.43 0.38 649 4.4. Support Vector Machine (SVM) Support Vector Machine se refere a um conjunto de métodos de aprendizado supervisionado que analisam os dados e reconhecem padrões buscando a melhor classificação que mantenha a maior separação entre as classes. Apesar de ser um modelo computacionalmente custoso, foi possível executar diferentes tipos de kernel usados pelo 11

algoritmo já que o problema trata de um dataset relativamente pequeno. Os diferentes kernels estão relacionados à função de similaridade que será usada pelo algoritmo. O fato do modelo SVM Linear ter tido o melhor resultado dos três avaliados pode ser associado à forma de separação do problema. 4.4.1. Linear Figura 9 : Matriz de Confusão Normalizada para o modelo SVM Linear. Tabela 13: Resultados do modelo SVM Linear com Dalc. 1.0 0.54 0.87 0.67 247 2.0 0.25 0.11 0.16 150 3.0 0.28 0.14 0.19 120 4.0 0.62 0.59 0.61 132 avg / total 0.45 0.51 0.45 649 Tabela 14: Resultados do modelo SVM Linear sem Dalc. 1.0 0.50 0.74 0.59 247 2.0 0.25 0.21 0.23 150 3.0 0.17 0.06 0.09 120 4.0 0.59 0.52 0.55 132 avg / total 0.40 0.44 0.41 649 12

4.4.2. Polinomial Figura 10 : Matriz de Confusão Normalizada para o modelo SVM Polinomial. Tabela 15: Resultados do modelo SVM Polinomial com Dalc. 1.0 0.51 0.58 0.54 247 2.0 0.23 0.23 0.23 150 3.0 0.27 0.23 0.25 120 4.0 0.55 0.49 0.52 132 avg / total 0.41 0.42 0.41 649 Tabela 16: Resultados do modelo SVM Polinomial sem Dalc. 1.0 0.48 0.55 0.51 247 2.0 0.20 0.19 0.20 150 3.0 0.24 0.23 0.24 120 4.0 0.46 0.35 0.40 132 avg / total 0.37 0.37 0.36 649 13

4.4.3. Função de Base Radial (RBF) Figura 11 : Matriz de Confusão Normalizada para o modelo SVM RBF. Tabela 17: Resultados do modelo SVM RBF com Dalc. 1.0 0.46 0.88 0.61 247 2.0 0.14 0.03 0.05 150 3.0 0.15 0.03 0.04 120 4.0 0.58 0.55 0.57 132 avg / total 0.36 0.46 0.37 649 Tabela 18: Resultados do modelo SVM RBF sem Dalc. 1.0 0.46 0.89 0.60 247 2.0 0.15 0.03 0.05 150 3.0 0.00 0.00 0.00 120 4.0 0.50 0.52 0.51 132 avg / total 0.31 0.45 0.34 649 4.5. Árvore de Decisão Árvore de decisão é uma ferramenta amplamente usada em data mining com o objetivo de criar um modelo capaz de predizer o target do problema através de uma sequência de entradas. Este modelo permite visualizar o fluxograma de decisão e assim aferir os atributos que desempenham maior grau de decisão dentro do problema. Para o 14

problema apresentado neste relatório foram usados diferentes configurações de níveis de profundidade máxima para o algoritmo: sem profundidade máxima, 3, e 5. É chamada de profundidade a distância do caminho da raiz da árvore até a folha. Algoritmos para construção de árvores de decisão buscam a cada etapa o atributo que melhor divida o conjunto de itens de forma binária. Diversas métricas podem ser utilizadas, geralmente medindo a homogeneidade da variável target. É importante ressaltar que o modelo de árvore de decisão é considerado um modelo altamente instável, ou seja, pequenas mudanças no conjunto de dados sendo analisado (como um conjunto de treinamento diferente) podem gerar árvores completamente diferentes. Com a utilização da validação cruzada, buscamos eliminar, ou pelo menos reduzir, o impacto dessa instabilidade nos resultados do modelo. Entretanto, a título de curiosidade, colocamos uma das árvores de decisão gerada, de forma a permitir perceber as principais variáveis usadas dentro dela para as decisões. Figura 12 : Árvore de Decisão gerada com Dalc com profundidade 3. Figura 13 : Árvore de Decisão gerada sem Dalc com profundidade 3. Com relação à profundidade da árvore quanto menor for a profundidade maior será a capacidade de generalização, entretanto menor a capacidade de ajuste. Dessa forma, é necessário encontrar um ponto ótimo que gere um ajuste fino o suficiente sem causar overfitting. 15

4.5.1. Sem Limite Figura 14 : Matriz de Confusão Normalizada para o modelo Árvore de Decisão sem Limite. Tabela 19: Resultados do modelo Árvore de Decisão sem Limite com Dalc. 1.0 0.54 0.53 0.54 247 2.0 0.25 0.23 0.24 150 3.0 0.25 0.28 0.26 120 4.0 0.52 0.52 0.52 132 avg / total 0.42 0.41 0.41 649 Tabela 20: Resultados do modelo Árvore de Decisão sem Limite sem Dalc. 1.0 0.44 0.42 0.43 247 2.0 0.19 0.21 0.20 150 3.0 0.21 0.22 0.21 120 4.0 0.38 0.39 0.38 132 avg / total 0.33 0.33 0.33 649 16

4.5.2. Profundidade 3 Figura 15 : Matriz de Confusão Normalizada para o modelo Árvore de Decisão de profundidade 3. Tabela 21: Resultados do modelo Árvore de Decisão de profundidade 3 com Dalc. 1.0 0.53 0.92 0.68 247 2.0 0.24 0.09 0.13 150 3.0 0.29 0.10 0.15 120 4.0 0.64 0.61 0.63 132 avg / total 0.44 0.51 0.44 649 Tabela 22: Resultados do modelo Árvore de Decisão de profundidade 3 sem Dalc. 1.0 0.44 0.89 0.59 247 2.0 0.15 0.01 0.02 150 3.0 0.10 0.01 0.02 120 4.0 0.56 0.57 0.57 132 avg / total 0.34 0.46 0.35 649 17

4.5.3. Profundidade 5 Figura 16 : Matriz de Confusão Normalizada para o modelo Árvore de Decisão de profundidade 5. Tabela 23: Resultados do modelo Árvore de Decisão de profundidade 5 com Dalc. 1.0 0.53 0.85 0.65 247 2.0 0.32 0.17 0.22 150 3.0 0.39 0.19 0.26 120 4.0 0.61 0.53 0.57 132 avg / total 0.47 0.51 0.46 649 Tabela 24: Resultados do modelo Árvore de Decisão de profundidade 5 sem Dalc. 1.0 0.45 0.70 0.55 247 2.0 0.22 0.15 0.18 150 3.0 0.11 0.04 0.06 120 4.0 0.53 0.46 0.49 132 avg / total 0.35 0.40 0.36 649 18

4.6. Floresta Aleatória As florestas aleatórias ou as florestas de decisão aleatórias são métodos de aprendizagem de conjunto ( ensemble) que operam construindo uma multidão de árvores da decisão no tempo do treinamento. Cada árvore de decisão dá uma classificação, e pode-se dizer que a árvore "vota" por aquela classe. A floresta escolhe a classificação que obteve o maior número de votos. O objetivo disso é tratar a instabilidade do modelo de árvore de decisão. Para este relatório foram gerados 2 modelos de Floresta Aleatória, com 100 árvores e com 500 árvores. 4.6.1. 100 árvores Figura 17 : Matriz de Confusão Normalizada para o modelo de Floresta Aleatória com 100 árvores. Tabela 25: Resultados do modelo Floresta Aleatória com 100 árvores com Dalc. 1.0 0.56 0.85 0.67 247 2.0 0.29 0.13 0.18 150 3.0 0.40 0.23 0.29 120 4.0 0.64 0.65 0.64 132 avg / total 0.48 0.53 0.48 649 19

Tabela 26: Resultados do modelo Floresta Aleatória com 100 árvores sem Dalc. 1.0 0.46 0.76 0.57 247 2.0 0.23 0.12 0.16 150 3.0 0.13 0.03 0.05 120 4.0 0.55 0.54 0.55 132 avg / total 0.36 0.43 0.37 649 4.6.2. 500 árvores Figura 18 : Matriz de Confusão Normalizada para o modelo de Tabela 27: Resultados do modelo Floresta Aleatória com 500 árvores com Dalc. 1.0 0.54 0.87 0.67 247 2.0 0.25 0.09 0.14 150 3.0 0.51 0.21 0.30 120 4.0 0.63 0.70 0.66 132 avg / total 0.49 0.53 0.47 649 20

Tabela 28: Resultados do modelo Floresta Aleatória com 500 árvores sem Dalc. 1.0 0.44 0.76 0.56 247 2.0 0.23 0.12 0.16 150 3.0 0.18 0.03 0.06 120 4.0 0.55 0.52 0.53 132 avg / total 0.37 0.43 0.37 649 5. Avaliação e Conclusões Dentro da execução dos diferentes modelos pode-se notar que não existe um modelo único que irá se comportar com a melhor classificação no problema apresentado. Há uma sequência de ajustes que podem ser realizados em cada modelo com o objetivo de tornar sua classificação mais precisa (precision), mais completa (em relação a uma classe de interesse específica) (recall), ou com menor estimativa escolhida de erro e consequentemente ultrapassar outros modelos que se saíram melhor neste relatório. Na avaliação do problema e com os modelos escolhidos foi possível notar que o atributo Dalc (que representa o consumo de álcool pelos estudantes durante a semana) usualmente agrega uma melhoria considerável na classificação do problema. Entretanto, podemos considerar que o exercício sem a presença dessa variável faz mais sentido no mundo real, já que uma classificação sem ter informações explicitamente relacionadas ao consumo parece ter maior uso prático. É interessante evidenciar que o tamanho reduzido do dataset utilizado pode ter feito com que os modelos analisados durante o trabalho tivessem um desempenho abaixo do esperado. O que chama a atenção para, em vários momentos ao decorrer da disciplina, ter sido ressaltada a importância de uma quantidade suficientemente grande de dados para o estudo. Também é imprescindível ressaltar a gama de ferramentas que a biblioteca scikit-learn oferece, com uma vasta documentação que oferece um entendimento mais completo do funcionamento do algoritmo. É possível notar também que as variáveis que tiveram as maiores correlações com o target do problema, como verificado no Relatório 1, foram também as consideradas com maior grau de decisão pelo modelo da árvore de decisão. Destaca-se aqui a variável Dalc (quando presente no modelo), que apresentava a maior correlação com a variável Walc no relatório preliminar, além das variáveis goout e sex, referentes ao quando o aluno sai com os amigos e sexo do aluno (sendo 1 para masculino), respectivamente, que apresentaram correlações positivas de destaque. A comparação entre os modelos pode ser observado na Tabela 29 e 30, com a presença do atributo Dalc e sem, respectivamente. Tabela 29: Comparação dos resultados dos modelos sem Dalc. +-----------------------+----------------+--------------------+ Modelo f1_weighted Mean Squared Error 21

+-----------------------+----------------+--------------------+ Regressão Logística 0.386413275542 1.68567026194 Bayesiano Multinomial 0.344240820379 2.14637904468 RN (2,2) 0.209826284826 2.80123266564 RN (5,5) 0.382645534862 1.80123266564 RN (10,10) 0.388671822074 1.64714946071 RN (20,20) 0.37758626452 1.69183359014 SVM Linear 0.398438494741 1.58397534669 SVM Polinomial 0.35786943827 1.77349768875 SVM RBF 0.344095301114 1.95839753467 Decision Tree 0.324962121212 2.01232665639 Decision Tree (D=3) 0.457567016317 1.94761171032 Decision Tree (D=5) 0.402084061772 1.90446841294 Random Forest 100 0.445190122378 1.82434514638 Random Forest 500 0.438964889277 1.79969183359 +-----------------------+----------------+--------------------+ Tabela 30: Comparação dos resultados dos modelos com Dalc. +-----------------------+----------------+--------------------+ Modelo f1_weighted Mean Squared Error +-----------------------+----------------+--------------------+ Regressão Logística 0.434812656046 1.28659476117 Bayesiano Multinomial 0.367905590847 1.94298921418 RN (2,2) 0.209826284826 2.80123266564 RN (5,5) 0.275250639979 2.41910631741 RN (10,10) 0.475676239685 1.18798151002 RN (20,20) 0.46501996192 1.15562403698 SVM Linear 0.440060429655 1.23574730354 SVM Polinomial 0.404606236867 1.46995377504 SVM RBF 0.366374404309 1.72573189522 Decision Tree 0.41283289627 1.48690292758 Decision Tree (D=3) 0.51421474359 1.28043143297 Decision Tree (D=5) 0.505148601399 1.33281972265 Random Forest 100 0.515897435897 1.17411402157 Random Forest 500 0.535851544289 1.23728813559 +-----------------------+----------------+--------------------+ Os modelos que apresentaram um maior f1_weighted, a média ponderada dos valores de f1 de cada uma das classes, levando em conta a quantidade de registros de cada classe, e um menor erro quadrático médio, soma do quadrado dos erros de previsão, foram diferentes com e sem a presença da variável Dalc. Com Dalc, o modelo de Floresta Aleatória com 500 árvores apresentou maior f1_weighted e a Rede Neural com duas camadas intermediárias de 20 neurônios apresentou o menor erro quadrático médio. Sem Dalc, o modelo da árvore de decisão com profundidade 3 apresentou maior f1_weighted e o modelo SVM Linear apresentou menor erro quadrático médio. 22

Vale destacar que, na hipótese da presença da variável Dalc, o modelo de Floresta Aleatória com 500 árvores apresentou maior recall para a classe 4, onde estão os alunos que consomem uma maior quantidade de álcool, classe essa que dentro do target do problema se mostra como a de maior interesse em classificação. Sem essa variável, o modelo de Regressão Logística teve o melhor recall da classe 4. Esses resultados reforçam nossa conclusão de que diferentes modelos podem ser escolhidos como os mais adequados dependendo do seu objetivo, de forma que não existe um modelo chave que irá sempre ser a melhor opção. 6. Pesquisa Bibliográfica Using Data Mining To Predict Secondary School Student Alcohol Consumption. Fabio Pagnotta, Hossain Mohammad Amran Department of Computer Science,University of Camerino Livro Ensinando Máquinas - Autor: Alexandre G. Evsukoff Blog sobre Machine Learning https://ensinandomaquinasblog.wordpress.com/ Documentação do pandas http://pandas.pydata.org/pandas-docs/stable/ Trabalhando com DataFrames http://www.gregreda.com/2013/10/26/working-with-pandas-dataframes/ Paper sobre o uso do dataset https://www.researchgate.net/publication/296695247_using_data_mining_to_predic T_SECONDARY_SCHOOL_STUDENT_ALCOHOL_CONSUMPTION Logistic Regression with scikit-learn http://nbviewer.jupyter.org/gist/justmarkham/6d5c061ca5aee67c4316471f8c2ae976 Documentação do scikit-learn http://scikit-learn.org/stable/documentation.html Review on Methods to Fix Number of Hidden Neurons in Neural Networks https://www.hindawi.com/journals/mpe/2013/425740/ Random Forests, by Leo Breiman and Adele Cutler https://www.stat.berkeley.edu/~breiman/randomforests/cc_home.htm 23

I. Apêndice 1: Código gerado para o Relatório 1 # coding: utf-8 import pandas import numpy as np from matplotlib import cm as cm from matplotlib import pyplot as plt from prettytable import PrettyTable materia = raw_input('mat ou Por? ') # Abrindo o arquivo mat = pandas.read_csv('student-%s.csv' % materia, sep=';') # Adaptando os dados del mat['reason'] mat['school'] = mat['school'].apply(lambda x: 0 if x == 'GP' else 1) mat['sex'] = mat['sex'].apply(lambda x: 0 if x == 'F' else 1) mat['address'] = mat['address'].apply(lambda x: 0 if x == 'R' else 1) mat['famsize'] = mat['famsize'].apply(lambda x: 0 if x == 'LE3' else 1) mat['pstatus'] = mat['pstatus'].apply(lambda x: 0 if x == 'T' else 1) mat['mjob'] = mat['mjob'].apply(lambda x: 0 if x == 'at_home' else 1) mat['fjob'] = mat['fjob'].apply(lambda x: 0 if x == 'at_home' else 1) mat['guardian'] = mat['guardian'].apply(lambda x: 1 if x == 'other' else 0) for i in ['schoolsup', 'famsup', 'paid', 'activities', 'nursery', 'higher', 'internet', 'romantic']: mat[i] = mat[i].apply(lambda x: 1 if x == 'yes' else 0) print str(mat.isnull().values.sum()) + ' valores ausentes' # Visualização tabela = PrettyTable(['Variavel', 'Min', 'Max', 'Mean', 'Std', 'Qtl 25', 'Qtl 75']) n = int(np.sqrt(len(mat.columns)))+1 fig = plt.figure(figsize=(12,9)) for i in range(len(mat.columns)): c = mat.columns[i] v = mat[c] ax1 = fig.add_subplot(n, n, i) ax1.hist(v, bins=len(v.unique())) ax1.set_title(c + ' - ' + materia) ax1.set_xlabel('valor') ax1.set_ylabel('frequencia') ax1.axis('off') tabela.add_row([c, v.min(), v.max(), round(v.mean(), 3), round(v.std(), 3),\ round(v.quantile(.25), 3), round(v.quantile(.75), 3)]) plt.tick_params(labeltop='off', labelbottom='off') plt.savefig('histograma_' + materia + '.png') plt.close() with open('tabela-%s.html' % materia,'w') as file: file.write(tabela.get_html_string()) def correlation_matrix(df): fig = plt.figure() 24

ax1 = fig.add_subplot(111) cmap = cm.get_cmap('jet', 30) cax = ax1.imshow(df.corr(), interpolation="nearest", cmap=cmap, clim=[-1,1]) ax1.grid(true) plt.title('matriz de Correlacao - %s' % materia) labels = df.columns ax1.set_xticks(np.arange(len(df.columns))) ax1.set_yticks(np.arange(len(df.columns))) ax1.set_xticklabels(labels, fontsize=10, rotation='vertical') ax1.set_yticklabels(labels, fontsize=10) cbar = fig.colorbar(cax, ticks=[-1, -0.75, -0.5, -0.25, 0,.25,.5,.75,1]) fig.subplots_adjust(bottom=0.15) plt.savefig('correlacao_%s.png' % materia) def boxplot(df): fig = plt.figure() plt.title('boxplot - %s' % materia) ax = fig.add_subplot(111) ax.set_xticklabels(df.columns, fontsize=10, rotation='vertical') bp = ax.boxplot([df[k] for k in df.columns]) fig.subplots_adjust(bottom=0.15) plt.savefig('boxplot_%s.png' % materia) plt.close() boxplot(mat) correlation_matrix(mat) 25

II. Apêndice 2: Código gerado para o Relatório 2 # coding: utf-8 import pandas import itertools import numpy as np from patsy import dmatrices from prettytable import PrettyTable from matplotlib import pyplot as plt from scipy import stats from sklearn import svm, metrics, tree from sklearn import naive_bayes as nb from sklearn import linear_model as lm from sklearn import cross_validation as cv from sklearn.ensemble import RandomForestClassifier from sklearn.grid_search import RandomizedSearchCV from sklearn.neural_network import MLPClassifier from sklearn.externals.six import StringIO import pydotplus # Abrindo o arquivo df = pandas.read_csv('student-por.csv', sep=';') # Adaptando os dados (Relatorio 1) del df['reason'] df['school'] = df['school'].apply(lambda x: 0 if x == 'GP' else 1) df['sex'] = df['sex'].apply(lambda x: 0 if x == 'F' else 1) df['address'] = df['address'].apply(lambda x: 0 if x == 'R' else 1) df['famsize'] = df['famsize'].apply(lambda x: 0 if x == 'LE3' else 1) df['pstatus'] = df['pstatus'].apply(lambda x: 0 if x == 'T' else 1) df['mjob'] = df['mjob'].apply(lambda x: 0 if x == 'at_home' else 1) df['fjob'] = df['fjob'].apply(lambda x: 0 if x == 'at_home' else 1) df['guardian'] = df['guardian'].apply(lambda x: 1 if x == 'other' else 0) for i in ['schoolsup', 'famsup', 'paid', 'activities', 'nursery', 'higher', 'internet', 'romantic']: df[i] = df[i].apply(lambda x: 1 if x == 'yes' else 0) # Pie Chart def pie(df, v, title): t = df[v].value_counts().to_dict() colors = ['gold', 'yellowgreen', 'lightcoral', 'lightskyblue', 'mediumslateblue'] plt.pie(t.values(), labels=t.keys(), colors=colors, shadow=true, autopct='%1.1f%%') plt.axis('equal') plt.savefig(title + 'png', transparent=true) plt.close() # Preparando para Relatorio 2 pie(df, 'Walc', 'Walc-5classes') pie(df, 'Dalc', 'Dalc-5classes') df['walc'] = df['walc'].apply(lambda x: 4 if x == 5 else x) df['dalc'] = df['dalc'].apply(lambda x: 4 if x == 5 else x) 26

pie(df, 'Walc', 'Walc-4classes') pie(df, 'Dalc', 'Dalc-4classes') del df['dalc'] colunas = reduce(lambda x, y: x if y == 'Walc' else x + ' + ' + y, df.columns) y, X = dmatrices('walc ~ ' + colunas, df, return_type='dataframe') y = np.ravel(y) class_names = range(1,5) # Confusion Matrix def plot_confusion_matrix(cm, classes, normalize=false, title='matriz de Confusao', cmap=plt.cm.blues): cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] for i in range(len(cm)): for k in range(len(cm[i])): cm[i][k] = round(cm[i][k]*100, 1) plt.imshow(cm, interpolation='nearest', cmap=cmap, clim=[0,100]) plt.title(title) tick_marks = np.arange(len(classes)) plt.xticks(tick_marks, classes, rotation=45) plt.yticks(tick_marks, classes) plt.colorbar(ticks=[0,25,50,75,100]) thresh = 70 for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])): plt.text(j, i, cm[i, j], horizontalalignment="center", color="white" if cm[i, j] > thresh else "black") plt.tight_layout() plt.subplots_adjust(bottom=0.15) plt.ylabel('classe correta') plt.xlabel('classe predita') tabela = PrettyTable(['Modelo', 'f1', 'Mean Squared Error']) # Regressao Logistica # Modelo logistic = lm.logisticregression().fit(x, y) predicted = cv.cross_val_predict(logistic, X, y, cv=10) # Cross Validation scores = cv.cross_val_score(lm.logisticregression(), X, y, cv=10, scoring='f1_weighted') print 'Regressao Logistica' print scores.mean() # Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'w') as text_file: text_file.write(cr) 27

text_file.write('\n') mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['regressao Logistica', scores.mean(), mse]) # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('cm_rl_n.png', transparent=true) plt.close() print '\n' # Classificador Bayesiano (Multinomial) # Modelo bayes = nb.multinomialnb() bayes = bayes.fit(x, y) predicted = cv.cross_val_predict(bayes, X, y, cv=10) # Cross Validation scores = cv.cross_val_score(nb.multinomialnb(), X, y, cv=10, scoring='f1_weighted') print 'bayesiano multinomial' print scores.mean() # Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'a') as text_file: text_file.write(cr) text_file.write('\n') mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['bayesiano Multinomial', scores.mean(), mse]) # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('cm_bayes_n.png', transparent=true) plt.close() ## Modelo mlp = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(5,5), random_state=1) mlp = mlp.fit(x, y) predicted = cv.cross_val_predict(mlp, X, y, cv=10) # Cross Validation scores = cv.cross_val_score(mlpclassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(5,5), random_state=1), X, y, cv=10, scoring='f1_weighted') print 'redes neurais 55' print scores.mean() 28

mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['rn (5,5)', scores.mean(), mse]) # Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'a') as text_file: text_file.write(cr) text_file.write('\n') # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('cm_rn_n55.png', transparent=true) plt.close() ## Modelo mlp = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(20,20), random_state=1) mlp = mlp.fit(x, y) predicted = cv.cross_val_predict(mlp, X, y, cv=10) # Cross Validation scores = cv.cross_val_score(mlpclassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(20,20), random_state=1), X, y, cv=10, scoring='f1_weighted') print 'redes neurais 2020' print scores.mean() mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['rn (20,20)', scores.mean(), mse]) # Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'a') as text_file: text_file.write(cr) text_file.write('\n') # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('cm_rn_n2020.png', transparent=true) plt.close() ## Modelo mlp = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(10,10), random_state=1) mlp = mlp.fit(x, y) predicted = cv.cross_val_predict(mlp, X, y, cv=10) 29

# Cross Validation scores = cv.cross_val_score(mlpclassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(10,10), random_state=1), X, y, cv=10, scoring='f1_weighted') print 'redes neurais 1010' print scores.mean() mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['rn (10,10)', scores.mean(), mse]) # Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'a') as text_file: text_file.write(cr) text_file.write('\n') # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('cm_rn_n1010.png', transparent=true) plt.close() ## Modelo mlp = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(2,2), random_state=1) mlp = mlp.fit(x, y) predicted = cv.cross_val_predict(mlp, X, y, cv=10) # Cross Validation scores = cv.cross_val_score(mlpclassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(2,2), random_state=1), X, y, cv=10, scoring='f1_weighted') print 'redes neurais 1010' print scores.mean() mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['rn (2,2)', scores.mean(), mse]) # Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'a') as text_file: text_file.write(cr) text_file.write('\n') # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('cm_rn_n22.png', transparent=true) 30

plt.close() # SVM Linear # Modelo svc = svm.svc(kernel='linear') svc = svc.fit(x, y) predicted = cv.cross_val_predict(svc, X, y, cv=10) # Cross Validation scores = cv.cross_val_score(svm.svc(kernel='linear'), X, y, cv=10, scoring='f1_weighted') print 'svm linear' print scores.mean() mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['svm Linear', scores.mean(), mse]) # Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'a') as text_file: text_file.write(cr) text_file.write('\n') # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('cm_svm_l_n.png', transparent=true) plt.close() # SVM Polinomial # Modelo poly_svc = svm.svc(kernel='poly', degree=3) poly_svc = poly_svc.fit(x, y) predicted = cv.cross_val_predict(poly_svc, X, y, cv=10) # Cross Validation scores = cv.cross_val_score(svm.svc(kernel='poly', degree=3), X, y, cv=10, scoring='f1_weighted') print 'svm polinomial' print scores.mean() # Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'a') as text_file: text_file.write(cr) text_file.write('\n') 31

mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['svm Polinomial', scores.mean(), mse]) # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('cm_svm_p_n.png', transparent=true) plt.close() # SVM RBF # Modelo rbf_svc = svm.svc(kernel='rbf') rbf_svc = rbf_svc.fit(x, y) predicted = cv.cross_val_predict(rbf_svc, X, y, cv=10) # Cross Validation scores = cv.cross_val_score(svm.svc(kernel='rbf'), X, y, cv=10, scoring='f1_weighted') print 'svm rbf' print scores.mean() # Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'a') as text_file: text_file.write(cr) text_file.write('\n') mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['svm RBF', scores.mean(), mse]) # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('cm_svm_rbf_n.png', transparent=true) plt.close() # Decision Tree # Modelo clf = tree.decisiontreeclassifier(random_state=1) clf = clf.fit(x, y) predicted = cv.cross_val_predict(clf, X, y, cv=10) # Cross Validation scores = cv.cross_val_score(clf, X, y, cv=10) print 'decision tree' print scores.mean() 32

# Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'a') as text_file: text_file.write(cr) text_file.write('\n') mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['decision Tree', scores.mean(), mse]) # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('cm_tree_n.png', transparent=true) plt.close() # Decision Tree 3 # Modelo clf = tree.decisiontreeclassifier(max_depth=3, random_state=1) clf = clf.fit(x, y) predicted = cv.cross_val_predict(clf, X, y, cv=10) # Cross Validation scores = cv.cross_val_score(clf, X, y, cv=10) print 'decision tree' print scores.mean() # Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'a') as text_file: text_file.write(cr) text_file.write('\n') mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['decision Tree (D=3)', scores.mean(), mse]) # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('cm_tree3_n.png', transparent=true) plt.close() # Decision Tree 5 # Modelo clf = tree.decisiontreeclassifier(max_depth=5, random_state=1) clf = clf.fit(x, y) predicted = cv.cross_val_predict(clf, X, y, cv=10) 33

# Cross Validation scores = cv.cross_val_score(clf, X, y, cv=10) print 'decision tree' print scores.mean() # Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'a') as text_file: text_file.write(cr) text_file.write('\n') mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['decision Tree (D=5)', scores.mean(), mse]) teste = list(df.columns) teste = [0] + teste dot_data = tree.export_graphviz(clf, out_file = None, class_names=['1','2','3','4'], feature_names=teste, rounded=true) graph = pydotplus.graph_from_dot_data(dot_data) graph.write_pdf('teste5.pdf') # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('cm_tree5_n.png', transparent=true) plt.close() # Random Forest # Modelo clf = RandomForestClassifier(n_estimators=100) clf = clf.fit(x, y) predicted = cv.cross_val_predict(clf, X, y, cv=10) # Cross Validation scores = cv.cross_val_score(clf, X, y, cv=10) print 'Random Forest 100' print scores.mean() # Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'a') as text_file: text_file.write(cr) text_file.write('\n') 34

mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['random Forest 100', scores.mean(), mse]) # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('randomforest100.png', transparent=true) plt.close() # Random Forest # Modelo clf = RandomForestClassifier(n_estimators=500) clf = clf.fit(x, y) predicted = cv.cross_val_predict(clf, X, y, cv=10) # Cross Validation scores = cv.cross_val_score(clf, X, y, cv=10) print 'Random Forest 500' print scores.mean() # Avaliacao cnf_matrix = metrics.confusion_matrix(y, predicted) cr = metrics.classification_report(y, predicted) print cr with open('cr.txt', 'a') as text_file: text_file.write(cr) text_file.write('\n') mse = metrics.mean_squared_error(y, predicted) tabela.add_row(['random Forest 500', scores.mean(), mse]) # Matriz de Confusao Normalizada plt.figure() plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=true, title='matriz de Confusao Normalizada') plt.savefig('randomforest500.png', transparent=true) plt.close() tabela.align = "l" print tabela with open('tabela.txt', 'w') as text_file: text_file.write(tabela.get_string()) 35