Ebook---Aprendizagem-de-Maquina-na-Pratica

Prévia do material em texto

1 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2 
 
Sumário 
Unidade 1: Introdução – Aprendizagem de Máquina .......................................................... 4 
1.1 Considerações Iniciais ................................................................................................... 4 
1.2 Introdução: O que é Aprendizagem de Máquina (AM)? ........................................... 4 
1.3 Tipos de Aprendizagem de Máquina (AM) .................................................................. 5 
1.3.1 Aprendizagem Supervisionada .............................................................................. 5 
1.3.2 Aprendizagem não Supervisionada ...................................................................... 6 
1.3.3 Aprendizagem por Reforço ..................................................................................... 7 
1.3.4 Aprendizagem Profunda (ou Deep Learning) ...................................................... 8 
1.4 Roteiro .............................................................................................................................. 10 
1.4.1 Pré-requisitos .......................................................................................................... 10 
1.4.2 Assuntos abordados no módulo ......................................................................... 11 
1.4.3 Recursos usados no módulo ............................................................................... 12 
1.4.4 Ecossistema de programação interativa Python: Anaconda e Jupyter 
Notebook ............................................................................................................................ 12 
1.5 Considerações Finais ................................................................................................... 13 
Unidade 2: Atividades de Aprendizagem Supervisionada ............................................... 13 
2.1 Considerações Iniciais ................................................................................................. 13 
2.2 Estudo de caso ............................................................................................................... 13 
2.3 Atividades ........................................................................................................................ 14 
2.3.1 Importação dos dados ........................................................................................... 14 
2.3.2 Transformação dos dados .................................................................................... 14 
2.3.3 Treinamento ............................................................................................................. 15 
2.3.4 Teste .......................................................................................................................... 18 
2.3.5 Curvas de Aprendizagem ...................................................................................... 19 
2.3.6 Validação .................................................................................................................. 22 
2.4 Considerações Finais ................................................................................................... 23 
Unidade 3: Aprendizagem Supervisionada - Classificação ............................................. 23 
3.1 Considerações Iniciais ................................................................................................. 23 
3.2 O Algoritmo K-Nearest Neighbor (KNN) .................................................................... 24 
3.2.1 Analisando o algoritmo KNN ................................................................................ 25 
3.2.2 Regressão com o algoritmo KNN ........................................................................ 26 
3.2.3 Vantagens, desvantagens e hiperparâmetros ................................................... 27 
3.3 Árvores de Decisão ....................................................................................................... 28 
3.3.1 Construindo classificadores baseados em Árvores de Decisão .................. 28 
3.3.2 Analisando Árvores de Decisão........................................................................... 29 
3.3.3 Importância dos Atributos .................................................................................... 30 
3.3.4 Vantagens, desvantagens e hiperparâmetros ................................................... 31 
3 
 
3.4 Support Vector Machines (SVM) ................................................................................. 31 
3.4.1 Modelos lineares e atributos não lineares ......................................................... 31 
3.4.2 O papel dos hiperparâmetros ................................................................................... 33 
3.4.3 Vantagens, desvantagens e hiperparâmetros....................................................... 35 
3.5 Considerações Finais ................................................................................................... 35 
Unidade 4: Aprendizagem Supervisionada – Regressão ................................................. 36 
4.1 Considerações Iniciais ................................................................................................. 36 
4.2 Regressão Linear Simples ........................................................................................... 36 
4.2.1 Métrica dos Mínimos quadrados (Minimum Squares Error – MSE).............. 37 
4.2.2 Estudo de Caso: Extensão do gelo marinho e mudanças climáticas .......... 38 
4.3 Regressão Linear Múltipla e Regressão Polinomial ............................................... 39 
4.3.1 Estudo de caso: Previsão do preço de imóveis ............................................... 40 
4.3.2 Predições e Modelos esparsos ............................................................................ 42 
4.4 Regressão Logística...................................................................................................... 43 
4.4.1 Estimando probabilidades .................................................................................... 44 
4.4.2 Limites de Decisão ................................................................................................. 44 
4.4.2 Regressão Softmax ................................................................................................ 46 
4.5 Considerações Finais ................................................................................................... 46 
Unidade 5: Aprendizagem Profunda (Deep Learning) ...................................................... 47 
5.1 Considerações Iniciais ................................................................................................. 47 
5.2 Perceptrons e o modelo de redes neurais artificiais .............................................. 47 
5.3 Configuração das redes neurais artificiais ............................................................... 49 
5.4 Redes neurais profundas ............................................................................................. 53 
5.4.1 Bibliotecas para Deep Learning ........................................................................... 53 
5.4.2 Estudo de caso: construção de um classificador de imagens ..................... 54 
5.4.3 Criação de rede neural profunda baseada em API Sequencial ..................... 55 
5.4.4 Ajuste dos Hiperparâmetros ................................................................................. 57 
5.4.5 Uso da rede neural para fazer predições ........................................................... 57 
5.5 Considerações Finais ................................................................................................... 58 
Referências ................................................................................................................................ 594 
 
Unidade 1: Introdução – Aprendizagem de Máquina 
 
1.1 Considerações Iniciais 
 Neste primeiro capítulo, além de introduzir o que é e qual a importância da Aprendizagem 
de Máquina (AM), iniciaremos os estudos sobre os conceitos fundamentais dessa área fascinante. 
A AM tem desempenhado papel significativo na construção de sistemas que podem “aprender” 
com base nos dados e na experiência do usuário. Nas últimas décadas ela tem sido usada para 
construir aplicações que revolucionaram a forma como interagimos com o mundo, como os 
assistentes pessoais digitais (Amazon Alexa, Apple Siri e Microsoft Cortana). Este primeiro 
capítulo está estruturado da seguinte forma: na Seção 1.2 vamos introduzir o que é Aprendizagem 
de Máquina; na Seção 1.3 estudaremos os principais tipos de AM; na Seção 1.4 vamos apresentar 
o roteiro deste módulo, ou seja, quais assuntos serão estudados na sequência deste capítulo e 
nos capítulos seguintes; por fim, a Seção 1.5 faz as considerações finais do capítulo. 
 
1.2 Introdução: O que é Aprendizagem de Máquina (AM)? 
 A Aprendizagem de Máquina (ou Machine Learning) é uma área da Inteligência Artificial 
(IA) que visa criar artefatos de software que usam experiências do passado para tomar decisões 
futuras, ou seja, é um tipo de software que “aprende” com base em um conjunto de dados 
históricos. Seu objetivo fundamental é generalizar ou induzir uma regra desconhecida a partir de 
exemplos de aplicação da regra. Um exemplo clássico de aprendizagem de máquina é a 
filtragem de spam. O filtro de spam usado na caixa de entrada do seu e-mail é um programa de 
aprendizagem de máquina que, com base em inúmeros exemplos de e-mails de spam sinalizados 
por usuários, e exemplos de e-mails regulares (que não são spam), podem aprender a sinalizar 
um spam. 
 Arthur Samuel (Emporia, Kansas, EUA, 1901-1990), um cientista da computação que foi o 
pioneiro no estudo da inteligência artificial, disse que a aprendizagem de máquina é o "estudo que 
dá aos computadores a capacidade de aprender sem serem programados explicitamente". Ao 
longo dos anos 1950 e 1960, Samuel desenvolveu programas que jogavam damas. Embora as 
regras das damas sejam simples, estratégias complexas são necessárias para derrotar oponentes 
habilidosos. Samuel nunca programou explicitamente essas estratégias, mas por meio da 
experiência de jogar milhares de partidas, o programa aprendeu comportamentos complexos que 
lhe permitiram vencer muitos oponentes humanos. 
 Uma citação popular do cientista da computação Tom Mitchell (Blossburg, Pensilvânia, 
EUA, 1951-) define a aprendizagem de máquina mais formalmente: "Pode-se dizer que um 
programa aprende com a experiência 'E' em relação a alguma classe de tarefas 'T' e medida de 
desempenho 'P', se seu desempenho nas tarefas em 'T', medido por 'P', melhora com a 
experiência 'E' " Por exemplo, suponha que você tenha uma coleção de fotos. Cada imagem 
representa um cachorro ou um gato. Uma tarefa pode ser classificar as fotos em coleções 
separadas de fotos de cães e gatos. Um programa poderia aprender a realizar essa tarefa 
observando as imagens que já foram classificadas e poderia avaliar seu desempenho calculando 
a porcentagem de imagens classificadas corretamente. Nós usaremos a definição de 
aprendizagem de máquina de Tom Mitchell para organizar o conteúdo desta disciplina. Neste 
capítulo, discutiremos os tipos de experiência, incluindo aprendizagem supervisionada e 
aprendizagem não supervisionada. A seguir, discutiremos tarefas comuns que podem ser 
realizadas por sistemas de aprendizagem de máquina. Nos próximos capítulos, discutiremos as 
5 
 
medidas de desempenho que podem ser usadas para avaliar sistemas de aprendizagem de 
máquina. 
 
1.3 Tipos de Aprendizagem de Máquina (AM) 
 Como descrevemos na seção anterior, uma das primeiras aplicações de AM que se tornou 
verdadeiramente popular, que melhorou a vida de centenas de milhões de pessoas e conquistou o 
mundo nos anos 1990 foi o filtro de spam. Essa técnica foi seguida por centenas outros sistemas 
de AM que fornecem silenciosamente centenas de produtos e recursos que você usa 
regularmente, desde sistemas de recomendação até pesquisa por voz. Uma dúvida recorrente é 
onde a Aprendizagem de Máquina começa e onde termina? O que exatamente significa para uma 
máquina aprender alguma coisa? Se eu baixar uma cópia da Wikipedia, meu computador irá 
aprender alguma coisa? Nesta Seção, começaremos a esclarecer o que é AM e por que você 
pode querer usá-la. 
 Existem vários tipos diferentes de sistemas de AM, portanto, é útil classificá-los em 
categorias mais generalistas, com base em alguns critérios (GERON, 2019): 
 se eles são ou não treinados com supervisão humana (supervisionada, não supervisionada 
e semi-supervisionada ou aprendizagem por reforço); 
 se eles podem ou não aprender dinamicamente de forma incremental (aprendizagem 
online versus aprendizagem em lote); 
 se eles funcionam simplesmente comparando novos conjuntos de dados com conjuntos de 
dados conhecidos, ou detectando padrões nos dados de treinamento e construindo um modelo 
preditivo (aprendizagem baseada em instância versus aprendizagem baseada em modelo) 
 Esses critérios não são exclusivos; você pode combiná-los da maneira que quiser. Por 
exemplo, um filtro de spam de última geração pode aprender em tempo real usando um modelo 
de redes neurais treinado com um conjunto de dados contendo exemplos de spam; isso o torna 
um sistema de aprendizagem online, baseado em um modelo supervisionado. As subseções a 
seguir descrevem alguns dos principais tipos de aprendizagem de máquina. 
 
1.3.1 Aprendizagem Supervisionada 
 Os sistemas de aprendizagem de máquina podem ser classificados de acordo com a 
quantidade e o tipo de supervisão que recebem durante o treinamento. Existem três categorias 
principais: aprendizagem supervisionada, aprendizagem não supervisionada, e aprendizagem 
semi-supervisionada ou por reforço. 
 Na aprendizagem supervisionada, os dados de treinamento que você utiliza para o 
algoritmo incluem um atributo especial que classifica cada instância do conjunto de dados, 
chamado de classe ou rótulo. Uma atividade típica da aprendizagem supervisionada é a 
classificação. O filtro de spam é um bom exemplo disso: ele é treinado com muitos e-mails de 
exemplo, e cada um deles possui a sua classe (spam ou não-spam), e o sistema precisa aprender 
a classificar novos e-mails com base no conjunto de treinamento, como é mostrado na Figura 1.1. 
 Outra tarefa típica da aprendizagem supervisionada é prever um valor numérico, como o 
preço de um carro, dado um conjunto de atributos (quilometragem, idade, marca, etc.) chamados 
preditores. Esse tipo de aprendizagem supervisionada é chamada de regressão. Para treinar o 
sistema, você precisa de um conjunto de dados com muitos exemplos de carros, incluindo os 
preditores e o seu rótulo, que neste caso será o preço do carro. Um exemplo genérico de 
regressão é mostrado na Figura 1.2. 
6 
 
 
Figura 1.1 – Exemplo de aprendizagem supervisionada: conjunto de dados rotulados para 
classificação de spam (GERON, 2019) 
 
Figura 1.2 – Problema de regressão: prever um valor, dado um atributo de entrada (podem existir 
também vários atributos de entrada) (GERON, 2019) 
 
1.3.2 Aprendizagem não Supervisionada 
 Na aprendizagem não supervisionada, os dados do conjunto de treinamento não possuem 
um rótulo ou classe, portanto, o sistema tenta aprender sem supervisão. Por exemplo, digamos 
que você tenha muitos dados sobre os usuários visitantes do seu blog. Você pode executar um 
algoritmo de clusterização (agrupamento) para tentar detectar grupos de visitantes semelhantes. 
Em nenhum momento você diz ao algoritmo a que grupo o visitante pertence: ele encontra essas 
conexões sem a sua ajuda. Por exemplo, pode notar que 40% dos seus visitantes são homens 
que gostam de históriasem quadrinhos e geralmente leem seu blog à noite, enquanto 20% são 
jovens amantes de ficção científica que visitam nos fins de semana. Se você usar um algoritmo de 
clusterização hierárquica, ele também poderá subdividir cada grupo em grupos menores. Isso 
pode ajudá-lo a direcionar suas postagens para cada grupo. Observe a Figura 1.3, à esquerda ela 
mostra o seu conjunto de dados (visitantes do blog), e à direita você pode visualizar os grupos (ou 
clusters) que foram identificados pelo algoritmo de clusterização. 
7 
 
 
Figura 1.3 – Exemplo de aprendizagem não supervisionada (GERON, 2019) 
 Outra tarefa importante de aprendizagem não supervisionada é a detecção de anomalias; 
por exemplo, a detecção de transações incomuns com cartão de crédito para evitar fraudes, 
detecção de defeitos de fabricação ou remoção automática de valores discrepantes de um 
conjunto de dados antes de usá-lo em outro algoritmo de aprendizagem. Essa técnica é usada 
para identificar instâncias “normais” durante o treinamento, portanto aprende a reconhecê-las; 
então, quando analisa uma nova instância, pode dizer se ela é parecida com uma instância normal 
ou se provavelmente é uma anomalia, como você pode observar na Figura 1.4. Uma tarefa muito 
semelhante é a detecção de novidades: ela visa detectar novas instâncias que parecem diferentes 
de todas as outras no conjunto de treinamento. Isso requer um conjunto de treinamento 
desprovido de qualquer instância que você queira que o algoritmo detecte. Por exemplo, se você 
tem milhares de fotos de cães e 1% delas representa Chihuahuas, um algoritmo de detecção de 
novidade não deve tratar novas fotos de Chihuahuas como novidades. Por outro lado, algoritmos 
de detecção de anomalias podem considerar esses cães tão raros e tão diferente de outros cães 
que provavelmente os classificariam como anomalias (sem querer ofender os Chihuahuas). 
 
1.3.3 Aprendizagem por Reforço 
 A aprendizagem por reforço é um método bastante diferente. Nesse sistema de 
aprendizagem, um agente “inteligente” pode observar o ambiente, selecionar e executar ações e 
receber recompensas em troca, ou penalidades na forma de recompensas negativas, como 
mostra a Figura 1.5. Em seguida, ele deve aprender por si próprio qual é a melhor estratégia, 
chamada de política, para obter a maior recompensa ao longo do tempo. Uma política define qual 
ação o agente deve escolher quando estiver em uma determinada situação. 
 Por exemplo, muitos robôs são criados com base em algoritmos de aprendizagem por 
reforço para aprender a andar. O programa AlphaGo da DeepMind também é um bom exemplo de 
aprendizagem por reforço: ele chegou às manchetes em maio de 2017 quando venceu o campeão 
mundial Ke Jie no jogo Go. Ele aprendeu sua política vitoriosa analisando milhões de jogos e 
depois jogando muitas vezes contra si mesmo, sendo que a aprendizagem foi desativada durante 
os jogos contra o campeão, assim, o AlphaGo estava apenas aplicando a política que havia 
aprendido anteriormente (GERON, 2019). 
8 
 
Figura 1.4 – Exemplo genérico de detecção de anomalias (GERON, 2019) 
 
 Figura 1.5 – Aprendizagem por reforço (GERON, 2019) 
 
1.3.4 Aprendizagem Profunda (ou Deep Learning) 
 Os pássaros nos inspiraram a voar, da mesma forma que a natureza inspirou inúmeras 
outras invenções. Parece lógico, então, olhar para a arquitetura do cérebro em busca de 
inspiração sobre como construir uma máquina inteligente. Esta é a lógica que inspirou a criação 
9 
 
das redes neurais artificiais (RNA’s): uma RNA é um modelo de aprendizagem de máquina 
supervisionada inspirada nas redes de neurônios biológicos do nosso cérebro. No entanto, 
embora os aviões tenham sido inspirados por pássaros, eles não precisam bater as asas para 
voar. Da mesma forma, as RNA se tornaram gradualmente muito diferentes de seus primos 
biológicos. Alguns pesquisadores até argumentam que devemos abandonar completamente a 
analogia biológica (por exemplo, dizendo "unidades" em vez de "neurônios"), para não restringir 
nossa criatividade a sistemas biologicamente plausíveis (GERON, 2019). 
 As RNA são o conceito central de Aprendizagem Profunda. Elas são versáteis, poderosas 
e escaláveis. São ideais para lidar com tarefas de aprendizagem de máquina grandes e altamente 
complexas, como classificar bilhões de imagens (por exemplo, Imagens do Google), fazer o 
reconhecimento de voz em assistentes pessoais digitais (por exemplo, Siri da Apple), recomendar 
os melhores vídeos para assistir a centenas de milhões de usuários todos os dias (como no 
YouTube) ou aprendendo a vencer o campeão mundial no jogo Go (AlphaGo da DeepMind). 
 A arquitetura mais simples possível de uma RNA é chamada de Perceptron. Ele 
representa um único neurônio artificial, ligeiramente diferente de um neurônio biológico. Observe a 
Figura 1.6: um perceptron é formado por duas ou mais entradas numéricas (xi), cada uma delas 
normalmente é associada a um peso (wi); o perceptron irá somar o valor das entradas multiplicado 
pelo valor dos seus respectivos pesos; o valor desse somatório é a entrada de uma função de 
ativação, e o resultado desta função é a saída produzida pelo perceptron. 
Figura 1.6 – Funcionamento de um Perceptron (GERON, 2019) 
 
 Um único perceptron não é capaz de solucionar problemas complexos. Para tal, assim 
como o cérebro humano possui várias camadas, nas quais a saída de um neurônio torna-se a 
entrada de outros, também é possível configurar dezenas, centenas, milhares e até milhões de 
neurônios artificiais em diferentes arquiteturas, formadas por inúmeras camadas. É neste contexto 
que surge o conceito de Aprendizagem Profunda: ela é formada por uma arquitetura de RNA 
que possui duas ou mais camadas “ocultas” de neurônios (aquelas que estão entre a camada de 
entrada e a camada de saída). Observe a Figura 1.7 em que são mostradas diferentes 
arquiteturas de RNA, em que são combinados diversos neurônios. Todos os modelos com duas ou 
mais camadas (excetuando-se as entradas e as saídas) são modelos de aprendizagem profunda. 
 
 
 
 
 
10 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 1.7 – Arquiteturas de Redes Neurais Artificiais 
Fonte: https://www.asimovinstitute.org/the-neural-network-zoo-2016 
 
1.4 Roteiro 
 Nesta seção iremos apresentar o conteúdo que estudaremos em cada capítulo do módulo. 
 
1.4.1 Pré-requisitos 
 Os únicos conhecimentos necessários que você precisará ter para compreender o 
conteúdo estudado neste módulo são os conceitos básicos para tratamento de dados da 
linguagem de programação Python1. Os trechos de código-fonte discutidos nos próximos capítulos 
foram implementados e utilizam pacotes em Python 3, portanto, vamos considerar que você 
possui algum tipo de familiaridade com esta linguagem de programação. Além disso, é importante 
que você conheça alguns recursos básicos da linguagem Python que são necessários para 
realizar tratamentos básicos sobre os dados que serão analisados pelos algoritmos de 
aprendizagem de máquina. Nos exemplos práticos, discutiremos com detalhes o código-fonte 
apresentado, que realiza tanto o tratamento dos dados quanto a implementação dos algoritmos. 
Contudo, iremos nos concentrar na construção, configuração, treinamento e avaliação dos 
algoritmos de aprendizagem de máquina. Se você conhece pouco a linguagem Python, não se 
preocupe! Com o código-fonte disponível e um pouco de pesquisa, você será capaz de 
compreender toda a lógica de programação. 
 
1https://www.python.org/downloads 
https://www.asimovinstitute.org/the-neural-network-zoo-2016
https://www.python.org/downloads/
11 
 
 Também utilizaremos alguns pacotes específicos em Python para executar os exemplos 
discutidos nos próximos capítulos. São eles: NumPy2, SciPy3, pandas4, matplotlib5, 
seaborn6, scikit-learn7, keras8 e tensorflow9. Em cada capítuloserão utilizados 
alguns pacotes mais específicos sobre algumas técnicas de Inteligência Artificial, neste caso, as 
instruções serão fornecidas no próprio capítulo. 
 
1.4.2 Assuntos abordados no módulo 
 Este primeiro Capítulo é uma introdução ao conceito de Aprendizagem de Máquia (AM). Já 
discutimos rapidamente o que é AM e como ela ganhou relevância na construção de sistemas 
inteligentes, principalmente nas últimas décadas. AM é uma área bastante extensa e possui 
diversos tipos, como a Aprendizagem Supervisionada, Aprendizagem não Supervisionada, 
Aprendizagem por Reforço e Aprendizagem Profunda. Contudo, nesta disciplina iremos discutir os 
principais algoritmos de Aprendizagem Supervisionada, tanto a área de Classificação quanto 
Regressão, além do conceito de Aprendizagem Profunda, baseado na arquitetura de redes 
neurais artificiais. 
 No Capítulo 2 discutiremos as principais atividades relacionadas à aprendizagem 
supervisionada, referentes tanto às técnicas de classificação quanto de regressão. De acordo com 
o tipo de resposta que buscamos, estamos visando diretamente um determinado conjunto de 
técnicas. Se a pergunta pode ser respondida apenas com Sim/Não, ou admite apenas um 
conjunto discreto de respostas, selecionadas a partir de um número finito de escolhas, estamos 
em frente a um problema de classificação. Por exemplo: “Dados os resultados de um teste clínico, 
o paciente sofre de diabetes?”. Por outro lado, se a pergunta a ser respondida é a previsão de 
uma quantidade com valor real, nos deparamos com um problema de regressão. Por exemplo: “A 
partir das características de um imóvel, qual é o seu valor de mercado?” Neste capítulo, 
conheceremos as atividades necessárias para executar essas técnicas: importação dos dados, 
tranformações dos dados, treinamento, teste e validação. 
 No Capítulo 3 estudaremos alguns dos principais algoritmos de classificação, cujo objetivo 
é prever o rótulo de uma classe, que é uma escolha em uma lista predefinida de possibilidades. A 
classificação normalmente é dividida em classificação binária, que é o caso especial de distinguir 
exatamente entre duas classes, e multiclasse, que é aquela entre mais de duas classes. Você 
pode pensar na classificação binária como uma tentativa de responder a uma pergunta sim / não. 
Classificar emails como spam ou não spam é um exemplo de problema de classificação binária. 
Vamos conhecer três dos algoritmos de classificação mais usados, e explicaremos como eles 
aprendem com os dados, como fazem previsões e examinaremos os pontos fortes e fracos de 
cada algoritmo, sendo eles: K-Nearest Neighbor (KNN), Árvores de Decisão e Support Vector 
Machines (SVM). 
 No Capítulo 4 apresentaremos a análise de regressão e algumas de suas aplicações. A 
regressão está relacionada a como fazer previsões sobre as quantidades do mundo real, como, 
por exemplo, as previsões relacionadas a perguntas do tipo: como o volume de vendas muda com 
as mudanças no preço? Ela pede uma resposta que pode ser expressa como uma combinação de 
 
2http://docs.scipy.org/doc/numpy-1.10.1/user/install.html 
3http://www.scipy.org/install.html 
4https://pandas.pydata.org 
5http://matplotlib.org/1.4.2/users/installing.html 
6https://seaborn.pydata.org 
7http://scikit-learn.org/stable/install.html 
8https://keras.io/ 
9https://www.tensorflow.org/?hl=pt-br 
http://docs.scipy.org/doc/numpy-1.10.1/user/install.html
http://www.scipy.org/install.html
https://pandas.pydata.org/
http://matplotlib.org/1.4.2/users/installing.html
https://seaborn.pydata.org/
http://scikit-learn.org/stable/install.html
https://keras.io/
https://www.tensorflow.org/?hl=pt-br
12 
 
uma ou mais variáveis independentes (também chamadas de covariáveis ou preditores). O papel 
da regressão é construir modelos para prever as respostas dessas variáveis contínuas. Iremos 
aprender os conceitos de Regressão Linear Simples, Regressão Linear Múltipla, Regressão 
Polinomial e Regressão Logística. 
 No Capítulo 5 conheceremos uma família de algoritmos de aprendizagem supervisionada, 
conhecida como redes neurais artificiais, que recentemente teve um renascimento com o nome de 
"aprendizagem profunda". Embora a aprendizagem profunda mostre uma grande promessa em 
muitas aplicações, a técnica costuma realizar ajustes com muito cuidado para que possa ser 
usada em um caso específico. Neste capítulo, iremos discutir algumas técnicas, como o uso de 
Perceptrons multicamadas (Multilayer Perceptrons – MLP’s) para classificação e regressão, que 
podem servir como um ponto de partida para métodos de aprendizagem profunda mais 
complexos. MLP’s também são conhecidos como redes neurais feed-forward, ou, às vezes, 
apenas redes neurais. Iremos introduzir os conceitos de Perceptrons e o modelo de redes neurais 
artificiais. Vamos aprender também como configur as redes neurais artificiais para realizar tarefas 
de aprendizagem profunda. 
 Em todos os próximos quatro capítulos, você irá aprender os conceitos apresentados por 
meio de uma série de exemplos práticos implementados na linguagem de programação Python. 
Sempre iniciaremos o estudo por meio da análise de exemplos mais simples, e aos poucos iremos 
adicionar mais conceitos para que você possa entender os exemplos mais complexos. O objetivo 
é fornecer uma base com os conceitos fundamentais de Aprendizagem de Máquina, de forma 
prática, para que futuramente você possa se aprofundar nos temas de seu maior interesse, no 
ritmo e intensidade que você julgar necessários. 
 
1.4.3 Recursos usados no módulo 
 Outro tema importante são os recursos que você utilizará ao longo do módulo. Em várias 
aulas, solicitaremos que você importe algum arquivo ou execute algum script já pronto para 
agilizar o andamento dos estudos. Todos esses recursos estão compactados em uma pasta que 
você pode baixar no seguinte link: https://cutt.ly/xgYqlKp. Recomendamos que logo no início, você 
salve esse arquivo e o descompacte em alguma pasta no seu computador. Durante o módulo, 
sempre que solicitarmos que você utilize algum arquivo, você pode buscá-lo nessa pasta. 
 
1.4.4 Ecossistema de programação interativa Python: Anaconda e Jupyter Notebook 
 Os exemplos disponibilizados estão implementados em IPython10: um interpretador 
interativo para várias linguagens de programação, mas especialmente focado em Python. Mais 
precisamente, usaremos IPython por meio da plataforma Anaconda11, uma distribuição gratuita e 
de código aberto das linguagens de programação Python e R para computação científica (ciência 
de dados, aplicações de aprendizagem de máquina, processamento de dados em grande escala, 
análise preditiva, etc.), que visa simplificar o gerenciamento de pacotes e os desdobramentos da 
implementação de tal solução. 
 Assim, você deve seguir os seguintes passos para instalar o ecossistema necessário para 
executar os exemplos: 
1) acessar o endereço https://www.anaconda.com e instalar a versão open source (Individual 
Edition) da plataforma Anaconda; existem versões disponíveis para Windows, Linux e MacOS; 
 
10https://ipython.org/install.html 
11https://www.anaconda.com 
https://cutt.ly/xgYqlKp
https://www.anaconda.com/
https://ipython.org/install.html
https://www.anaconda.com/
13 
 
2) uma vez instalada a distribuição Anaconda, você deve executar o comando anaconda-
navigator; o Anaconda Navigator é uma interface gráfica desktop incluída na distribuição do 
Anaconda que permite iniciar aplicativos e gerenciar facilmente bibliotecas e ambientes para 
ciência de dados e inteligência artificial; você deve instalar os seguintes pacotes que serão 
necessários ao longo dos próximos capítulos: NumPy, SciPy, pandas, matplotlib, seaborn, scikit-
learn e tensorflow. 
3) A partir do Anaconda Navigator, intalar o Jupyter Notebook: um ambiente open source 
baseado na web que permite criare compartilhar documentos Python interativos (IPython). 
 
1.5 Considerações Finais 
 Neste primeiro capítulo do módulo, introduzimos os principais conceitos relacionados a 
Aprendizagem de Máquina (AM). Você conheceu a definição de AM e estudou quais são os seus 
principais tipos, como a Aprendizagem Supervisionada, Aprendizagem não Supervisionada, 
Aprendizagem por Reforço e Aprendizagem Profunda (Deep Learning). Dentre esses tipos, 
discutimos que atualmente as principais técnicas para a construção de sistemas inteligentes são 
as técnicas supervisionadas, especialmente Deep Learning. Você conheceu o roteiro que 
estudaremos nos próximos capítulos, que incluem técnicas de classificação, regressão e redes 
neurais profundas. No próximo capítulo daremos início aos estudos sobre as atividades que 
devem ser executadas para a construção de modelos preditivos. 
 
Unidade 2: Atividades de Aprendizagem Supervisionada 
 
2.1 Considerações Iniciais 
 Neste capítulo estudaremos um tipo específico de aprendizagem de máquina: a 
aprendizagem supervisionada. Como desenvolvedor de soluções inteligentes, a primeira etapa 
que você precisa aplicar a um determinado problema é identificar a pergunta a ser respondida 
com base nos dados. De acordo com o tipo de resposta que buscamos, estamos visando 
diretamente um determinado conjunto de técnicas. Se a pergunta pode ser respondida apenas 
com Sim/Não, ou admite apenas um conjunto discreto de respostas, selecionadas a partir de um 
número finito de escolhas, estamos em frente a um problema de classificação. Por exemplo: 
“Dados os resultados de um teste clínico, o paciente sofre de diabetes?” Ou “Dadas as 
características de uma planta, é possível determinar a sua espécie?”. Por outro lado, se a 
pergunta a ser respondida é a previsão de uma quantidade com valor real, nos deparamos com 
um problema de regressão. Por exemplo: “A partir das características de um imóvel, qual é o seu 
valor de mercado?” Ou “Dados os registros anteriores de atividade do usuário em Apps, por 
quanto tempo um determinado cliente ficará conectado ao nosso App?” Nas próximas seções, 
conheceremos as atividades que são executadas em problemas de aprendizagem supervisionada, 
seja classificação ou regressão. O capítulo está estruturado da seguinte forma: na Seção 2.2 
vamos introduzir o estudo de caso que será usado para compreender as atividades iniciais da 
aprendizagem supervisionada; na Seção 2.3 descreveremos os detalhes dessas atividades: 
importação dos dados, transformações dos dados, treinamento, teste e validação; por fim, a 
Seção 2.4 faz as considerações finais do capítulo. 
 
2.2 Estudo de caso 
14 
 
 Como exemplo neste capítulo, usamos os dados do Lending Club12 para desenvolver 
nossa compreensão dos conceitos das atividades de aprendizagem supervisionada. O Lending 
Club é uma empresa que oferece empréstimos bancários financiados por outras pessoas. Nesse 
sentido, ele atua como um hub que conecta os mutuários aos investidores. O mutuário solicita um 
empréstimo de determinado valor e a empresa avalia o risco da operação. Se o pedido for aceito, 
ele pode ou não ser totalmente coberto. Vamos nos concentrar na previsão que responderá se o 
empréstimo será totalmente financiado, com base na pontuação e nas informações relacionadas. 
 Usaremos o conjunto de dados parcial do período 2007–2011. Especificando um pouco 
mais o problema, com base nas informações fornecidas pelo cliente que solicita um empréstimo, 
queremos prever se ele será concedido até um determinado limite. Os atributos que usamos neste 
problema estão relacionados a alguns dos detalhes do pedido de empréstimo, como o valor do 
empréstimo aplicado ao mutuário, o pagamento mensal a ser feito pelo mutuário se o empréstimo 
for aceito, a renda anual do mutuário, a taxa de juros do empréstimo, entre outros. Nesse caso, 
podemos prever os empréstimos aceitos sem sucesso. Um pedido de empréstimo é mal sucedido 
se o valor financiado (coluna funded_amnt) ou o valor financiado pelos investidores (coluna 
funded_amnt_inv) fica muito aquém do valor do empréstimo solicitado (coluna loan_amnt). Isso 
pode ser determinado pela seguinte fórmula: 
 
 
 
2.3 Atividades 
2.3.1 Importação dos dados 
 A primeira atividade em um processo de aprendizagem supervisionada será importar os 
dados de que precisamos para treinar o algoritmo. Eles podem estar armazenados em diferentes 
formatos, sendo os arquivos do tipo CSV um dos mais comuns. A Figura 2.1 mostra o código para 
ler o arquivo com os dados do nosso estudo de caso. 
Figura 2.1 – Importação dos dados 
 
2.3.2 Transformação dos dados 
 Depois de realizar a importação, geralmente precisamos transformar os dados em uma 
representação adequada para modelos de aprendizagem de máquina. Para muitos algoritmos, 
essa representação terá a forma de uma estrutura vetorial ou de matriz que contém dados 
numéricos. Os desafios comuns durante a transformação de dados incluem: 
 
12https://www.lendingclub.com/info/download-data.action 
https://www.lendingclub.com/info/download-data.action
15 
 
 transformar dados categóricos (como a categoria de um filme) e codificá-los em uma 
representação numérica; 
 extrair informações úteis de atributos textuais; 
 lidar com dados de imagem ou áudio; 
 converter dados numéricos em dados categóricos para reduzir o número de valores que 
uma variável pode assumir; um exemplo disso é a conversão de uma variável para idade em 
intervalos como 25-35, 45-55 e assim por diante; 
 A Figura 2.2 mostra uma função que realiza uma etapa da atividade de transformação, ao 
mapear o atributo term_clean do tipo string para um atributo numérico. 
 
Figura 2.2 – Transformação dos dados 
 
2.3.3 Treinamento 
 A próxima etapa é o treinamento: executar o algoritmo usando o conjunto de dados para 
que ele “aprenda” a reconhecer o padrão de cada classe. A partir daí, o classificador pode ser 
usado para prever o resultado sobre dados novos. A Figura 2.3 mostra o código-fonte para realizar 
o treinamento dos dados sobre empréstimos bancários com o algoritmo KNN (K-Nearest 
Neighbors). 
Figura 2.3 – Treinamento dos dados 
 
16 
 
Avaliação da qualidade dos classificadores: Matriz de confusão 
 Uma matriz de confusão é uma tabela que é usada para descrever o desempenho de um 
classificador, ao prever a classe de exemplos que não estão no conjunto original de dados 
(treinamento). Cada linha na matriz representa as instâncias da classe prevista, e cada coluna 
representa as instâncias da classe real. Esse nome é usado porque a matriz facilita a visualização 
se o modelo confundir ou rotular incorretamente suas classes. Nós comparamos cada classe com 
todas as outras e vemos quantas amostras são classificadas corretamente e incorretamente. 
 Durante a construção da matriz, encontramos alguns conceitos importantes descritos a 
seguir. Considere um caso de classificação binária em que as saídas possíveis sejam 0 (Falso) ou 
1 (Verdadeiro): 
 Verdadeiro positivo (VP): são amostras para as quais foi previsto 1 e valor real é 1. 
 Verdadeiro negativo (VN): são amostras para as quais foi previsto 0 e valor real é 0. 
 Falso positivo (FP): são amostras para as quais foi previsto 1 e valor real é 0. 
 Falso negativo (FN): são amostras para as quais foi previsto 0 e valor real é 1. 
 Dependendo do problema em questão, talvez seja necessário otimizar o algoritmo para 
reduzir a taxa de falsos positivos ou de falsos negativos. Por exemplo, em um sistema de 
identificação biométrica, é muito importante evitar falsos positivos, porque as pessoas erradas 
podem ter acesso a informações confidenciais. Em termos de métricas de avaliação, existem 
basicamente quatro conceitos: acurácia, precision, recall e F1-score. 
 A acurácia é a métrica de desempenho mais comum, ela simplesmente indica a proporção 
de previsõescorretas, por meio da fórmula: 
 
 Precision é a proporção de cada verdadeiro positivo com o total de positivos. Podemos 
pensar nessa métrica como um ruído de medição das previsões, isto é, quando o classificador 
prevê algo como positivo, qual a probabilidade de realmente ser positivo. Um classificador com 
valor alto de precision é considerado pessimista, pois ele apenas classificará uma observação 
como positiva quando tiver certeza disto. Formalmente, a fórmula para o cálculo de precision é: 
 
 Recall é a proporção de cada observação positiva que é verdadeiramente positiva. 
Podemos pensar nessa métrica como a habilidade do classificador em identificar observações da 
classe positiva. Classificadores com alto valor de recall são considerados otimistas, pois eles 
tendem a prever as observações como positivas. A fórmula para o cálculo de recall é: 
 
 Por sua vez, F1-score é uma métrica que busca equilibrar precision e recall, por meio de 
uma média harmônica (tipo de média utilizada para proporções): 
 
 
17 
 
 A Figura 2.4 mostra o código-fonte que mostra a acurácia para o modelo treinado do nosso 
estudo de caso, e a distribuição dos rótulos no conjunto de dados. Por sua vez, a Figura 2.5 
mostra como calcular e visualizar a matriz de confusão. 
Figura 2.4 – Acurácia e distribuição dos rótulos 
 
Figura 2.5 – Calcular matriz de confusão 
 A Figura 2.6 mostra o código-fonte que exibe o desempenho do classificador com os dados 
de treinamento. A medida de desempenho é perfeita: 100% de precisão e uma matriz de confusão 
diagonal, o que parece ser bom. O erro detectado nesta fase é chamado de erro de treinamento 
(ou erro dentro da amostra), que se refere ao erro medido em todas as amostras de dados 
observadas no conjunto de treinamento. Até este ponto, verificamos o desempenho do 
classificador nos mesmos dados com os quais ele foi treinado, o que é uma prática não 
recomendada. Durante a exploração, em aplicações reais, precisamos avaliar o classificador 
utilizando dados não vistos anteriormente, ou seja, dados que não estão no conjunto de 
treinamento, como é descrito na próxima seção. 
18 
 
Figura 2.6 – Desempenho dos dados de treinamento 
 
2.3.4 Teste 
 Para avaliar o desempenho do classificador, precisamos testá-lo com dados 
desconhecidos. Assim surge o conceito de erro do teste ou erro de generalização, que é aquele 
esperado em dados novos. Para isso, uma prática bastante comum é usar um subconjunto dos 
dados de treinamento. Assim, precisamos dividir o conjunto original dos dados em duas partes: o 
conjunto de treinamento (normalmente 70% dos dados) e o conjunto de testes (normalmente 30% 
dos dados). A Figura 2.7 mostra essa divisão e o desempenho do classificador com dados 
desconhecidos. Perceba a mudança da matriz de confusão e da acurácia. 
Figura 2.7 – Desempenho dos dados de teste 
 Ao utilizar esta técnica, você perceberá que diferentes algoritmos, ou até o mesmo 
algoritmo configurado com parâmetros diferentes, podem apresentar desempenhos diferentes 
para o mesmo conjunto de dados. As Figuras 2.8 e 2.9 apresentam, respectivamente, o código-
fonte e o gráfico que mostra quatro boxplots com o desempenho do algoritmo KNN com K=1 e 
K=3, SVM e Árvores de Decisão. Perceba que o melhor desempenho foi apresentado pelo 
algoritmo SVM. 
 
19 
 
Figura 2.8 – Código para mostrar o desempenho de quatro algoritmos no mesmo conjunto de dados 
 
Figura 2.9 – Desempenho dos algoritmos: destaque para o SVM. 
 
2.3.5 Curvas de Aprendizagem 
 Vamos simular o efeito do número de exemplos nas taxas de erro de treinamento e teste 
para algoritmos de uma determinada complexidade. Essa curva é chamada de curva de 
aprendizagem. Vamos nos concentrar por um momento em um caso mais simples, utilizando 
conjuntos de teste e treinamento com dados aleatórios. Vamos considerar um classificador e 
20 
 
variar o número de exemplos com que o alimentamos para fins de treinamento, depois verificar o 
comportamento do treinamento e testar a precisão à medida que o número de exemplos aumenta. 
 Neste caso particular, usaremos o algoritmo de árvore de decisão com profundidade 
máxima fixa. A variável C=5 mostrada na Figura 2.10 representa a complexidade do algoritmo, ou 
seja, a profundidade da árvore de decisão. Observe na Figura que conforme o número de 
amostras de treinamento aumenta, ambos os erros tendem para o mesmo valor. Quando temos 
poucos dados de treinamento, o erro de treinamento é muito pequeno, mas o erro de teste é muito 
grande. 
Figura 2.10 – Curvas de aprendizagem (erros de teste e treinamento) para um classificador de alta 
complexidade 
 
 Agora, vamos repetir o processo com um classificador mais simples: uma árvore de 
decisão com profundidade máxima igual a 1 (C=1). Observe a Figura 2.11 em que o gráfico 
compara o resultado do exemplo anterior (classificador complexo) com o classificador mais 
simples e analise a diferença. É possível observar o seguinte: 
 com um baixo grau de complexidade, os erros de treinamento e teste convergem mais 
cedo / com menos dados; 
 além disso, com um baixo grau de complexidade, o erro de convergência é maior do que 
com o aumento da complexidade. 
 O valor em que os dois erros convergem (teste e treinamento) também é chamado de viés 
(bias); e a diferença entre esse valor e o erro de teste é chamada de variância. A decomposição 
de viés / variância da curva de aprendizado é uma abordagem alternativa para a visão de 
treinamento e generalização. 
 Vamos agora representar graficamente o comportamento de aprendizagem para um 
número fixo de exemplos com respeito à complexidade do classificador. Podemos usar os 
mesmos dados, mas agora vamos alterar a profundidade máxima da árvore de decisão, que 
determina a complexidade do classificador. 
21 
 
Figura 2.11 – Curvas de aprendizagem (erros de teste e treinamento) para um classificador de alta e 
um classificador de baixa complexidade 
 
Figura 2.12 – Curvas de aprendizagem (erros de teste e treinamento) para um mesmo 
conjunto de dados, com aumento da complexidade do algoritmo. 
 
 Observe a Figura 2.12 em que é possível observar que conforme a complexidade do 
classificador aumente (profundidade da árvore de decisão), o erro de treinamento é reduzido; mas 
acima de um certo nível de complexidade, o erro de teste passa a aumentar. Este efeito é 
chamado de overfitting. Existem algumas possibilidades para reduzir este problema: os modelos 
geralmente são configurados por meio de alguns hiperparâmetros. A determinação da 
complexidade do classificador geralmente é determinada por eles. Assim, temos a possibilidade 
de escolher o modelo ideal para nosso conjunto de dados. Uma boa solução para selecionar a 
complexidade é escolher o valor dos hiperparâmetros que produzam o menor erro de teste 
estimado. Isso pode ser feito usando validação cruzada (cross-validation). Existem vários tipos 
de validação cruzada, como leave-one-out e K-Fold: 
 no método leave-one-out, dadas N amostras do conjunto de dados, o classificador é 
treinado com N-1 amostras e testado com o restante; esse processo é repetido N vezes, uma vez 
por amostra de treinamento e o resultado final é a média dos erros; 
22 
 
 no método K-Fold, o conjunto de treinamento é dividido em K partes (folds) não 
sobrepostas; as partes K-1 são usadas para treinamento e a restante usada para teste; este 
processo é repetido K vezes, e o resultado final é a média dos erros. 
 As estratégias de seleção dos hiperparâmetros e validação cruzada podem ser usadas 
para auxiliar a selecionar a complexidade de um classificador, em um processo chamado 
validação, como descrito na próxima seção. 
 
2.3.6 Validação 
 Como estudamos anteriormente, precisamos selecionar um algoritmo de classificação e 
controlar sua complexidade de acordo com o número de dados de treinamento. Para fazer isso, 
podemos começar usando uma técnicade seleção de classificador. Já descrevemos como fazer 
isso, quando comparamos o desempenho de diferentes classificadores. Nesse caso, nossa 
melhor aposta era selecionar o classificador com o menor erro de treinamento. De forma análoga 
à seleção do classificador, podemos pensar na estratégia de selecionar os melhores 
hiperparâmetros, escolhendo aqueles que apresentam o melhor desempenho. Assim, podemos 
selecionar um conjunto de valores de hiperparâmetros e usar a validação cruzada para selecionar 
a melhor configuração. 
 O processo de seleção dos melhores hiperparâmetros é chamado de validação. Isso 
introduz um novo conjunto em nosso esquema de simulação; agora precisamos dividir os dados 
que temos em três conjuntos: conjuntos de treinamento, validação e teste. Como vimos, o 
processo de avaliar o desempenho do classificador estimando o erro de generalização é chamado 
de teste. E o processo de seleção de um modelo usando a estimativa do erro de generalização é 
chamado de validação. Há uma diferença sutil, mas crítica entre os dois e temos que estar cientes 
disso ao lidar com problemas de classificação: 
 os dados de treinamento são usados para que o algoritmo possa "aprender" os padrões 
existentes nos exemplos do conjunto de dados; 
 os dados de teste são usados exclusivamente para avaliar o desempenho no final do 
processo e nunca serão usados no processo de aprendizagem; 
 os dados de validação são usados explicitamente para selecionar os hiperparâmetros / 
classificadores com o melhor desempenho de acordo com uma estimativa do erro de 
generalização. Esta é uma forma de aprendizado. 
 Na prática, recebemos apenas dados de treinamento e, no caso mais geral, temos que 
ajustar explicitamente alguns hiperparâmetros. Assim, como dividimos o conjunto de dados? A 
seguinte estratégia pode ser usada: 
1) divida o conjunto de dados original em dados de treinamento e teste; por exemplo, use 
30% do conjunto de dados original para fins de teste, que serão usados apenas para avaliar o 
desempenho do classificador; 
2) use os dados de treinamento restantes para selecionar os hiperparâmetros por meio de 
validação cruzada; 
3) treine o modelo com os hiperparâmetros selecionados e avalie o desempenho usando o 
conjunto de dados de teste. 
 A Figura 2.13 mostra o resultado da execução do código-fonte que usa a estratégia K-Fold 
(10 partições) de validação cruzada, para avaliar o desempenho do hiperparâmetro profundidade 
do algoritmo de classificação árvore de decisão. 
23 
 
Figura 2.13 – Boxplots com a acurácia de diferentes complexidades da árvore de decisão 
 O gráfico é resultado de 18 iterações, em que a variação da complexidade ocorreu da 
profundidade 2 até 19. Como podemos ver na Figura, a melhor acurácia média é obtida pelo 
quinto modelo, cuja profundidade máxima é 6. Embora possamos verificar que a melhor precisão 
é com um valor de complexidade de 6, não podemos dizer nada sobre o valor que ela alcançará. 
Para ter uma estimativa desse valor, precisamos executar o modelo em um novo conjunto de 
dados diferente, tanto no treinamento quanto no teste. 
 
2.4 Considerações Finais 
 Neste segundo capítulo, nós descrevemos os principais conceitos e atividades 
relacionados a construção de modelos preditivos, baseados em algoritmos de aprendizagem 
supervisionada, também chamados de classificadores. Você estudou como realizar a importação 
dos dados de um estudo de caso sobre empréstimos financeiros, e como realizar algumas 
transformações básicas sobre os dados para que eles possam ser efetivamente usados em um 
classificador. Na sequência, vimos as três atividades principais que devem ser executadas na 
construção de um classificador: a fase de treinamento é executada para que o algoritmo possa 
"aprender" os padrões existentes nos exemplos do conjunto de dados; na fase de teste o 
desempenho do algoritmo é avaliado; e por fim, na validação são selecionados os 
hiperparâmetros / modelos com o melhor desempenho, de acordo com uma estimativa do erro de 
generalização. Você aprendeu o conceito de matriz de confusão, usado para gerar as principais 
métricas que avaliam o desempenho de um classificador: acurácia, precision, recall e F1-score. 
Por fim, você aprendeu o conceito de curva de aprendizagem, analisando o desempenho de 
algoritmos com diferentes complexidades, sobre diferentes tamanhos de conjunto de dados. Na 
próxima unidade, estudaremos o funcionamento de alguns dos principais algoritmos de 
aprendizagem supervisionada: KNN, Árvores de Decisão e SVM. 
 
Unidade 3: Aprendizagem Supervisionada - Classificação 
 
3.1 Considerações Iniciais 
 A aprendizagem supervisionada é usada quando queremos prever um resultado a partir de 
um determinado conjunto de entradas. O objetivo é fazer previsões para dados novos com o 
24 
 
máximo de precisão possível. Na classificação, o objetivo é prever o rótulo de classe, que é uma 
escolha em uma lista predefinida de possibilidades. A classificação normalmente é dividida em 
classificação binária, que é o caso especial de distinguir exatamente entre duas classes, e 
multiclasse, que é aquela entre mais de duas classes. Você pode pensar na classificação binária 
como uma tentativa de responder a uma pergunta sim / não. Classificar emails como spam ou não 
spam é um exemplo de problema de classificação binária. Nesta tarefa de classificação binária, a 
pergunta sim / não feita seria "Este e-mail é spam?" Neste capítulo, estudaremos alguns dos 
algoritmos de classificação mais usados, e explicaremos como eles aprendem com os dados e 
como fazem previsões. Também discutiremos como o conceito de complexidade do modelo 
funciona para cada um deles e forneceremos uma visão geral de como cada algoritmo constrói tal 
modelo. Examinaremos os pontos fortes e fracos de cada algoritmo e a que tipo de dados eles 
podem ser melhor aplicados. Também explicaremos o significado dos hiperparâmetros e as 
configurações mais importantes. O capítulo está estruturado da seguinte forma: na Seção 3.2 
vamos introduzir os conceitos do algoritmo K-Nearest Neighbor (KNN); na Seção 3.3 
descreveremos os detalhes do algoritmo de classificação por Árvores de Decisão; na Seção 3.4 
estudaremos o algoritmo Support Vector Machines (SVM); por fim, a Seção 3.5 faz as 
considerações finais do capítulo. 
 
3.2 O Algoritmo K-Nearest Neighbor (KNN) 
 KNN é o algoritmo mais simples usado em aprendizagem de máquina, pois construir o 
classificador consiste apenas em armazenar o conjunto de dados de treinamento. Para fazer uma 
previsão para um novo item de dado, o algoritmo encontra os itens mais próximos no conjunto de 
treinamento, usando a estratégia “vizinhos mais próximos”. 
 Em sua versão mais simples, o algoritmo considera apenas um vizinho mais próximo, que 
é o item de dados do treinamento mais próximo do item para o qual queremos fazer uma previsão. 
A Figura 3.1 mostra essa 
estratégia, considerando um 
conjunto de dados genérico. 
 
 
 
 
 
 
 
 
 
 
Figura 3.1 – Predições feitas pelo classificador KNN, com K=1, para um conjunto de dados genérico 
 Perceba que são adicionados três novos itens de dados, representados por uma estrela. 
Para cada uma delas, marcamos o ponto mais próximo no conjunto de treinamento. A previsão do 
algoritmo é o vizinho mais próximo ao item. Em vez de considerar apenas o vizinho mais próximo, 
também podemos considerar um número arbitrário K de vizinhos (neighbours). É justamente daí 
25 
 
que vem o nome do algoritmo K-Neighbours. Ao considerar mais de um vizinho, contamos 
quantos deles são da cor laranja e quantos são azuis. Em seguida, atribuímos a classe que é a 
mais frequente: em outras palavras, a classe majoritária entre os K vizinhos. A Figura 3.2 usa os 
três vizinhos mais próximos. Novamente, a previsão é mostrada como a cor da estrela. Você pode 
ver que a previsão mudou para o item no canto superior esquerdo,quando foi usado apenas um 
vizinho. 
 
 
 
 
 
 
 
 
 
 
Figura 3.2 – Predições feitas pelo classificador KNN, com K=3, para um conjunto de dados genérico 
 
3.2.1 Analisando o algoritmo KNN 
 Considerando um conjunto de dados genérico e bidimensional, também podemos ilustrar a 
previsão para todos os pontos de teste possíveis no plano xy. Colorimos o plano de vermelho nas 
regiões onde os pontos seriam atribuídos à classe vermelha e, caso contrário, de azul. Isso nos 
permite visualizar o limite de decisão, que é a divisão entre onde o algoritmo atribui um item à 
classe vermelha ou à classe azul. A Figura 3.3 mostra uma visualização do limite de decisão para 
um, três e cinco vizinhos. 
Figura 3.3 – Limite de decisão para três possíveis valores de K 
 
 
 
26 
 
 Vamos investigar se podemos confirmar a conexão entre a complexidade do modelo e seu 
poder de generalização. Faremos isso no conjunto de dados de câncer de mama do mundo real. 
Começamos dividindo o conjunto de dados em um treinamento e um conjunto de teste. Em 
seguida, avaliaremos o desempenho do treinamento e do conjunto de testes com diferentes 
números de vizinhos. 
 O gráfico da Figura 3.4 mostra a acurácia do conjunto de treinamento e teste no eixo y em 
comparação com a configuração de N vizinhos no eixo x. Embora os gráficos do mundo real 
raramente sejam muito suaves, ainda podemos reconhecer algumas das características de 
overfitting. Considerando um único vizinho mais próximo, a previsão do conjunto de treinamento é 
perfeita. Considerando mais vizinhos, a acurácia do treinamento diminui. A precisão do conjunto 
de teste para usar um único vizinho é menor do que ao usar mais vizinhos, indicando que usar um 
único vizinho mais próximo leva a um modelo que é pouco complexo. Por outro lado, ao 
considerar 10 vizinhos o desempenho é pior. O melhor desempenho está em algum lugar no meio, 
usando seis vizinhos. Deve-se ter em mente que o pior desempenho é de cerca de 88% de 
acurácia, o que ainda pode ser aceitável. 
 
 
 
 
 
 
 
 
 
 
 
Figura 3.4 – Acurácia do algoritmo KNN para diferentes valore de K 
 
3.2.2 Regressão com o algoritmo KNN 
 Também existe uma variante de regressão do algoritmo de KNN. Mais uma vez, vamos 
começar usando um único vizinho mais próximo, utilizando outro conjunto de dados genérico. 
Observe a Figura 3.5: adicionamos três itens de dados de teste como estrelas verdes no eixo x. A 
previsão usando um único vizinho é apenas o valor do vizinho mais próximo, mostrado como a 
estrela azul. Também é possível usar mais de um vizinho mais próximo para a regressão. Neste 
caso, a previsão é a média dos vizinhos mais relevantes. 
 Para conjuntos de dados unidimensionais, podemos facilmente ver as previsões para todos 
os valores possíveis dos atributos. Na Figura 3.6, os pontos vermelhos são as respostas para os 
dados de treinamento, enquanto a linha vermelha é a previsão feita pelo classificador para todos 
os itens de dados. Usando apenas um único vizinho, cada ponto no conjunto de treinamento tem 
uma influência óbvia nas previsões, e os valores previstos passam por todos os pontos de dados. 
Isso leva a uma previsão muito instável. Considerar mais vizinhos leva a previsões mais suaves, 
mas elas também não se ajustam bem aos dados de treinamento. 
27 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 3.5 – Exemplo de regressão para o algoritmo KNN, com K=1 
 
Figura 3.6 – Exemplo de regressão para o algoritmo KNN, com K=1, K=3 e K=9 
 
3.2.3 Vantagens, desvantagens e hiperparâmetros 
 A princípio, existem dois hiperparâmetros importantes para o classificador KNN: o número 
de vizinhos e como você mede a distância entre os itens de dados. Na prática, usar um pequeno 
número de vizinhos como 3 ou 5 geralmente funciona bem, mas você certamente deve ajustar 
esse hiperparâmetro. A escolha da medida de distância certa está um pouco além do escopo 
deste capítulo. Por padrão, a distância euclidiana é usada, o que funciona bem em muitos 
conjuntos de dados. 
 Um dos pontos fortes do KNN é que a estratégia do classificador é muito fácil de entender 
e geralmente oferece um desempenho razoável sem muitos ajustes. Este algoritmo é um bom 
método base antes de considerar técnicas mais avançadas. Ao usá-lo, é importante pré-processar 
seus dados, pois muitas vezes o algoritmo não funcionam bem em conjuntos de dados com 
muitos atributos ou em dados esparsos. Embora KNN seja fácil de entender, o algoritmo pode 
apresentar lentidão da previsão devido à sua incapacidade de lidar com muitos atributos. 
 
 
28 
 
 
3.3 Árvores de Decisão 
 Árvores de decisão são algoritmos de aprendizagem de máquina que podem ser usados 
para tarefas tanto de classificação quanto de regressão. Essencialmente, eles aprendem uma 
hierarquia de perguntas do tipo "if-else", levando a um encadeamento de decisões. Essas 
perguntas são semelhantes às perguntas que você pode fazer em um jogo de perguntas. Imagine 
que você queira distinguir entre os quatro animais a seguir: urso (bear), falcão (hawk), pinguim 
(penguin) e golfinho (dolphin). Seu objetivo é chegar à resposta certa fazendo o mínimo possível 
de perguntas. 
 Você pode começar perguntando se o animal tem penas (feathers), uma pergunta que 
restringe as possibilidades a apenas dois animais. Se a resposta for sim, você pode fazer outra 
pergunta que pode ajudá-lo a distinguir entre falcões e pinguins. Por exemplo, você pode 
perguntar se o animal pode ou não voar. Se o animal não tem penas, suas possíveis escolhas são 
golfinhos e ursos, e você precisará fazer uma pergunta para distinguir entre esses dois animais, 
por exemplo, perguntando se o animal tem nadadeiras (fins). Essa série de perguntas pode ser 
expressa como uma árvore de decisão, conforme mostrado na Figura 3.7. Nesta Figura, cada nó 
na árvore representa uma pergunta ou um nó terminal (também chamado de folha) que contém a 
resposta. As linhas conectam as respostas a uma pergunta com a próxima pergunta que você 
faria. 
 No jargão de aprendizagem de máquina, construímos um classificador para distinguir 
quatro classes de animais (falcões, pinguins, golfinhos e ursos) usando os três atributos “tem 
penas”, “pode voar” e “tem nadadeiras”. 
 
 
 
 
 
 
 
 
 
Figura 3.7 – Exemplo de Árvore de Decisão 
 
3.3.1 Construindo classificadores baseados em Árvores de Decisão 
 Vamos analisar o processo de construção de uma árvore de decisão para um conjunto de 
dados genérico 2D mostrado no topo da Figura 3.8. O conjunto de dados possui duas formas de 
meia-lua de pontos azuis e vermelhos, consistindo em 50 pontos de dados cada. 
 A aprendizagem com o algoritmo de árvore de decisão baseia-se em aprender uma 
sequência de perguntas “if-else” que nos leva à verdadeira resposta de forma mais rápida. Na 
configuração do algoritmo, essas questões são chamadas de testes (não deve ser confundido 
com o conjunto de testes, que são os dados que usamos para testar e ver o quão generalizável 
nosso classificador é). Normalmente, os dados não vêm na forma de atributos binários Sim / Não, 
29 
 
como no exemplo dos animais, mas são representados como atributos contínuos, como no 
conjunto de dados 2D mostrado no topo da Figura 3.8. Os testes que são usados em dados 
contínuos são do tipo “o atributo i é maior que o valor a”. Para construir uma árvore, o algoritmo 
analisa todos os testes possíveis e encontra aquele que é mais informativo sobre a variável em 
questão. 
 A segunda parte da Figura 3.8 (depth=1) mostra o primeiro teste que é realizado: dividir o 
conjunto de dados horizontalmente em x[1] <= 0.06, que é a melhor linha de corte para separar os 
pontos azuis dos vermelhos. O nó superior, também chamado de raiz, representa todo o conjunto 
de dados, consistindo em 50 pontos vermelhos e 50 pontos azuis. Se o teste for verdadeiro, o 
ponto é atribuído ao nó esquerdo, que contém 2 pontos azuise 32 pontos vermelhos. Caso 
contrário, o ponto é atribuído ao nó direito, que contém 48 pontos azuis e 18 vermelhos. Esses 
dois nós correspondem às regiões superior e inferior mostradas na segunda parte da Figura 3.8. 
Mesmo que a primeira divisão tenha feito um bom trabalho ao separar os pontos azuis e 
vermelhos, a região inferior ainda contém pontos azuis e a região superior ainda contém muitos 
pontos vermelhos. Podemos construir um modelo mais preciso, repetindo o processo de busca do 
melhor teste em ambas as regiões. A terceira parte da Figura 3.8 (depth=2) mostra que a próxima 
divisão mais informativa para a região esquerda e direita é baseada em x[0]. Este processo 
recursivo produz uma árvore binária de decisões, com cada nó contendo um teste. 
 Como alternativa, você pode pensar em cada teste como uma divisão da parte dos dados 
atualmente ao longo de um eixo. Isso produz uma visão do algoritmo como a construção de uma 
partição hierárquica. Como cada teste diz respeito a apenas um único atributo, as regiões na 
partição resultante sempre têm limites paralelos ao eixo. A Figura 3.8 mostra o particionamento 
dos dados na coluna da esquerda e a árvore resultante na coluna da direita. O particionamento 
recursivo dos dados é geralmente repetido até que cada região na partição (cada folha na árvore 
de decisão) contenha apenas um único valor de destino (uma única classe). 
Figura 3.8 – Classificação dos dados usando diferentes profundidades de Árvores de Decisão 
 
3.3.2 Analisando Árvores de Decisão 
 Podemos visualizar uma árvore de decisão usando a função export_graphviz do pacote 
scikit-learn. Ela cria um arquivo no formato dot, que é um formato de texto específico para 
armazenar gráficos. Definimos uma opção para colorir os nós para refletir a classe majoritária em 
cada um deles e passar os nomes das classes e atributos para que a árvore possa ser 
30 
 
devidamente rotulada. O resultado pode ser visualizado na Figura 3.9. A visualização da árvore 
fornece uma visão detalhada de como o algoritmo faz previsões, sendo um exemplo facilmente 
explicável para não especialistas. Árvores mais profundas (acima de dez níveis) são mais difíceis 
de apreender. Um método de inspecionar a árvore que pode ser útil é descobrir qual caminho a 
maioria dos dados realmente segue. 
Figura 3.9 – Árvore de decisão para o conjunto de dados sobre câncer de mama 
 
 O valor samples mostrado em cada nó fornece o número de amostras em cada um 
deles, enquanto value fornece o número de amostras por classe. Seguindo os ramos à direita, 
vemos que texture_error <= 0.4732 cria um nó que contém apenas 8 amostras benignas, mas 
134 malignas. O resto deste lado da árvore usa algumas distinções mais sutis para separar essas 
8 amostras benignas restantes. Das 142 amostras que foram para a direita na divisão inicial, 
quase todas elas (132) acabaram na folha à direita. 
 
3.3.3 Importância dos Atributos 
 Em vez de analisar a árvore inteira, o que pode ser exaustivo, existem algumas métricas 
estatísticas úteis que podemos usar para resumir o comportamento da árvore. A métrica mais 
usada é a importância do atributo, que avalia a importância de cada atributo para a decisão que 
uma árvore toma. É representada por um número entre 0 e 1 para cada atributo, em que 0 
significa “nada usado” e 1 significa “prediz perfeitamente a classe”. A soma das métricas de 
importância de todos os atributos é igual a 1. A Figura 3.10 mostra a importância dos atributos 
para o conjunto 
de dados sobre 
câncer de mama. 
 
 
 
 
31 
 
 
 
 
 
 
 
Figura 3.10 – Importância dos atributos para o conjunto de dados sobre câncer de mama 
3.3.4 Vantagens, desvantagens e hiperparâmetros 
 Conforme discutido anteriormente, os hiperparâmetros que controlam a complexidade do 
algoritmo de árvores de decisão são aqueles que interrompem a construção da árvore antes que 
ela seja totalmente desenvolvida. Normalmente, pode-se escolher estratégias de “poda” da árvore 
para evitar o overfitting, configurando hiperparâmetros como min_depth, max_leaf_nodes ou 
min_samples_leaf. 
 As árvores de decisão têm duas vantagens sobre muitos dos algoritmos de aprendizagem 
de máquina: o classificador resultante pode ser facilmente visualizado e compreendido por não 
especialistas (pelo menos para árvores menores) e eles são completamente invariáveis para o 
dimensionamento dos dados, ou seja, o atributo é processado separadamente e as possíveis 
divisões dos dados não dependem de atividades de pré-processamento, como normalização ou 
padronização. As árvores de decisão funcionam bem quando você tem atributos que estão em 
escalas completamente diferentes ou uma mistura de atributos categóricos e contínuos. A principal 
desvantagem desse algoritmo é que, mesmo com o uso de estratégias de “poda”, as árvores de 
decisão tendem a se ajustar demais e não fornecem um bom desempenho de generalização. 
 
3.4 Support Vector Machines (SVM) 
 SVM são uma extensão de classificadores lineares que permite o treinamento de modelos 
mais complexos que não são definidos simplesmente por hiperplanos no espaço de entrada. 
Embora existam máquinas de vetores de suporte para classificação e regressão, nos 
restringiremos ao caso de classificação, conforme implementado na classe SVC do pacote scikit-
learn. A matemática por trás deste algoritmo é um pouco complicada e está além do escopo deste 
capítulo. No entanto, tentaremos passar algumas intuições sobre a ideia por trás do método. 
 
3.4.1 Modelos lineares e atributos não lineares 
 Os modelos lineares podem ser bastante limitados em espaços de baixa dimensão, pois as 
linhas ou hiperplanos têm flexibilidade limitada. Uma maneira de tornar um modelo linear mais 
flexível é adicionando mais atributos, por exemplo, adicionando interações ou polinômios dos 
atributos de entrada. Um modelo linear para classificação só pode separar pontos usando uma 
linha e não será capaz de fazer um bom trabalho em um conjunto de dados como o mostrado na 
Figura 3.11. 
32 
 
 
 
 
 
 
 
 
 
 
 
Figura 3.11 – Limite da decisão de um classificador linear 
 Agora, vamos expandir o conjunto de atributos de entrada, adicionando também 
feature1^2, ou seja, o quadrado do segundo atributo, como um novo atributo. Em vez de 
representar cada item de dado como um ponto bidimensional (feature0, feature1), agora vamos 
representá-lo como um ponto tridimensional (feature0, feature1, feature1^2). Escolhemos este 
atributo específico para fins de ilustração, contudo, o alvo da escolha não é particularmente 
importante. Esta nova representação é ilustrada na Figura 3.12, em um gráfico de dispersão 
tridimensional. 
 
 
 
 
 
 
 
 
 
 
Figura 3.12 – Expansão do conjunto de dados mostrado na Figura 3.9, criado pela adição de um 
terceiro atributo (feature1^2) derivado de feature1. 
 Na nova representação tridimensional dos dados, agora é possível separar os itens 
vermelhos e azuis usando um modelo linear: um plano em três dimensões. Podemos conf irmar 
isso ajustando um modelo linear aos dados aumentados, como mostra a Figura 3.13(a). Em 
função das características originais, o classificador SVM linear não é mais uma linha, mas sim, 
uma elipse, como mostrado na Figura 3.13(b). 
33 
 
Figura 3.13 – (a) Limite de decisão encontrado por um algoritmo SVM linear no conjunto de dados 
tridimensional expandido. (b) Limite de decisão como uma função dos dois atributos originais. 
 A lição aqui é que adicionar atributos não lineares à representação de nossos dados pode 
tornar os modelos lineares muito mais poderosos. No entanto, muitas vezes não sabemos quais 
atributos adicionar, e adicionar atributos demasiadamente (como todas as interações possíveis em 
um espaço de atributos de 100 dimensões) pode tornar a computação muito cara. Felizmente, 
existe um “truque matemático” inteligente que nos permite criar um classificadorem um espaço 
dimensional superior sem realmente computar a nova representação, possivelmente muito 
grande. Essa estratégia é conhecida como truque do kernel. 
 O truque do kernel funciona calculando diretamente a distância (mais precisamente, os 
produtos escalares) dos itens de dados para a representação de atributo expandido, sem nunca 
realmente calcular a expansão. Existem duas maneiras de mapear seus dados em um espaço 
dimensional mais alto que são comumente usados com máquinas de vetores de suporte: o kernel 
polinomial, que calcula todos os polinômios possíveis até um certo grau dos atributos originais 
(como feature0^2 * feature1^5), e o kernel da função de base radial (radial basis function – 
RBF), também conhecido como kernel gaussiano. O kernel gaussiano é um pouco mais difícil de 
explicar, pois corresponde a um espaço de atributos dimensionais infinitos. Uma maneira de 
explicá-lo é que ele considera todos os polinômios possíveis de todos os graus, mas a importância 
dos atributos diminui para graus mais elevados. Se tudo isso é muito conceitual matematicamente 
para você, não se preocupe, você pode usar um classificador SVM sem imaginar espaços 
dimensionais infinitos. 
 Durante o treinamento, o SVM aprende a importância de cada um dos itens de dados de 
treinamento para representar o limite de decisão entre duas classes. Normalmente, apenas um 
subconjunto dos itens de treinamento importa para definir o limite de decisão: aqueles que ficam 
na fronteira entre as classes. Eles são chamados de vetores de suporte e dão seu nome ao 
algoritmo SVM. Para fazer uma previsão para um novo item, a distância para cada um dos vetores 
de suporte é medida. Uma decisão de classificação é feita com base nas distâncias ao vetor de 
suporte e na importância daqueles vetores que foram aprendidos durante o treinamento. 
 
3.4.2 O papel dos hiperparâmetros 
34 
 
 O hiperparâmetro gamma controla a largura do kernel gaussiano. Ele determina a escala 
do que significa os pontos estarem próximos. O hiperparâmetro C é um parâmetro de 
regularização, semelhante ao usado nos modelos lineares. Ele limita a importância de cada item 
de dado. Observe a Figura 3.14. Vamos analisar o que acontece quando variamos esses 
parâmetros. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 3.14 – Limites de decisão e vetores de suporte para diferentes configurações dos 
hiperparâmetros C e gamma. 
35 
 
 Da esquerda para a direita, aumentamos o valor do parâmetro gamma de 0.1 para 10. Um 
valor pequeno significa um grande raio para o kernel gaussiano, ou seja, muitos pontos são 
considerados próximos. Isso se reflete em limites de decisão muito suaves à esquerda e limites 
que se concentram mais em pontos únicos mais à direita. Portanto, um valor baixo de gamma 
significa que o limite de decisão irá variar lentamente, o que produz um modelo de baixa 
complexidade, enquanto um valor alto de gamma produz um modelo mais complexo. 
 De cima para baixo, aumentamos o parâmetro C de 0.1 para 1000. Tal como acontece com 
os modelos lineares, um valor pequeno de C significa um modelo muito restrito, onde cada item de 
dado pode ter uma influência muito limitada. Perceba que no canto superior esquerdo, o limite de 
decisão parece quase linear, com os pontos classificados erroneamente. Aumentar o valor de C, 
conforme mostrado no canto inferior direito, permite que esses pontos tenham uma influência mais 
forte no modelo e ajusta a curva do limite de decisão para classificá-los corretamente. 
 
3.4.3 Vantagens, desvantagens e hiperparâmetros 
 SVM são classificadores poderosos e funcionam bem em uma variedade de conjuntos de 
dados. Eles permitem limites de decisão complexos, mesmo se os dados tiverem poucos 
atributos. Eles funcionam bem em dados de baixa e alta dimensão (ou seja, poucos e muitos 
atributos), mas não se adaptam muito bem a um pequeno número de amostras. Executar um SVM 
em dados com até 10.000 amostras pode funcionar bem, mas trabalhar com conjuntos de dados 
de tamanho 100.000 ou mais pode se tornar um desafio em termos de tempo de execução e uso 
de memória. 
 Outra desvantagem dos SVM é que eles exigem um pré-processamento cuidadoso dos 
dados e o ajuste dos hiperparâmetros. É por isso que, atualmente, a maioria das pessoas usa 
modelos baseados em árvore, que exigem pouco ou nenhum pré-processamento. Além disso, os 
classificadores SVM são difíceis de inspecionar; pode ser difícil entender por que uma predição 
específica foi feita e pode ser complicado explicar o modelo para um não especialista. Ainda 
assim, pode valer a pena tentar SVMs, principalmente se todos os seus atributos representarem 
medidas em unidades semelhantes (por exemplo, todas são intensidades de pixel) e estão em 
escalas semelhantes. 
 Os hiperparâmetros importantes em SVM são o parâmetro de regularização C, a escolha 
do kernel e os parâmetros específicos do kernel. Embora tenhamos nos concentrado 
principalmente no kernel RBF, outras opções estão disponíveis na biblioteca scikit-learn. O kernel 
RBF possui apenas o parâmetro gamma, que é o inverso da largura do kernel gaussiano. gamma e 
C controlam a complexidade do algoritmo, com grandes valores resultando em um classificador 
mais complexo. Portanto, boas configurações para os dois parâmetros geralmente estão 
fortemente correlacionadas, e ambos devem ser ajustados juntos. 
 
3.5 Considerações Finais 
 Neste terceiro capítulo, nós descrevemos alguns dos principais algoritmos usados em 
aprendizagem supervisionada, mais especificamente do tipo classificação. Primeiro, aprendemos 
como usar o algoritmo KNN, que usa o conceito de distância aos vizinhos mais próximos para 
classificar um novo item de dado. A seguir, estudamos o funcionamento das árvores de decisão, 
36 
 
que aprendem uma hierarquia de perguntas do tipo "if-else", levando a um encadeamento de 
decisões, de forma bastante intuitiva. Por fim, conhecemos o algoritmo SVM, que são uma 
extensão de classificadores lineares que permite o treinamento de modelos mais complexos que 
não são definidos simplesmente por hiperplanos no espaço de entrada. No próximo capítulo, 
iniciaremos os estudos sobre análise de regressão. 
 
Unidade 4: Aprendizagem Supervisionada – Regressão 
 
4.1 Considerações Iniciais 
 Neste capítulo, apresentamos a análise de regressão e algumas de suas aplicações. A 
regressão está relacionada a como fazer previsões sobre as quantidades do mundo real, como, 
por exemplo, as previsões relacionadas às perguntas: como o volume de vendas muda com as 
mudanças no preço? Como o volume de vendas é afetado pelo clima? Como o título de um livro 
afeta suas vendas? Como a quantidade de uma droga absorvida varia com o peso corporal do 
paciente? Qual é a chance de chuva nas próximas duas segundas-feiras; e qual é a temperatura 
esperada? Todas essas perguntas têm uma estrutura comum: pedem uma resposta que pode ser 
expressa como uma combinação de uma ou mais variáveis independentes (também chamadas de 
covariáveis ou preditores). O papel da regressão é construir modelos para prever as respostas 
dessas variáveis contínuas. O capítulo está estruturado da seguinte forma: na Seção 4.2 vamos 
introduzir os conceitos Regressão Linear Simples e Regressão Linear Múltipla; na Seção 4.3 
descreveremos os detalhes da Regressão Polinomial; na Seção 4.4 estudaremos a Regressão 
Logística; por fim, a Seção 4.5 faz as considerações finais do capítulo. 
 
 
 
4.2 Regressão Linear Simples 
 O objetivo de realizar uma Regressão é construir um modelo para expressar a relação 
entre a variável de resposta 𝑦 (quantitativa) e uma combinação de uma ou mais variáveis 𝑦𝑦 
(independentes), também quantitativas. O modelo nos permite prever a resposta da variável 𝑦. 
 O modelo de regressão mais simples que podemos imaginar é o modelo linear, em que a 
resposta 𝑦 depende linearmente das variáveis 𝑦𝑦. Na regressão linear