Data Science

Prévia do material em texto

FUNDAMENTOS DE 
APRENDIZAGEM 
DE MÁQUINA 
Maikon Lucian Lenz 
Abordagens de 
aprendizagem de máquina 
e principais tarefas
Objetivos de aprendizagem
Ao final deste texto, você deve apresentar os seguintes aprendizados:
 � Reconhecer os tipos de aprendizado de máquina.
 � Categorizar tarefas de aprendizado de máquina de acordo com os 
tipos propostos.
 � Diferenciar o processo de aprendizado de máquina de acordo com 
os tipos propostos.
Introdução
O aprendizado de máquina é uma área abrangente e em constante 
crescimento. Nos últimos anos, muitas tarefas de aprendizado foram 
desenvolvidas, o que contribui para o avanço não só da inteligência 
artificial, mas da tecnologia como um todo. Soluções antes inimagináveis 
estão sendo criadas graças ao aprendizado de máquina. Entretanto, 
há muitas características em comum entre as tarefas desenvolvidas. 
O tipo de aprendizado de máquina é um dos fatores mais importantes 
de determinada tarefa, além de um conceito que permite ao iniciante 
na área de aprendizado de máquina compreender muitos dos princípios 
envolvidos sem que seja necessário analisar toda a imensidão de algo-
ritmos e exemplos de cada um deles.
O aprendizado de máquina é dividido em quatro tipos, de acordo com 
a forma como o sistema compreende se o modelo que está utilizando 
é mais ou menos adequado aos dados apresentados. Para tanto, a má-
quina passa por um processo de treinamento. Enquanto o aprendizado 
supervisionado demanda o conhecimento prévio dos atributos-alvo, o 
tipo de aprendizado não supervisionado busca estruturas intrínsecas aos 
dados para tentar agrupá-los conforme as similaridades que apresentam. 
Há ainda os tipos de aprendizado semissupervisionado e por reforço. 
O primeiro combina os tipos anteriormente citados, de modo geral, 
devido ao fato de somente uma parte dos dados ser acompanhada 
de atributos-alvo. O segundo recebe estímulos que reforçarão ou não 
determinada característica do modelo.
Neste capítulo, você estudará sobre quatro tipos de aprendizados 
de máquina. 
1 Aprendizado de máquina
Apesar de a etapa de treinamento ser a mais enfatizada, o aprendizado de 
máquina envolve ainda outras etapas. Um exemplo é a seleção e preparação 
dos dados, que permite que os dados estejam adequados ao modelo e às tare-
fas utilizadas. Também têm vital importância para o sucesso no processo de 
aprendizado as etapas de teste, de validação e, quando necessário, o ajuste e 
refinamento de parâmetros para melhorar o desempenho do modelo. A Figura 1 
apresenta um resumo das etapas de aprendizado.
Figura 1. Etapas do aprendizado de máquina. 
Abordagens de aprendizagem de máquina e principais tarefas2
O processamento de dados em aprendizado de máquina pode ser de na-
tureza preditiva ou descritiva. Tarefas preditivas são aquelas que têm como 
objetivo estimar o atributo-alvo de uma nova instância a partir de um modelo 
previamente gerado. Em outras palavras, como o próprio nome sugere, elas são 
capazes de prever os valores de atributo-alvo para uma dada combinação de 
atributos previsores. Para treinar uma máquina do tipo preditivo, é necessário 
que as instâncias fornecidas durante o processo sejam acompanhadas do 
respectivo atributo-alvo, também conhecido como rótulo. Assim, o algoritmo 
poderá comparar o resultado obtido com o resultado esperado e proceder aos 
ajustes necessários na tentativa de melhorar sua previsão. 
As tarefas descritivas, por sua vez, têm por função explorar um conjunto de 
dados sem qualquer interferência externa, seja simultânea ou previamente definida, 
com o intuito de organizar e separar os dados a partir de padrões percebidos entre 
eles. A Figura 2 detalha como são organizadas as tarefas de aprendizado de má-
quina segundo a perspectiva do tipo de aprendizado utilizado e quais são os tipos 
de aplicações comuns a elas. É possível observar que as tarefas de classificação, 
regressão e agrupamento (na qual estão inclusas, ainda, associação e sumarização) 
podem ser aninhadas em diferentes tipos de aprendizado, como supervisionado, 
não supervisionado, semissupervisionado e por reforço.
Figura 2. Classificação dos tipos de aprendizado de máquina.
Tipos de
aprendizado de
máquinas
Aprendizado
supervisionado
Aprendizado não
supervisionado
Aprendizado
semissupervisionado
Aprendizado por
reforço
Atributos de saída
contínuos
Atributos de saída
discretos
Variável de destino
não disponível
Rótulo
Clusterização
Variável-alvo
Variável de destino
não disponível
Regressão
Estimativa de preço
residencial
Classi�cação
Exames de imagem
Clusterização
Associação
Classi�cação
Classi�cação
Controle
Localização de vias
em dados no GPS
Segmentação de
clientes
Análise de mercado
Classi�cação de
texto
Otimização de
marketing
Veículo autônomo
3Abordagens de aprendizagem de máquina e principais tarefas
As maiores diferenças ficam por conta dos tipos de aprendizado super-
visionado, não supervisionado e por reforço, uma vez que o aprendizado 
semissupervisionado é uma mescla dos dois primeiros. O Quadro 1 apresenta 
um resumo das principais diferenças entre os três tipos.
Características
Tipos de aprendizado
Semissupervisionado
Reforço
Supervisionado
Não 
supervisionado
Conjunto 
de dados
Valores para 
atributo previsor 
e alvo.
Dados não 
rotulados.
Sem 
atributo-alvo.
Aprimoramento
Treinamento 
do modelo 
com base nas 
instâncias 
rotuladas.
Análise 
intrínseca.
Recompensas 
e punições.
Tarefa
Prever a resposta 
ou o rótulo 
correto.
Agrupar 
instâncias com 
características 
similares.
Buscar novas 
hipóteses no 
sentido de 
tentar reduzir 
as punições e 
aumentar as 
recompensas.
Quadro 1. Comparativo das principais características entre os tipos de aprendizado
Todavia, uma aplicação nem sempre é fácil de enquadrar de maneira rígida 
e restrita ao esquema apresentado na Figura 2. É comum que um problema 
demande o uso de diferentes tipos de aprendizado, um exemplo é a própria 
existência de uma categoria denominada semissupervisionada, que combina 
os tipos supervisionado e não supervisionado.
Abordagens de aprendizagem de máquina e principais tarefas4
Cada uma das categorias envolve diferentes tipos de aplicações, no entanto, 
os problemas reais costumeiramente podem abranger fenômenos e dados de 
naturezas diversas, misturando características de dois ou mais tipos de apren-
dizado. Muitas vezes, o dado a ser examinado não decorre nem de uma, nem 
de outra natureza específica, mas da própria interação em si, o que terminará, 
por sua vez, na mixagem de tipos de aprendizado e tarefas.
Um ótimo exemplo para demonstrar o quão complexo pode se tornar um 
problema de aprendizado de máquina é a própria fala humana. A máquina 
não apenas deverá ser capaz de compreender a estrutura sintática e semântica 
da linguagem utilizada pelo interlocutor como também reconhecer padrões 
vocais, além de diferenciar entonações para avaliar diferentes ênfases que 
podem sugerir desde uma apresentação literal de determinada informação 
até o seu inverso, utilizando-se de tom irônico na pronúncia.
Aprendizado supervisionado
Imagine uma máquina capaz de melhorar a sua performance de previsão 
somente quando lhe são informados de maneira direta os valores de saída espe-
rados. Nesse caso, pode-se dizer que o aprendizado é supervisionado, porque, 
apesar de a máquina varrer os dados em busca de padrões que a permitam 
melhorar o modelo que utiliza para a previsão, o conhecimento dos atributos 
corretos de alvo para determinado conjunto de atributos previsores requer que 
outro indivíduo ou máquina os tenha classificado em um momento anterior.
Mesmo que não haja qualquer interferência externa durante o tempo de 
execução do algoritmo, compreende-se que o programa está sendo orientado 
por dados que demandaram algum conhecimento prévio. Assim, o aprendizado 
supervisionado pressupõe a existência, ou emulação, de um supervisor que 
o orienta quanto à assertividade objetiva de suas previsões (FACELI et al.,originais e os previstos pelo modelo (Figura 5).
Figura 5. Comparativo entre os clusters originais (à esquerda) e os previstos pelo k-means 
(à direita).
Na Figura 5, nota-se que as cores são diferentes para cada um dos clus-
ters, motivo que levou à criação do dicionário de tradução, já que a ordem 
dos clusters está invertida. Por essa razão, é possível imaginar que existem 
instâncias agrupadas em clusters diferentes em cada exemplo, e uma rápida 
observação denunciaria isso entre as espécies virginica e versicolor. As flores 
que, originalmente, eram classificadas como virginica, mas apresentavam 
características de comprimento de sépala e largura de pétala que as inseriam 
dentro do cluster da espécie versicolor, não puderam ser agrupadas de modo 
correto pelo algoritmo de k-means devido a essa sobreposição na distribuição. 
Também é possível constatar a quantidade de erros ao comparar quais instâncias 
estão agrupadas em clusters diferentes entre cada DataFrame (original e 
previsto), contabilizando o tamanho do vetor encontrado através da função 
len que retornará um total de 26 instâncias com clusters divergentes.
Aprendizagem não supervisionada: aplicação do k-means18
# Exemplo 11
len(prevDataFrame[iDF_SL_PW_T['specie'] != 
prevDataFrame['specie']])
cm = confusion_matrix(iDF_SL_PW_T['specie'], 
prevDataFrame['specie'])
cmtx = pa.DataFrame(
 cm, 
 index=('Real: ' + pa.DataFrame(iTarget_Names))
[0],
 columns=('Prev: ' + pa.DataFrame(iTarget_Na-
mes))[0]
 )
cmtx, accuracy_score(iDF_SL_PW_T['specie'], 
prevDataFrame['specie'])
O exemplo anterior, além de apresentar o algoritmo para calcular os erros, 
também utiliza a função confusion_matrix para apresentar uma matriz 
de confusão relacionando os valores esperados e os obtidos para cada grupo, 
como apresentado no Quadro 3, além do percentual de acerto segundo o 
método accuracy_score.
Prev: setosa Prev: versicolor Prev: virginica
Real: setosa 50 0 0
Real: versicolor 4 39 7
Real: virginica 0 15 35
Quadro 3. Matriz de confusão
19Aprendizagem não supervisionada: aplicação do k-means
Entretanto, a matriz de confusão e a quantidade de erros só podem ser 
utilizadas porque os rótulos corretos de cada espécie são conhecidos na biblio-
teca SciKit-Learn. Na maioria das situações, o agrupamento é utilizado em 
conjuntos de dados em que se pretende aprender estruturas ou características 
relacionadas para, só então, determinar a possibilidade de se rotular algum 
grupo.
Outras métricas devem ser utilizadas em situações em que os grupos 
originais não são conhecidos. O exemplo a seguir calcula a silhueta média 
dos clusters, uma das métricas mais utilizadas na avaliação de agrupamentos 
por k-means. Ambos buscam por grupos que possuem pouca ou nenhuma 
sobreposição.
# Exemplo 12
from sklearn.metrics import silhouette_score
prevs = alg.predict(iData_SL_PW)
silhouette_score(iData_SL_PW, prevs)
Para a silhueta, é encontrado um valor de 0,5, que é um bom valor para 
um índice que varia de –1 a 1. Quanto mais baixo esse número, maior a 
quantidade de instâncias que poderiam ser agrupadas em outro cluster. 
Outro indicador disponibilizado pela biblioteca do SciKit-Learn é o índice de 
Calinski-Harabasz, que calcula e avalia a taxa de dispersão entre os clusters 
pela dispersão entre os membros de cada um deles. Veja o exemplo a seguir.
# Exemplo 13
from sklearn import metrics
from sklearn.metrics import pairwise_distances
metrics.calinski_harabasz_score(iData_SL_PW, prevs)
Aprendizagem não supervisionada: aplicação do k-means20
Quanto maior for o índice de Calinski-Harabasz, melhor será o agru-
pamento. No entanto, esse valor fará mais sentido quando comparado com 
diferentes agrupamentos, podendo determinar qual é o maior deles e, portanto, 
o mais eficiente. A critério de comparação, quando testado o treinamento do 
k-means para valores de k = 2 e k = 4, teríamos, respectivamente, índices iguais 
a 318,25 e 323,32, enquanto que, para k = 3, conforme os exemplos executados, 
o índice seria de 350,24, ou seja, o maior entre eles conforme o esperado, 
já que sabemos que três clusters existem no conjunto de dados original.
ARTHUR, D.; VASSILVITSKII, S. K-means++: the advantages of careful seeding. In: ACM-
-SIAM SYMPOSIUM ON DISCRETE ALGORITHMS, 18., 2007, New Orleans. Proceedings 
[...]. Philadelphia: SIAM, 2007, p. 1027–1035. Disponível em: http://theory.stanford.
edu/~sergei/papers/kMeansPP-soda.pdf. Acesso em: 28 fev. 2020.
SCIKIT-LEARN. Clustering. c2019a. Disponível em: https://scikit-learn.org/stable/modules/
clustering.html#k-means. Acesso em: 28 fev. 2020.
SCIKIT-LEARN. sklearn.cluster.KMeans. c2019b. Disponível em: https://scikit-learn.org/
stable/modules/generated/sklearn.cluster.KMeans.html#sklearn.cluster.KMeans. Acesso 
em: 28 fev 2020. 
Leituras recomendadas
ANACONDA INC. Anaconda distribution. c2020. Disponível em: https://www.anaconda.
com/distribution/#download-section. Acesso em: 28 fev. 2020. 
FACELI, K. et al. Inteligência artificial: uma abordagem de aprendizado de máquina. Rio 
de Janeiro: LTC, 2011.
JAMES, G. et al. An introduction to statistical learning: with application in R. New York: 
Springer, 2013.
WITTEN, I. H.; FRANK, E. Data mining: practical machine learning tools and techniques. 
2nd ed. Boston: Morgan Kaufmann, 2005.
21Aprendizagem não supervisionada: aplicação do k-means
Os links para sites da web fornecidos neste livro foram todos testados, e seu funciona-
mento foi comprovado no momento da publicação do material. No entanto, a rede 
é extremamente dinâmica; suas páginas estão constantemente mudando de local 
e conteúdo. Assim, os editores declaram não ter qualquer responsabilidade sobre 
qualidade, precisão ou integralidade das informações referidas em tais links.
Aprendizagem não supervisionada: aplicação do k-means22
FUNDAMENTOS DE 
APRENDIZAGEM DE 
MÁQUINA
Rodrigo Santarelli
Aprendizagem 
supervisionada: árvores 
de decisão e regressão
Objetivos de aprendizagem
Ao final deste texto, você deve apresentar os seguintes aprendizados:
 � Reconhecer os algoritmos de árvores de decisão com base em entropia 
e ganho de informação.
 � Descrever os passos de um algoritmo com base em árvores de decisão.
 � Aplicar critérios de entropia e ganho de informação para a avaliação 
de resultados.
Introdução
O problema de classificação possui um valor de saída discreto, ou seja, 
haverá uma resposta nominal ou booleana, por exemplo, se uma mulher 
de 27 anos gosta ou não de cebola no sanduíche em determinada rede 
de fast-food. Já o problema de regressão apresenta como solução um 
valor de grandeza real, seja ele dado por uma média ponderada ou não, 
ou por outro modelo matemático, como a mediana, em que temos, por 
exemplo, o valor estimado do peso de homens com 1,83 m de altura 
em uma dada população.
Árvores de decisão são métodos utilizados também em aprendi-
zado de máquinas, muito úteis em tarefas de classificação e regressão, 
enquanto as árvores de regressão são aplicadas em problemas de regres-
são. Assim, árvores de decisão e regressão são métodos com base em 
procura, sistemas orientados a conhecimento que objetivam a criação 
de estruturas simbólicas que sejam compreensíveis por humanos, além 
de usarem a estratégia de “dividir para conquistar” no intuito de resolver 
problemas de decisão. Além disso, o problema complexo é dividido em 
problemas mais simples, em que a mesma estratégia é usada, as soluções 
dos subproblemas são combinadas na forma de uma árvore e, em uma 
árvore de decisão, uma decisão é tomada através do caminhamento a 
partir do nodo raiz até o nodo folha.
Neste capítulo, você será capaz de resolver problemas de classifica-
ção e regressão utilizando árvores de decisão e de regressão. Também 
compreenderá a lógica da geração de árvores usando os conceitos de 
ganho de informação e entropia.
1 Algoritmos de árvores de decisão com base 
em entropia e ganho de informação
Árvores de decisãosão estruturas de dados formadas por um conjunto de 
elementos que armazenam alguns tipos de informações aos chamados nós 
(ou nodos). Nessa estrutura, a árvore terá um nodo chamado raiz, conhecido 
como o ponto de partida, e suas conexões para outros elementos, denominadas 
nodos filhos. Esses nodos filhos poderão ter seus próprios nodos filhos, e assim 
sucessivamente. Já o nodo que não possui filho é reconhecido como nodo folha 
ou terminal. Assim, a árvore de decisão possui a característica de armazenar 
regras em seus nodos, e os nodos folhas representarão a decisão a ser tomada.
Aplicamos as árvores de decisão em grandes bases de dados com o objetivo 
de descobrir automaticamente regularidades implícitas nessas bases, expres-
sando-as em forma de regras. Sua finalidade é determinar quais campos de 
informação na base de dados são importantes e se relacionam com o problema.
A partir de um conjunto de treino, com exemplos previamente classificados, 
as árvores de decisão passam pelo processo de treinamento, para que outros 
exemplos possam ser classificados a seguir de acordo com essa mesma árvore. 
O algoritmo de treinamento construirá a arvore de decisão da raiz até as folhas, 
de cima para baixo, fazendo a identificação do atributo mais importante, 
chamado de divisor ou teste. Esse atributo é o que faz a maior diferença para 
a classificação das amostras existentes. Já no teste, a árvore construída é 
testada e usada para classificar um novo conjunto de amostras independentes 
e separadas das utilizadas no treinamento. Havendo uma precisão considerada 
aceitável após os testes, é possível usar a árvore na classificação de amostras 
desconhecidas, oferecendo resultados aos problemas (Figura 1).
Aprendizagem supervisionada: árvores de decisão e regressão2
Figura 1. Caracterizar um cidadão como amigo ou inimigo.
Sim Não
Inimigo
BandeiraEspada
Inimigo Amigo
Sorri
Porta
Se o cidadão da Figura 1 não sorri, a resposta direta é inimigo. Se o cidadão 
sorri, é preciso saber se ele está portando uma espada (e será indicado como 
inimigo) ou se está portando uma bandeira (indicado como amigo). Outra 
forma de visualização de árvore de decisão é demonstrada pela Figura 2, 
quanto à condição de saúde de um cidadão.
Figura 2. Caracterizar um cidadão saudável ou doente.
Cidadão sente-se
bem?
Cidadão sente
dor?
Temperatura
cidadãobinária 0000001000 é de 4,6890 bits de 
informação total da mensagem, pois temos 10 dígitos em que cada “0” vale 
0,152 bits por ter pouca incerteza (imprevisibilidade), enquanto o único dígito 
“1” tem mais informação, sendo 3,321 bits. Veja:
Infototal = 9 × (informação do “0”) + 1 × (informação do “1”)
Infototal = 9 × 0,152 + 1 × 3,3219 = 4,6899 bits
Se alterarmos o percentual de aparição do dígito “1” ou o tamanho da 
sequência binária, teremos para esse novo caso um outro valor de entropia. 
Se a amostra ou, nesse caso, nossa sequência binária, for completamente homo-
gênea, teremos entropia zero, e se a amostra for completamente heterogênea, 
a entropia será um (valor igual a 1).
O ganho de informação nos apresenta um valor com base na redução de 
entropia após um conjunto ser dividido a partir de um atributo. Para definir 
o atributo que gera ramos da árvore de decisão mais homogêneos, temos:
1. inicialmente, calcular a entropia do conjunto de instâncias ou dados;
2. esse conjunto, então, deve ser dividido usando os diferentes atributos;
3. a entropia de cada ramo deve ser calculada e subtraída da entropia de 
antes da divisão;
4. ganho de informação é o resultado dessa operação;
5. o atributo com o maior ganho de informação é escolhido como nodo 
de decisão;
6. quando o ramo tiver entropia zero, ele será um nodo folha.
7Aprendizagem supervisionada: árvores de decisão e regressão
Todo esse processo repete-se recursivamente. No Quadro 1, adaptado de 
Faceli et al. (2011), a coluna Corrida nos indica se poderemos ou não ter o 
evento de uma corrida de Fórmula 1, com base nos atributos indicados em 
Clima, Temperatura, Aderência da pista e Vento. Nesse exemplo, existem 14 
(S) condições, ou amostras, das quais 9 (s1) determinam a classe Sim, haverá 
corrida, e 5 (s2) indicam a classe Não haverá corrida.
Fonte: Adaptado de Faceli et al. (2011).
Condição Clima Temperatura
Aderência 
da pista
Vento Corrida
C1 Sol Quente Baixa Fraco Não
C2 Sol Quente Baixa Forte Não
C3 Nuvens Quente Baixa Fraco Sim
C4 Chuva Normal Baixa Fraco Sim
C5 Chuva Frio Normal Fraco Sim
C6 Chuva Frio Normal Forte Não
C7 Nuvens Frio Normal Forte Sim
C8 Sol Normal Baixa Fraco Não
C9 Sol Frio Normal Fraco Sim
C10 Chuva Normal Normal Fraco Sim
C11 Sol Normal Normal Forte Sim
C12 Nuvens Normal Baixa Forte Sim
C13 Nuvens Quente Normal Fraco Sim
C14 Chuva Normal Baixa Forte Não
Quadro 1. Condições para uma corrida de Fórmula 1 (F1)
Aprendizagem supervisionada: árvores de decisão e regressão8
A entropia será:
I(s1,s2) = I(9,5) = ‒ (9/14) · log2 · (9/14) ‒ (5/14) · log2 · (5/14) = 0,940
O cálculo da entropia a cada atributo discreto será:
a) Atributo = Clima; Instância = Sol; Classe = Sim (Amostras s11 = 2); 
Classe = Não (Amostras s21 = 3)
I(s11,s21) = I(2,3) = ‒ (2/5) · log2 · (2/5) ‒ (3/5) · log2 · (3/5) = 0,971
b) Atributo = Clima; Instância = Nuvens; Classe = Sim (Amostras s12 = 4); 
Classe = Não (Amostras s22 = 0)
I(s12,s22) = I(4,0) = ‒ (4/4) · log2 · (4/4) ‒ (0/4) · log2 · (0/4) = 0,0
c) Atributo = Clima; Instância = Chuva; Classe = Sim (Amostras s13 = 3); 
Classe = Não (Amostras s23 = 2)
I(s13,s23) = I(3,2) = ‒ (3/5) · log2 · (3/5) ‒ (2/5) · log2 · (2/5) = 0,971
d) Atributo = Temperatura; Instância = Quente; Classe = Sim (Amostras 
s11 = 2); Classe = Não (Amostras s21 = 2)
I(s11,s21) = I(2,2) = ‒ (2/4) · log2 · (2/4) ‒ (2/4) · log2 · (2/4) = 1,0
e) Atributo = Temperatura; Instância = Normal; Classe = Sim (Amostras 
s12 = 4); Classe = Não (Amostras s22 = 2)
I(s12,s22) = I(4,2) = ‒ (4/6) · log2 · (4/6) ‒ (2/6) · log2 · (2/6) = 0,918
f) Atributo = Temperatura; Instância = Frio; Classe = Sim (Amostras s13 
= 3); Classe = Não (Amostras s23 = 1)
I(s13,s23) = I(3,1) = ‒ (3/4) · log2 · (3/4) ‒ (1/4) · log2 · (1/4) = 0,811
9Aprendizagem supervisionada: árvores de decisão e regressão
g) Atributo = Aderência; Instância = Baixa; Classe = Sim (Amostras s11 
= 3); Classe = Não (Amostras s21 = 4)
I(s11,s21) = I(3,4) = ‒ (3/7) · log2 · (3/7) ‒ (4/7) · log2 · (4/7) = 0,985
h) Atributo = Aderência; Instância = Normal; Classe = Sim (Amostras s12 
= 6); Classe = Não (Amostras s22 = 1)
I(s12,s22) = I(6,1) = ‒ (6/7) · log2 · (6/7) ‒ (1/7) · log2 · (1/7) = 0,592
i) Atributo = Vento; Instância = Forte; Classe = Sim (Amostras s11 = 3); 
Classe = Não (Amostras s21 = 3)
I(s11,s21) = I(3,3) = ‒ (3/6) · log2 · (3/6) ‒ (3/6) · log2 · (3/6) = 1,0
j) Atributo = Vento; Instância = Fraco; Classe = Sim (Amostras s12 = 6); 
Classe = Não (Amostras s22 = 2)
I(s12,s22) = I(6,2) = ‒ (6/8) · log2 · (6/8) ‒ (2/8) · log2 · (2/8) = 0,811
Portanto, a entropia a cada amostra de condição para a corrida de Fórmula 1 
será dada por:
 � E(Clima) = (((2 + 3) / 14) · 0,971) + (((4 + 0) / 14) · 0,0) + (((3 + 2) / 14) 
· 0,971) = 0,694 
 � E(Temperatura) = (((2 + 2) / 14) · 1,0) + (((4 + 2) / 14) · 0,918) + (((3 + 1) 
/ 14) · 0,811) = 0,911
 � E(Aderência) = (((3 + 4) / 14) · 0,985) + (((6 + 1) / 14) · 0,592) = 0,789
 � E(Vento) = (((3 + 3) / 14) · 1,0) + (((6 + 2) / 14) · 0,811) = 0,892
Considerando todos os valores calculados anteriormente, vamos então ao 
Ganho de Informação:
 � Ganho(Clima) = 0,940 – 0,694 = 0,246
 � Ganho(Temperatura) = 0,940 – 0,911 = 0,029
 � Ganho(Aderência) = 0,940 – 0,789 = 0,151
 � Ganho(Vento) = 0,940 – 0,892 = 0,048
Aprendizagem supervisionada: árvores de decisão e regressão10
O atributo que possui o maior ganho de informação é o Clima, com o 
valor de 0,246. Assim, ele é o escolhido para ser o divisor do nodo raiz da 
árvore de decisão. O processo não termina nesse ponto, deve-se continuar os 
cálculos recursivamente e, a partir de Clima, teremos a possibilidade de uma 
nova ramificação com o atributo Sol. A partir do atributo Clima = Sol, o ganho 
de informação de saída dos outros três atributos (Temperatura, Aderência e 
Vento) será dado por:
 � Ganho(Temperatura) = 0,971 – 0,400 = 0,571
 � Ganho(Aderência) = 0,971 – 0,0 = 0,971
 � Ganho(Vento) = 0,971 – 0,951 = 0,020
Entropia:
I(s1,s2) = I(2,3) = – (2/5) · log2 · (2/5) – (3/5) · log2 · (3/5) = 0,971
O cálculo da entropia a cada atributo discreto será:
a) Atributo = Temperatura; Instância = Quente; Classe = Sim (Amostras 
s11 = 0); Classe = Não (Amostras s21 = 2)
I(s11,s21) = I(0,2) = – (0/2) · log2 · (0/2) – (2/2) · log2 · (2/2) = 0,0
b) Atributo = Temperatura; Instância = Normal; Classe = Sim (Amostras 
s12 = 1); Classe = Não (Amostras s22 = 1)
I(s12,s22) = I(1,1) = – (1/2) · log2 · (1/2) – (1/2) · log2 · (1/2) = 1,0
c) Atributo = Temperatura; Instância = Frio; Classe = Sim (Amostras s13 
= 1); Classe = Não (Amostras s23 = 0)
I(s13,s23) = I(1,0) = – (1/1) · log2 · (1/1) – (0/1) · log2 · (0/1) = 0,0
11Aprendizagem supervisionada: árvores de decisão e regressão
d) Atributo = Aderência; Instância = Baixa; Classe = Sim (Amostras s11 
= 0); Classe = Não (Amostras s21 = 3)
I(s11,s21) = I(0,3) = – (0/3) · log2 · (0/3) – (3/3) · log2 · (3/3) = 0,0
e) Atributo = Aderência; Instância = Normal; Classe = Sim (Amostras s12 
= 2); Classe = Não (Amostras s22 = 0)
I(s12,s22) = I(2,0) = – (2/2) · log2 · (2/2) – (0/2) · log2 · (0/2) = 0,0
f) Atributo = Vento; Instância = Forte; Classe = Sim (Amostras s11 = 1); 
Classe = Não (Amostras s21 = 1)
I(s11,s21) = I(1,1) = – (1/2) · log2 · (1/2) – (1/2) · log2 · (1/2) = 1,0
g) Atributo = Vento; Instância = Fraco; Classe = Sim (Amostras s12 = 1); 
Classe = Não (Amostras s22 = 2)
I(s12,s22) = I(1,2) = – (1/3) · log2 · (1/3) – (2/3) · log2 · (2/3) = 0,918
Portanto, a entropia a cada amostra de condição Sol é dada por:
 � E(Temperatura) = (((0 + 2) / 5) · 0,0) + (((1 + 1) / 5) · 1,0) + (((1 + 0) / 5) 
· 0,0) = 0,400
 � E(Aderência) = (((0 + 3) / 5) · 0,0) + (((2 + 0) / 5) · 0,0) = 0,0
 � E(Vento) = (((1 + 1) / 5) · 1,0) + (((1 + 2) / 5) · 0,918) = 0,951
Como o Ganho (Aderência) possui o maior valor de informação, com os 
seus 0,971 bits, o atributo Aderência será selecionado como ramificação. 
O processo deve continuar com a mesma ideia, o que nos leva à ilustração 
da Figura3.
Aprendizagem supervisionada: árvores de decisão e regressão12
Figura 3. Ilustração da árvore de decisão com 
nodos folha puros.
Sol
... ...
Baixa Normal
Não
Não
Não
Sim
Sim
Aderência
Clima
Esse processo deve terminar quando todos os nodos da folha são puros, 
ou seja, quando é possível que todas as amostras venham a ter a mesma 
classificação. Contudo, talvez não se consiga ramificar nessa condição de ter 
todos os nodos folha puros, em razão de haver, no conjunto de treino, dois 
ou mais exemplos/amostras com conjunto de atributos idênticos para classes 
diferentes. Assim, deve-se parar quando não podem ser mais ramificados. Em 
contraposição à escolha anterior em que temos nodos folha puros, a Figura 4 
nos apresenta a formação da árvore de decisão com os nodos folha não puros.
Figura 4. Ilustração da árvore de decisão com nodos folha não puros.
Sol Sol
Quente Frio
... ... ......
Fraco Forte
Sim
Não
Não
Sim
Não Não
Não
Sim
Não
Sim
Clima Clima
TemperaturaVento
Normal
13Aprendizagem supervisionada: árvores de decisão e regressão
Assim, podemos afirmar que:
 � quando em Clima temos Sol e Aderência é Normal, SIM, teremos 
corrida de Fórmula 1;
 � quando em Clima temos Sol e Aderência é Baixa, NÃO teremos corrida 
de Fórmula 1.
A Figura 5 ilustra a árvore de decisão com nodos folha puros, em que pode-
remos ter ou não o evento de uma corrida de Fórmula 1, com base nos cálculos 
apresentados de entropia e ganho de informação ao longo deste capítulo.
Figura 5. Ilustração da árvore de decisão.
Sol
Nuvens
Chuva
Baixa
Baixa
BaixaNormal
Normal
Normal
Não
Não
Não
Não
Não
Sim
Sim
Sim
Sim
Sim
Sim
Sim
Sim
Sim
Aderência Aderência
Aderência
Vento
Vento
Forte
Forte
Fraco
Fraco
Clima
Para complementar o conteúdo deste capítulo, leia os artigos “Aplicação de algoritmos 
de árvore de decisão sobre uma base de dados de câncer de mama”, de Jéssica Augusti 
Bonini, e “Avaliação da escolha de um fornecedor sob condição de riscos a partir do 
método de árvore de decisão”, de Wesley Vieira da Silva, Jansen Maia Del Corso, Hanna 
Tatarchenko Welgacz e Julinês Bega Peixe.
Aprendizagem supervisionada: árvores de decisão e regressão14
AMADO, N. M. R. Algoritmos paralelos de indução de árvores de decisão. 2001. Disserta-
ção (Mestrado em Inteligência Artificial e Computação) – Faculdade de Engenharia, 
Universidade do Porto, Porto, 2001.
FACELI, K. et al. Inteligência artificial: uma abordagem de aprendizado de máquina. Rio 
de Janeiro: LTC, 2011.
INGARGIOLA, G. Building classification models: ID3 and C4.5. [Philadelphia: Temple Uni-
versity, 1994]. Notas de aula do curso de Inteligência Artifical da Temple University. 
Também apresentado no Workshop "Providing and Integrating Educational Resources 
for Faculty Teaching Artificial Intelligence", da mesma universidade, entre 20 e 25 de 
junho de 1994. Disponível em: https://cis.temple.edu/~ingargio/cis587/readings/id3-
-c45.html. Acesso em: 9 abr. 2020.
POZO, A. T. R. Árvores de decisão. [Curitiba]: Universidade Federal do Paraná, [200-?]. 
Notas de aula do Departamento de Informática, da Universidade Federal do Paraná. 
Disponível em: http://www.inf.ufpr.br/aurora/disciplinas/datamining/arvore-decisao.
pdf. Acesso em: 9 abr. 2020.
Leituras recomendadas
BONINI, J. A. Aplicação de algoritmos de árvore de decisão sobre uma base de dados 
de câncer de mama. ComIng, v. 1, n. p. 57–67, 2016. Disponível em: https://periodicos.
ufsm.br/coming/article/view/21132/12781. Acesso em: 9 abr. 2020.
BREIMAN, L. et al. Classification and regression trees. Belmont: Wadsworth,1984.
FONSECA, J. M. M. R. Indução de árvores de decisão: HistClass: proposta de um algoritmo 
não paramétrico. 1994. Dissertação (Mestrado em Engenharia Informática) – Departa-
mento de Informática, Universidade Nova de Lisboa, Lisboa, 1994.
REZENDE, S. O. et al. Mineração de dados. In: REZENDE, S. O. (org.). Sistemas inteligentes: 
fundamentos e aplicações. Barueri: Manole, 2003. p. 307–335.
WELGACZ, H. T. et al. Avaliação da escolha de um fornecedor sob condição de riscos 
a partir do método de árvore de decisão. In: ENCONTRO DA ANPAD, 31., 2007, Rio de 
Janeiro. Anais [...]. Maringá: ANPAD, 2007.Disponível em: http://www.anpad.org.br/
diversos/down_zips/33/ADI-D230.pdf. Acesso em: 9 abr. 2020.
15Aprendizagem supervisionada: árvores de decisão e regressão
Os links para sites da web fornecidos neste capítulo foram todos testados, e seu fun-
cionamento foi comprovado no momento da publicação do material. No entanto, a 
rede é extremamente dinâmica; suas páginas estão constantemente mudando de 
local e conteúdo. Assim, os editores declaram não ter qualquer responsabilidade 
sobre qualidade, precisão ou integralidade das informações referidas em tais links.
Aprendizagem supervisionada: árvores de decisão e regressão16
FUNDAMENTOS DE 
APRENDIZAGEM 
DE MÁQUINA
Maikon Lucian Lenz
Aprendizagem 
supervisionada: 
aplicação de árvores para 
classificação e regressão
Objetivos de aprendizagem
Ao final deste texto, você deve apresentar os seguintes aprendizados:
 � Desenvolver um conjunto de dados para as tarefas de predição, clas-
sificação ou regressão.
 � Aplicar algoritmos de árvore de decisão.
 � Determinar métricas para avaliação dos resultados obtidos utilizando 
métodos de amostragem e validação.
Introdução
As árvores de decisão dividem o espaço de hipóteses, seja para rotular 
a saída ou para determinar valores contínuos de saída. Esse método, 
apesar de não garantir uma solução ótima global, é bastante utilizado e 
costuma apresentar bom desempenho tanto em classificação quanto em 
regressão. Assim como outros algoritmos de aprendizado, a biblioteca 
do Scikit-Learn implementa métodos e classes que facilitam o desenvol-
vimento de aplicações utilizando esses modelos.
Neste capítulo, você vai ver de que forma as árvores de decisão podem 
ser parametrizadas usando o Scikit-Learn e vai conhecer a importância 
das métricas de avaliação e das técnicas de amostragem, em especial, 
o hold-out e o cross-validation.
1 Árvores de decisão e regressão 
no Scikit-Learn
As árvores de decisão são algoritmos não paramétricos que, como o nome 
sugere, fazem uso de regras de decisão para determinar um atributo alvo 
a partir dos atributos previsores. O treinamento de uma árvore de decisão 
consiste no aprendizado dessas regras de decisão. Trata-se, portanto, de um 
método baseado em procura, quando um espaço de hipóteses é varrido para 
encontrar a melhor solução (FACELI et al., 2011).
A biblioteca Scikit-Learn, por sua vez, implementa o algoritmo de árvores 
de decisão, assim como outros métodos de aprendizado. Nela, há um módulo 
destinado exclusivamente a esses algoritmos: sklearn.tree (SCIKIT-
-LEARN, c2019a).
Os algoritmos de decisão produzem grafos acíclicos, no sentido de um nó 
folha ou de outras divisões do espaço de hipóteses em que os nós de divisão 
expressam um teste condicional dos valores de atributos previsores. Como 
critério de aprendizado, são usadas funções de custo 0-1 para obter a moda 
ou minimizar a média do erro médio quadrático, para tarefas de classificação 
e regressão, respectivamente (FACELI et al., 2011). A Figura 1 ilustra uma 
árvore de decisão e o respectivo espaço de hipóteses.
Figura 1. Árvore de decisão (à esquerda) e o respectivo espaço de hipóteses (à direita).
Fonte: FACELI et al. (2011, p. 84).
Aprendizagem supervisionada: aplicação de árvores para classificação e regressão2
Enquanto a função de custo não satisfazer o critério, o espaço de hipóteses 
será recursivamente subdividido, conforme a Figura 1. As decisões não podem 
ser reconsideradas e o algoritmo pode levar a uma solução ótima local, porém, 
com solução normalmente rápida e satisfatória. Os atributos que serão alvo 
do teste de decisão em cada nó são determinados segundo a entropia, ou seja, 
o teste será utilizado para aqueles que representam menor aleatoriedade na 
variável do alvo (FACELI et al., 2011).
Além da função de custo,opções que impactam fortemente sobre o de-
sempenho de uma árvore de decisão são os critérios de poda, que podem ser 
pré-poda, para evitar o crescimento de alguns nós, ou pós-poda, para remover 
nós que não contribuem de forma significativa para a acurácia de classificação. 
É necessário também ter um cuidado especial com valores desconhecidos, 
uma vez que a árvore de decisão é hierárquica e testes deixarão de ser feitos 
a partir do momento que um atributo nulo apareça (FACELI et al., 2011).
Os algoritmos mais populares de árvores de decisão são quatro: ID3, que 
utiliza o atributo categórico com maior ganho de informação para a cons-
trução da árvore, que é expandida até o seu tamanho máximo e, somente 
ao final, podada para aumentar a capacidade de generalização; C4.5, uma 
evolução do ID3 que permite o uso de atributos não categóricos utilizando 
valores discretizados, cuja saída também difere do ID3 por não ser mais 
uma árvore, mas um conjunto de regras de decisão; C5.0, que não apresenta 
modificações substanciais, porém, desempenho e acurácia superiores ao C4.5; 
e CART (do inglês, classification and regression trees). O CART, implemen-
tado pela biblioteca Scikit-Learn, pode ser utilizado tanto para regressões 
quanto classificações e se assemelha ao algoritmo C4.5, contudo, permite o 
uso de variáveis numéricas e constrói a árvore ao invés do conjunto de regras 
de decisão (SCIKIT-LEARN, c2019a).
Dois métodos são utilizados: o sklearn.tree.DecisionTree-
Classifier, para tarefas de classificação, e o sklearn.tree.Deci-
sionTreeRegressor, para tarefas de regressão. O Quadro 1 apresenta os 
parâmetros dos modelos de árvore de decisão.
3Aprendizagem supervisionada: aplicação de árvores para classificação e regressão
Parâmetro
DecisionTree- 
Classifier
DecisionTree- 
Regressor
criterion — 'gini': im-
pureza Gini; 'entropy': 
entropia/aleatoriedade.
X
criterion — 'mse': erro quadrá-
tico médio; 'friedman_mse': 
aprimoramento de Friedman para o 
mse; 'mae': erro médio absoluto.
X
splitter — 'best': melhor divi-
são; 'random': divisão aleatória.
X X
max_depth — profundi-
dade máxima (None).
X X
min_samples_split — nú-
mero mínimo de amostras 
para dividir um nó (2);
X X
min_samples_leaf – nú-
mero mínimo de amostras 
em um nó folha (1);
X X
min_weight_fraction_leaf 
— menor peso total para 
um nó folha (0,0);
X X
max_features — quantidade 
máxima de características relevan-
tes para dividir um nó (None).
X X
random_state — número 
de base para criar núme-
ros aleatórios (None);
X X
max_leaf_nodes — número 
máximo de nós folha (None);
X X
min_impurity_decrease 
— menor redução aceitável 
do indicador de impureza 
para dividir um nó (0,0);
X X
Quadro 1. Parâmetros dos modelos de árvore de decisão
(Continua)
Aprendizagem supervisionada: aplicação de árvores para classificação e regressão4
Parâmetro
DecisionTree- 
Classifier
DecisionTree- 
Regressor
min_impurity_split — maior 
valor aceitável de impureza 
para um nó folha (1,0e-7);
X X
class_weight — 'balan-
ced', lista ou dicionário con-
tendo os pesos (None).
X
ccp_alpha — custo de com-
plexidade mínimo (0,0).
X X
Quadro 1. Parâmetros dos modelos de árvore de decisão
(Continuação)
A maioria dos parâmetros e valores padrões assumidos por cada um dos mo-
delos são comuns em ambos os casos, com exceção do parâmetro criterion, 
que dispõe de opções diferentes para função de custo do classificador e regres-
sor, e do parâmetro class_weight, que obviamente não está presente no 
regressor por este lidar apenas com alvo de valor contínuo (SCIKIT-LEARN, 
c2019b, c2019c).
2 Algoritmos de árvore de decisão
Um classificador do tipo árvore de decisão pode ser inicializado utilizando o 
código-fonte a seguir.
# Exemplo 1 – Classificador
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier()
Assim como em outros algoritmos da biblioteca Scikit-Learn, estão pre-
sentes os métodos fit, predict e predict_proba. O método fit 
recebe um conjunto de dados separado em atributos previsores (parâmetro X) 
e atributo alvo (parâmetro y) e é utilizado no treinamento do modelo, como 
no exemplo apresentado a seguir.
5Aprendizagem supervisionada: aplicação de árvores para classificação e regressão
# Exemplo 2 – Treinamento
# importa o método load _ iris
from sklearn.datasets import load _ iris
# carrega os dados separando em atributos previsores (X) e alvo (y)
X, y = load _ iris(return _ X _ y=True)
# treina o modelo de árvore de decisão
model.fit(X=X, y=y)
Nesse exemplo, é utilizado o conjunto de dados Iris da biblioteca Scikit-
-Learn. Nele, 150 amostras de flores são classificadas em três espécies dife-
rentes a partir de suas características de comprimento e largura das sépalas 
e pétalas. Para tanto, o método load_iris carrega o conjunto de dados e, 
por meio do parâmetro return_X_y como True, retorna o conjunto na 
forma de uma tupla, dividindo-o em atributos previsores (variável X) e alvo 
(variável y). Na sequência, as variáveis X e y alimentam o método fit do 
modelo instanciado.
Para comparar o conjunto de dados original e seus respectivos rótulos 
com os rótulos previstos pelo modelo treinado, são criados DataFrame, 
que facilitam a substituição de valores numéricos por categorias, como é o 
caso da coluna espécies, e também tornam mais prático seu uso nas demais 
ferramentas, como Seaborn para produzir gráficos. No DataFrame criado, 
cada coluna representa um atributo e o atributo previsor tem seus valores 
dados pelos nomes das espécies conforme o dicionário criado para mapeá-los. 
Veja a seguir.
# Exemplo 3 – Previsão, DataFrames e Exibição de Gráficos
# Bibliotecas para criar DataFrame e gráficos
import pandas as pa
import seaborn as sb
import matplotlib.pyplot as pyp
# Dicionário que mapeará os rótulos numéricos para respectivas 
espécies
dic = {0: 'Setosa', 1: 'Versicolor', 2: 'Virginica'}
Aprendizagem supervisionada: aplicação de árvores para classificação e regressão6
# DataFrame do conjunto original
df = pa.DataFrame(X, columns=['Comprimento das Sépalas', 
 'Largura das Sépalas', 
 'Comprimento das Pétalas', 
 'Largura das Pétalas'])
df['Espécie'] = y
df['Espécie'] = df['Espécie'].apply(lambda i: dic[i])
# Previsão dos rótulos a partir dos atributos previsões
y _ prevs = model.predict(X)
# DataFrame com os rótulos previstos
df _ prevs = df.copy()
df _ prevs['Espécie'] = y _ prevs
df _ prevs['Espécie'] = df _ prevs['Espécie'].apply(lambda i: 
dic[i])
# Gráficos de distribuição dos dados originais e previstos
fig, axes = pyp.subplots(1, 2, figsize=(10,4))
sb.scatterplot( x=df['Comprimento das Pétalas'], 
 y=df['Comprimento das Sépalas'], 
 hue=df['Espécie'], ax=axes[0])
sb.scatterplot( x=df _ prevs['Comprimento das Pétalas'], 
 y=df _ prevs['Comprimento das Sépalas'], 
 hue=df _ prevs['Espécie'], 
 ax=axes[1])
axes[0].set _ title('a) Rótulos originais.')
axes[1].set _ title('b) Rótulos previstos.')
Ao final desse exemplo, são criadas duas colunas de imagem para exibir 
a distribuição de dados conforme os rótulos originais (Figura 2a) e os rótulos 
previstos (Figura 2b) utilizando o modelo treinado e o método predict com 
os valores de atributo previsor X. Uma vez que o conjunto de dados possui 
quatro atributos previsores, dois deles são selecionados para criar os gráficos, 
já que, apesar de possível, fazer um gráfico de quatro dimensões e um gráfico 
de três dimensões tornaria mais difícil comparar as instâncias.
7Aprendizagem supervisionada: aplicação de árvores para classificação e regressão
Figura 2. (a) Distribuição dos dados conforme rótulos originais. (b) Distribuição dos dados 
conforme rótulos previstos.
8.0
7.5
7.0
6.5
6.0
5.5
4.5
21 3 4 5 6 7 21 3 4 5 6 7
5.0
8.0
7.5
7.0
6.5
6.0
5.5
4.5
5.0
Comprimento das pétalasComprimento das pétalas
Co
m
pr
im
en
to
 d
as
 sé
pa
la
s
Co
m
pr
im
en
to
 d
as
 sé
pa
la
s
Espécie
Setosa
Versicolor
Virginica
Espécie
Setosa
Versicolor
Virginica
(a) (b)
Percebe-se que o modelo foi capaz de prever todos os rótulos corretamente. 
Ainda é possível visualizar a árvore gerada a partir de um método plot_tree 
disponível no módulo sklearn.tree conforme o exemplo 4.
# Exemplo 4 – Plot _ tree
# Importa a biblioteca tree
import sklearn.tree
# Cria uma área de gráfico de tamanho específico
fig, ax = pyp.subplots(figsize=(16, 8))
# Plota a árvore preenchida pela cor da classe que predomina no nó
arvore = sklearn.tree.plot _ tree(model, max _ depth=1000, font-
size=10, filled=True, ax=ax)
O resultado pode ser visualizado na Figura 3. Percebe-se que apenas um 
teste é necessário para separar uma das três espécies das demais, produzindo 
um nó folha já no primeiro nível de profundidade. Dali em diante, para separar 
as outras duas espécies, são necessários mais quatro níveis. Esse distanciamento 
para uma das classes já era esperado, uma vez que nos gráficos da Figura 2 
é possível notar que uma das classes está agrupada com uma separação bem 
definida das demais.
Aprendizagem supervisionada: aplicação de árvores para classificação e regressão8
Fi
gu
ra
 3
. Á
rv
or
e 
de
 d
ec
isã
o 
ge
ra
da
 p
el
os
 e
xe
m
pl
os
 3
 e
 4
.
X[
3]
boa representatividade dos 
dados; e o cross-validation, validação cruzada, em inglês, em que o conjunto 
de dados é dividido em vários grupos de mesmo tamanho e cada grupo serve 
uma vez como conjunto de teste, enquanto os demais são utilizados como 
treinamento.
Aprendizagem supervisionada: aplicação de árvores para classificação e regressão14
No hold-out, uma vez definida a proporção adequada, o treinamento ocorre 
uma única vez e é mais afetado pela variação do conjunto de dados. No cross-
-validation, o treinamento é efetuado tantas vezes quanto a quantidade de 
divisões criadas no conjunto de dados e o que importa é o valor médio entre 
todos os treinamentos.
As duas técnicas contam com métodos próprios na biblioteca do Scikit-
-Learn. O exemplo 8 aplica a técnica de hold-out e treina um modelo de árvore 
de decisão para nove proporções diferentes de treinamento/teste.
# Exemplo 8 – Hold-out
from sklearn.model _ selection import train _ test _ split
from sklearn.metrics import accuracy _ score
Xh, yh = load _ iris(return _ X _ y=True)
acc = []
tt = np.arange(0.1, 1, 0.1)
for t in tt:
 X _ treino, X _ teste, y _ treino, y _ teste = train _ test _
split(Xh, yh, 
 test _ size=t, 
 random _ state=4)
 modelh = DecisionTreeClassifier(random _ state=4)
 modelh.fit(X=X _ treino, y=y _ treino)
 acc.append(accuracy _ score(y _ teste, modelh.
predict(X _ teste))*100)
pa.DataFrame(acc, index=tt*100, columns=['Acurácia'])
Para facilitar a análise, uma tabela foi montada com os valores de acurácia 
medidos com a iteração com amostragem diferente, relacionando-os com a 
proporção do conjunto de testes, conforme a Figura 7.
15Aprendizagem supervisionada: aplicação de árvores para classificação e regressão
Figura 7. Acurácia obtida 
para diferentes proporções 
de amostragem.
Percebe-se que a acurácia aumenta até 30% quando atinge o maior valor 
entre todas as amostras. Era provável que esses resultados variassem bastante 
devido à aleatoriedade com que os grupos foram formados. Se aplicada a 
técnica de cross-validation, provavelmente, resultados mais constantes seriam 
observados. O algoritmo do exemplo 9 implementa essa técnica.
# Exemplo 9 – Cross-validation
from sklearn.model _ selection import cross _ val _ score
Xc, yc = load _ iris(return _ X _ y=True)
acc = []
dfc = pa.DataFrame()
for r in range(1, 5, 1):
 modelc = DecisionTreeClassifier(random _ state=r)
 s = 'Acurácia R' + str(r)
 cross = cross _ val _ score(modelc, Xc, yc, cv=10, 
 scoring='accuracy')*100
 cross = np.append(cross, sum(cross)/10)
 dfc[s] = cross
dfc
Aprendizagem supervisionada: aplicação de árvores para classificação e regressão16
Nesse caso, cada uma das linhas se refere a uma iteração do cross-vali-
dation, com exceção da última linha (10), que é composta pelo valor médio. 
É feito um laço para testar a variação dos índices com a aleatoriedade das 
amostragens alterando o valor de random_state, conforme a Figura 8.
Figura 8. Acurácia para diferentes estados de random_state.
Percebe-se pela tabela que, independentemente da aleatoriedade, a acurácia 
média permaneceu sempre próxima de 96%, sendo um indicador mais confiável 
do desempenho do modelo. 
Tanto o hold-out quanto o cross-validation são utilizados em tarefas de 
regressão. Entretanto, as métricas de avaliação são outras, já que o alvo, nesse 
caso, é um valor contínuo. Se a acurácia é uma das métricas mais utilizadas 
em classificadores, o erro quadrático médio desempenha papel similar nos 
regressores (FACELI et al., 2011).
17Aprendizagem supervisionada: aplicação de árvores para classificação e regressão
O exemplo 10 aplica o hold-out para o mesmo conjunto de dados criado 
no exemplo 6.
# Exemplo 10 – Erro Quadrático Médio (MSE, Mean Squared Error)
from sklearn.metrics import mean _ squared _ error
Xh = np.sort(2*np.pi * np.random.rand(50, 1), axis=0)
yh = np.sin(Xh).ravel()
mse = []
tt = np.arange(0.1, 1, 0.1)
for t in tt:
 X _ treino, X _ teste, y _ treino, y _ teste = train _ test _
split(Xh, yh, 
 test _ size=t, random _ state=4)
 modelh = DecisionTreeRegressor(random _ state=4)
 modelh.fit(X=X _ treino, y=y _ treino)
 mse.append(mean _ squared _ error(y _ teste, 
 modelh.predict(X _ teste))*100)
pa.DataFrame(mse, index=tt*100, columns=['MSE'])
Ao contrário da acurácia, busca-se pelo erro quadrático médio obter o 
menor valor possível. Nesse caso, a proporção de 10% de instâncias para o 
conjunto de testes apresentou o melhor desempenho, conforme a Figura 9. 
Entretanto, assim como na classificação, o hold-out é bastante impactado pela 
aleatoriedade das amostras.
Aprendizagem supervisionada: aplicação de árvores para classificação e regressão18
Figura 9. Erro quadrático médio para 
diferentes proporções de amostragem.
O exemplo 11, por sua vez, utiliza o modelo de regressão em conjunto com 
o método de cross-validation. Destaca-se do método cross_val_score 
em relação ao exemplo 9 quanto ao parâmetro scoring, antes igual a ‘ac-
curacy’, agora, igual a ‘neg_mean_squared_error’.
# Exemplo 11 – CV - Erro Quadrático Médio (MSE, Mean Squared 
Error)
from sklearn.model _ selection import cross _ val _ score
Xc = np.sort(2*np.pi * np.random.rand(50, 1), axis=0)
yc = np.sin(Xc).ravel()
dfc = pa.DataFrame()
for d in range(2, 10, 1):
 modelc = DecisionTreeRegressor(max _ depth=d)
 s = 'MSE D=' + str(d)
 cross = cross _ val _ score(modelc, Xc, yc, cv=10, 
 scoring='neg _ mean _ squared _ error')*100
 cross = np.append(cross, sum(cross)/10)
 dfc[s] = cross
dfc
19Aprendizagem supervisionada: aplicação de árvores para classificação e regressão
Dessa vez, é testada a variação do parâmetro de profundidade máxima 
(max_depth), de 2 a 9, e se percebe uma estabilização do erro a partir de 
uma profundidade igual a 4, conforme a Figura 10. É preciso lembrar que a 
última linha (10) indica a média de todas as amostragens para uma mesma 
coluna de parametrização.
Figura 10. Erro quadrático médio para diferentes níveis de profundidade máxima da árvore.
Os classificadores e os regressores possuem muitas métricas disponíveis 
para a avaliação. Enquanto um classificador irá visar à avaliação de erro e 
acerto usando acurácia, índice de sensibilidade, especificidade, precisão e assim 
por diante, todos dependentes dos verdadeiros/falsos e positivos/negativos, um 
regressor irá utilizar medições contínuas, como erro quadrático, erro absoluto, 
desvio e assim por diante.
FACELI, K. et al. Inteligência artificial: uma abordagem de aprendizado de máquina. Rio 
de Janeiro: LTC, 2011.
SCIKIT-LEARN. Decision trees. c2019a. Disponível em: https://scikit-learn.org/stable/
modules/tree.html. Acesso em: 24 abr. 2020.
Aprendizagem supervisionada: aplicação de árvores para classificação e regressão20
SCIKIT-LEARN. sklearn.tree.DecisionTreeClassifier. c2019b. Disponível em: https://scikit-
-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html. Acesso 
em: 24 abr. 2020.
SCIKIT-LEARN. sklearn.tree.DecisionTreeRegressor. c2019c. Disponível em: https://scikit-
-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html. Acesso 
em: 24 abr. 2020.
Os links para sites da web fornecidos neste capítulo foram todos testados, e seu fun-
cionamento foi comprovado no momento da publicação do material. No entanto, a 
rede é extremamente dinâmica; suas páginas estão constantemente mudando de 
local e conteúdo. Assim, os editores declaram não ter qualquer responsabilidade 
sobre qualidade, precisão ou integralidade das informações referidas em tais links.
21Aprendizagem supervisionada: aplicação de árvores para classificação e regressão2011). Esse tipo de aprendizado configura uma instrução objetiva e difere 
de outras formas de retorno de caráter qualitativo quanto à assertividade do 
algoritmo. Assim, o valor fornecido como objetivo do treinamento só pode 
ser do mesmo tipo do valor de saída.
São exemplos recorrentes de aprendizado supervisionado: a classificação de 
caracteres manuscritos, utilizando imagens da letra, do número ou do símbolo 
escrito para determinar o símbolo digital equivalente; a previsão de preços 
de determinado bem a partir de um conjunto de características; o diagnóstico 
de doenças a partir de exames diversos; entre outros. A Figura 3 mostra um 
5Abordagens de aprendizagem de máquina e principais tarefas
conjunto de imagens já rotuladas de vários números manuscritos todos de 
mesmo tamanho. Essa base de dados é utilizada para pesquisa e desenvol-
vimento de algoritmos capazes de reconhecer a escrita humana, e o rótulo 
de cada caractere identifica um valor equivalente na tabela ASCII utilizada 
pelos computadores para representar números, letras e símbolos nesse padrão.
Figura 3. Conjunto de dados MNIST.
Fonte: Adaptada de Baldominos, Saez e Isasi (2019).
Ao se utilizar aprendizado de máquina, espera-se que, com o modelo 
adequado e treinamento suficiente, o algoritmo seja capaz de analisar cada 
pixel de uma imagem na entrada e classificá-la segundo o dígito que deveria 
representar. Trata-se de um exemplo clássico de aprendizado supervisionado, 
preditivo, cuja tarefa principal é a de classificação dos dados. O padrão de 
entrada é determinado pela quantidade fixa de pixels, e o rótulo fornecido junto 
de cada imagem a orienta quanto à exatidão de suas previsões. Um algoritmo 
de aprendizado de máquina pode ser muito elaborado. Para implementar uma 
tarefa de aprendizado sobre imagens, parte considerável do problema reside em 
determinar de que forma os arquivos de imagem devem ser analisados, quais 
valores ou grupos de valores devem ser observados e como estão relacionados.
Abordagens de aprendizagem de máquina e principais tarefas6
O exemplo do Quadro 2 é mais simples e vai direto ao ponto: cada uma das 
colunas representa um atributo (característica). No aprendizado supervisio-
nado, pelo menos uma dessas colunas deve fazer menção a um atributo-alvo, 
ou seja, a um rótulo ou classe que identifique aquela instância. Assim, cada 
linha representa uma instância com os respectivos valores para cada um dos 
seus atributos. Nesse caso, o quadro mostra uma parte das instâncias de um 
conjunto de dados que relaciona os preços de casas na Califórnia com os 
atributos de: renda mediana na região (MedInc); idade mediana das casas 
na região (HouseAge); número de salas (AvgRooms); número de quartos 
(AvgBedrms); habitantes na região (Population); taxa de ocupação média das 
casas na região (AveOccup); latitude e longitude.
Fonte: Adaptado de Scikit-Learn (c2019).
M
ed
In
c
H
ou
se
A
ge
A
ve
Ro
om
s
A
ve
Be
dr
m
s
Po
pu
la
ti
on
A
ve
O
cc
up
La
ti
tu
de
Lo
ng
it
ud
e
Pr
ic
e
0 8.3252 41.0 6.984127 1.023810 322.0 2.555556 37.88 –122.23 4.526
1 8.3014 21.0 6.238137 0.971880 2401.0 2.109842 37.86 –122.22 3.585
2 7.2574 52.0 8.288136 1.073446 496.0 2.802260 37.85 –122.24 3.521
3 5.6431 52.0 5.817352 1.073059 558.0 2.547945 37.85 –122.25 3.413
4 3.8462 52.0 6.281853 1.081081 565.0 2.181467 37.85 –122.25 3.422
Quadro 2. Amostra de preços de casas (atributo-alvo) na Califórnia e suas respectivas 
características (atributos previsores)
Formalmente, o aprendizado supervisionado é definido segundo as três 
equações a seguir.
y = f(x)
onde:
 � y: atributo de saída
 � x: atributo de entrada
 � f: função que relaciona as entradas (x) com as saídas (y)
7Abordagens de aprendizagem de máquina e principais tarefas
D = {(xi, yi), i = 1, …, n}
onde:
 � D: conjunto de pares de entrada (xi) e saída (yi)
 � i: i-ésimo objeto do conjunto
 � n: quantidade total de objetos do conjunto
h = argmaxhϵℋP(h|D)
onde:
 � h: hipótese mais provável
 � ℋ: conjunto de hipóteses
 � P: função de probabilidade
A terceira equação determina que o aprendizado supervisionado ocorre 
quando a hipótese selecionada (h) dentro do conjunto de hipóteses (ℋ) é o 
parâmetro que maximiza (argmax) a função de probabilidade que relaciona 
cada hipótese ao conjunto de dados de entrada e saída (D) (RUSSEL; NORVIG, 
2013). Cabe ressaltar que os dados presentes em x e y não são necessariamente 
de tipo numérico, podendo ser de tipo simbólico. Ao final, espera-se que a 
função h seja tão próxima quanto possível da função f(x) da primeira equação.
O algoritmo só é capaz de generalizar (quando h ≅ f ) se o conjunto de 
hipóteses conter a hipótese (h) esperada e se os atributos de entrada seleciona-
dos possuírem características relevantes para o problema. Para tanto, pode-se 
imaginar que, quanto maior o conjunto de hipóteses e de atributos, melhor 
será a resolução. Contudo, à medida que eles aumentam, é possível que supe-
radaptações ocorram, situação em que o algoritmo acredita erroneamente que 
determinada característica tem relevância para um dado conjunto de entradas. 
Esse problema pode ser contornado aumentando a quantidade de exemplos 
ou encontrando um ponto de equilíbrio para cada um desses parâmetros, já 
que ampliar os conjuntos de dados, hipóteses e atributos levará sempre a um 
custo de processamento maior (RUSSEL; NORVIG, 2013).
Abordagens de aprendizagem de máquina e principais tarefas8
Aprendizado não supervisionado
Comum em tarefas descritivas, o aprendizado é considerado não supervisio-
nado quando a máquina deve aprender sobre a estrutura intrínseca dos dados, 
identificando similaridades ou dissimilaridades que permitam separar as 
instâncias em diferentes grupos (FACELI et al., 2011). Analogamente, pode-se 
pensar em diversas situações corriqueiras em que recorremos ao aprendizado 
não supervisionado, por exemplo, quando buscamos um padrão por meio da 
simples observação de algum evento. Esse é o caso, por exemplo, em que 
uma pessoa tenta compreender os elementos que compõem um novo jogo 
enquanto apenas o assiste pela primeira vez, mesmo que ninguém a esteja 
orientando sobre isso.
Após algum esforço e mesmo sem acompanhamento ou orientação, uma criança é 
capaz de reconhecer os elementos que fazem parte de um jogo de uma modalidade 
qualquer: jogadores, equipes, estrutura do ambiente, diferentes classes de acessórios, 
equipamentos e assim por diante — basta assistir a alguns eventos. Uma vez que ela 
tenha observado diversas partidas de esportes com bola, por exemplo, é provável 
que já saiba diferenciar com facilidade uma bola de outro objeto esférico qualquer, 
ou de outros objetos com outros formatos. Por meio de agrupamentos e associa-
ções, ela também é capaz de reconhecer indivíduos uniformizados, pertencentes ao 
mesmo grupo ou equipe. O mesmo ocorre com a máquina que se utiliza desse tipo de 
aprendizado, buscando por características similares entre cada instância presente no 
conjunto de dados que permitam agrupar ou separar essas instâncias umas das outras.
Contudo, é importante destacar que não se pode esperar do indivíduo que 
tenha reconhecido diferentes agrupamentos de objetos — apenas pela contínua 
observação — que saiba nomear ou, em outras palavras, rotular cada um dos 
objetos. Seria necessário que um observador o orientasse quanto aos rótulos 
que devem ou podem ser atribuídos às estruturas que ele identificou, o que já 
extrapola as atribuições do aprendizado não supervisionado.
9Abordagens de aprendizagem de máquina e principais tarefas
Enquanto no aprendizado supervisionado são conhecidos os rótulos corre-
tos, no aprendizado não supervisionado, a máquina poderá encontrar diferentes 
estruturas para um mesmo conjunto de dados conforme a variação dos parâ-
metros do algoritmo. Os grupos podem ou não ter algum significado válido, 
mas somente o observador poderá determinar isso, visto que o simples fato de 
encontrar alguma similaridade entre instânciasnão garante que as estruturas 
formadas possam ser aproveitadas para a analisar ou melhor compreender os 
dados. O aprendizado não supervisionado acarreta uma série de dificuldades 
adicionais se comparado ao aprendizado supervisionado. Entretanto, existem 
situações em que esse tipo de abordagem é a mais adequada ou a única possível 
de se resolver o problema. 
Um radiotelescópio pode ser programado para buscar determinados padrões 
em uma imagem a fim de detectar novos planetas, estrelas, cometas e outros 
objetos. Mesmo assim, é evidente que a imensidão do universo é demais para 
que se ouse pensar que qualquer pesquisa deva se restringir ao mundo que 
já se tem conhecimento atualmente. Logo, seria interessante que, paralelo 
às pesquisas convencionais, outros algoritmos objetivassem a busca não por 
padrões já conhecidos, mas por relações ainda não imaginadas pela comunidade 
científica, o que demandaria a flexibilidade que somente o aprendizado não 
supervisionado é capaz de fornecer.
Outras situações comuns envolvem aplicações de gestão e marketing 
empresarial, em que um algoritmo tem por finalidade encontrar produtos que 
estão frequentemente associados a uma base de dados de vendas, permitindo 
ao gestor determinar campanhas de publicidade mais eficientes, melhorar o 
mix de produtos e alterar o seu posicionamento nas prateleiras na tentativa de 
maximizar as vendas.
A Figura 4 mostra vários indivíduos de cores diferentes posteriormente 
agrupados com base nessa característica. No entanto, apesar de ser possível 
compreender a estrutura identificada, não quer dizer que esse tipo de agrupa-
mento tenha algum significado relevante. Pode ser que os indivíduos tivessem 
outras características mais significativas segundo as quais formariam outras 
estruturas, como altura, peso e até mesmo o gênero, conforme pode ser visto 
na imagem.
Abordagens de aprendizagem de máquina e principais tarefas10
Figura 4. Agrupamento de indivíduos com base no atributo cor.
Fonte: Orn Rin/Shutterstock.com.
É possível que a quantidade de amostras fosse insuficiente para o modelo 
identificar outras estruturas. Os parâmetros utilizados também podem in-
fluenciar os resultados, por exemplo, se o algoritmo utilizado for orientado a 
buscar por um agrupamento que resulte em três clusters. Havendo, coinciden-
temente, três cores diferentes e uma distribuição igualitária de amostras para 
essa característica, são grandes as chances de que, sem considerar os demais 
atributos, este seja favorecido no processo de treinamento. Caso o algoritmo 
fosse parametrizado para identificar dois grupos, as chances de a estrutura 
encontrada dividir os indivíduos entre homens e mulheres aumentam. Muitas 
são as aplicações desse tipo de aprendizado, e as tarefas de agrupamento e 
associação são as mais comuns
Aprendizado semissupervisionado
Nem sempre haverá uma classificação rígida dos métodos de aprendizado e 
treinamento adotados, e casos híbridos são muito utilizados. É o caso, por 
exemplo, dos métodos de aprendizado semissupervisionados. Esse tipo de 
11Abordagens de aprendizagem de máquina e principais tarefas
aprendizado tem por objetivo efetuar tarefas de classificação, porém, partindo 
de dados não completamente rotulados (WITTEN; FRANK, 2005).
A grande vantagem em utilizar ambas as abordagens em conjunto é o 
ganho em quantidade de dados disponíveis para o aprendizado. A técnica 
de aprendizado supervisionado depende dos dados previamente rotulados, o 
que envolve custos, já que alguém deverá filtrar e preparar esses dados para 
que possam ser utilizados. Ocorre que a quantidade de dados não rotulados 
existentes é muito maior, o que poderá impactar de forma positiva na qualidade 
do treinamento, caso seja possível utilizá-los em conjunto com os demais.
O processo pode ser dividido em quatro etapas. Primeiramente, deve-se 
treinar de maneira supervisionada a partir do conjunto de entradas que já 
possuem rótulo. Na sequência, o classificador deverá ser aplicado sobre o 
conjunto de dados que não possuem rótulos. Feito isso, a máquina precisa 
ser novamente treinada, agora utilizando todo o conjunto de dados. Por fim, 
a iteração deve ser repetida até que se possa obter um resultado satisfatório.
As etapas dois e três — de classificação dos dados não rotulados e de trei-
namento do conjunto completamente rotulado — podem recorrer a algoritmos 
como o de maximização de expectativa. Trata-se de um algoritmo iterativo 
de elevado grau de precisão para inferência bayesiana. É possível utilizar 
tanto as técnicas de MLE (maximum likelihood estimation, ou inferência por 
maximização de verossimilhança, em português) como de MAP (maximum a 
posteriori probability, ou probabilidade posterior máxima, em português). Em 
ambos os casos, pretende-se obter os parâmetros que minimizam as incertezas 
de se classificar um objeto em uma classe específica.
De forma resumida, espera-se que o algoritmo busque, por meio de fer-
ramentas estatísticas, características presentes nos objetos rotulados que 
aparecem também nos objetos não rotulados e que permitam associar um 
ao outro assumindo as mesmas classes. Assim, a característica em comum 
pode não ser a mesma utilizada para classificar os objetos já rotulados, mas 
serve de ponte para que o segundo obtenha a mesma classificação (WITTEN; 
FRANK, 2015).
Um exemplo bastante didático é o desenvolvimento de um algoritmo para 
prever a idade de um indivíduo com base em fotografias. Os rótulos são 
fornecidos pelos próprios indivíduos junto à sua imagem. No entanto, nem 
todos informam a sua idade, e outros podem eventualmente mentir a respeito 
dela. Em ambas as situações, faz-se necessária a aplicação de técnicas de 
aprendizado não supervisionado em conjunto com o supervisionado, tanto 
para estimar e reduzir a quantidade de erros pelos dados falsos fornecidos 
quanto pela falta de dados daqueles que nem mesmo informaram a sua idade.
Abordagens de aprendizagem de máquina e principais tarefas12
No exemplo anterior, a máquina buscará por características nas imagens 
que tenham relação direta com a idade, como sinais na pele (rugas). Utilizando 
os dados rotulados, a máquina pode aproximar as regras que levam de deter-
minadas características para a previsão da idade em si e, a partir do algoritmo 
não supervisionado, estimar, primeiramente, os erros de rotulação que podem 
existir, para só então tentar rotular as demais já com o algoritmo corrigido.
Aprendizado por reforço
O aprendizado por reforço, como o próprio nome sugere, visa reforçar ou 
atenuar parâmetros do modelo a partir dos resultados obtidos, conforme 
recompensas ou punições são dadas a cada tentativa. Pode-se imaginar esse 
tipo de aprendizado como uma espécie de adestramento, em que o que se está 
treinando (ou adestrando), apesar de ser incapaz de avaliar rótulos, pode ser 
instruído quanto à qualidade das decisões ou previsões tomadas por meio de 
recompensas e punições (RUSSEL; NORVIG, 2013).
A Figura 5 mostra a interação entre o agente (máquina) e o ambiente 
nesse tipo de aprendizado. A partir de uma situação ou estado atual (dados), o 
agente realiza uma ação com base no aprendizado acumulado até o momento, 
alterando o estado. O resultado dessa ação fará com que o ambiente retorne 
para o agente uma recompensa ou punição. Esse reforço servirá de guia para 
que o agente possa melhorar o seu desempenho.
Figura 5. Ciclo de aprendizado por reforço.
13Abordagens de aprendizagem de máquina e principais tarefas
Trata-se de um tipo de aprendizado mais abrangente, assim como o apren-
dizado não supervisionado, o que não acarreta necessariamente um melhor 
desempenho, uma vez que cada tipo de aprendizado tem suas vantagens e 
desvantagens. Mesmo assim, o algoritmo não está limitado a dados de en-
trada já avaliados por outro indivíduo, e compreender se as decisões tomadas 
resultaram em falha ou sucesso é suficiente para o algoritmo. Então, caberá 
ao algoritmo, utilizando ferramentas de probabilidadee recursos próprios do 
aprendizado de máquina, encontrar as decisões ou os parâmetros que foram 
mais relevantes para os casos repetidos de sucesso.
Imagine, por exemplo, um robô aspirador de pó que possui sensores de colisão e GPS 
para guiá-lo através do ambiente que se pretende limpar. Enquanto o GPS fornece 
as coordenadas atuais e permite que o robô armazene o caminho já percorrido, os 
sensores de colisão detectam a necessidade de mudança de percurso. Sem qualquer 
outro meio de sensoriamento, o robô só saberá que concluiu a limpeza do ambiente 
quando tiver encontrado todos os caminhos possíveis.
Para que o robô aspirador melhore a sua performance, serão necessárias várias 
repetições de um processo completo de limpeza, tentando encontrar rotas que o 
permitam concluir em menor tempo o percurso completo. Dessa forma, o tempo de 
conclusão da tarefa em conjunto com a quantidade de colisões funcionarão como 
mecanismos de reforço, permitindo que a máquina compreenda se as hipóteses 
adotadas na última iteração são melhores ou piores que as anteriores.
Esse também é um método de aprendizado muito utilizado pelos seres 
humanos. Ao contrário do exemplo citado no aprendizado não supervisionado, 
em que um indivíduo aprenderia as regras de um esporte a partir da observa-
ção de vários jogos, o aprendizado por reforço poderia representar o método 
utilizado pelo indivíduo para aprender as técnicas corretas de movimento para 
determinada modalidade que o levarão a resultados mais satisfatórios. À medida 
que os seus movimentos se tornem mais precisos, o resultado, provavelmente, 
será mais positivo, reforçando o que foi aprendido.
Abordagens de aprendizagem de máquina e principais tarefas14
Outra situação em que o aprendizado por reforço é o mais adequado ocorre 
quando as hipóteses para cada novo movimento ou etapa de um processo 
são muitas, como em um jogo de xadrez. A máquina precisa saber qual é a 
movimentação mais recomendada a cada jogada. No entanto, dificilmente 
disporá de orientações diretas para cada uma das combinações e, tanto para a 
máquina quanto para um jogador real, é comum tomar decisões com o intuito 
de atingir um objetivo muito mais distante. O resultado obtido pela execução 
da estratégia servirá como mecanismo de recompensa ou punição (RUSSEL; 
NORVIG, 2013).
No caso do xadrez, a recompensa é obtida sempre que, por algum motivo, 
um xeque-mate tenha ocorrido a seu favor, assim como a punição é obtida 
caso tenha ocorrido em favor do adversário. Alvos menores também podem 
ser determinados, até mesmo fracionando o algoritmo em partes menores, 
em que recompensas seriam ativadas conforme a quantidade de peças do 
adversário diminui ou, ainda, quando um xeque é aplicado. Quaisquer que 
sejam os gatilhos pretendidos de recompensa ou punição, eles deverão ser 
explicitamente determinados no algoritmo para que seja possível diferenciar 
essa entrada específica de todas as demais.
Em resumo, o aprendizado por reforço pode iniciar de maneira aleatória 
e concluir no momento em que se tornar capaz de tomar as decisões corretas 
para que atinja sempre a recompensa e não a punição. Quanto melhor for a 
capacidade de exploração do algoritmo, mais bem-sucedido ele será. 
BALDOMINOS, A.; SAEZ, Y.; ISASI, P. A survey of handwritten recognition with MNIST 
and EMNIST. Applied Sciences, v. 9, n. 3169, p. 1–16, 2019. Disponível em: https://www.
mdpi.com/2076-3417/9/15/3169/pdf. Acesso em: 14 fev. 2020.
FACELI, K. et al. Inteligência artificial: uma abordagem de aprendizado de máquina. Rio 
de Janeiro: LTC, 2011.
RUSSEL, S. J.; NORVIG, P. Inteligência artificial. 3. ed. Rio de Janeiro: LTC, 2013.
SCIKIT-LEARN. California housing dataset. c2019. Disponível em: https://scikit-learn.org/
stable/modules/generated/sklearn.datasets.fetch_california_housing.html#sklearn.
datasets.fetch_california_housing. Acesso em: 14 fev. 2020.
WITTEN, I. H.; FRANK, E. Data mining: practical machine learning tools and techniques. 
San Francisco, CA: Morgan Kaufmann Publishers, 2005. 
15Abordagens de aprendizagem de máquina e principais tarefas
Os links para sites da web fornecidos neste capítulo foram todos testados, e seu fun-
cionamento foi comprovado no momento da publicação do material. No entanto, a 
rede é extremamente dinâmica; suas páginas estão constantemente mudando de 
local e conteúdo. Assim, os editores declaram não ter qualquer responsabilidade 
sobre qualidade, precisão ou integralidade das informações referidas em tais links.
Abordagens de aprendizagem de máquina e principais tarefas16
FUNDAMENTOS DE 
APRENDIZAGEM 
DE MÁQUINA
Maikon Lucian Lenz
Aprendizagem não 
supervisionada: 
agrupamento
Objetivos de aprendizagem
Ao final deste texto, você deve apresentar os seguintes aprendizados:
 � Definir uma tarefa de agrupamento (clustering).
 � Descrever os passos do algoritmo k-means.
 � Determinar critérios para a avaliação de clusters.
Introdução
O agrupamento é uma das tarefas mais comuns que compõem o apren-
dizado não supervisionado. Os grupos formados também são conheci-
dos como clusters e dependem muito das características do algoritmo 
utilizado.
Neste capítulo, além dos conceitos que envolvem tarefas de agru-
pamento, você conhecerá o algoritmo de K-Médias e os critérios de 
avaliação mais utilizados para determinar se os grupos condizem com 
os dados analisados.
1 Agrupamento
Nem sempre será possível contar com dados já classificados para proceder com 
o treinamento, descartando a possibilidade de se utilizar tarefas de aprendizado 
supervisionado. Os dados obtidos podem ser ainda mais restritos, contendo 
apenas os atributos previsores (de entrada) e nenhuma informação, nem mesmo 
de recompensa ou punição, situação em que até mesmo tarefas de aprendizado 
por reforço estão descartadas. Para situações como essa, podem ser utilizadas 
tarefas de aprendizado não supervisionado. Esse tipo de aprendizado não requer 
informações acerca dos atributos alvo. Pelo contrário, os algoritmos desse 
tipo de aprendizado buscam por características relevantes de um conjunto de 
dados que permitam separá-los uns dos outros.
O agrupamento, também conhecido como clusterização (do inglês, cluste-
ring), enquadra-se no aprendizado não supervisionado e consiste na divisão 
dos dados em grupos (em inglês, denominado como clusters) de características 
similares, ou seja, que compartilham valores próximos entre os atributos de 
entrada. A forma como esses grupos são divididos varia de acordo com a tarefa 
utilizada. A Figura 1 demonstra duas formas diferentes de se agrupar os dados. 
O eixo X representa um atributo, e o eixo Y, outro, enquanto dados que possuem 
valores próximos entre esses atributos são inseridos no mesmo grupo. Deve-se 
observar, entretanto, que o algoritmo utilizado afeta diretamente os grupos 
aprendidos, já que as instâncias pertencentes a determinado grupo na Figura 
1a não são em todos os casos as mesmas instâncias agrupadas na Figura 1b.
Figura 1. Agrupamento (a) hierárquico e (b) particional, com grupos que não se sobrepõem.
Fonte: Maikon Lucian Lenz/Shutterstock.com.
(a) (b)
Aprendizagem não supervisionada: agrupamento2
Enquanto os algoritmos particionais agrupam as instâncias dentro de 
um cluster de forma exclusiva, os algoritmos hierárquicos podem aninhar 
clusters criando uma hierarquia em que uma mesma instância pertence a dois 
ou mais clusters ao mesmo tempo, o que é facilmente distinguível em ambos 
os métodos comparados pela Figura 1. Existem tipos de dados em que essa 
relação (hierárquica) é bastante comum, como em modelos biológicos nos 
quais a estrutura dos membros, de modo geral, possui algum tipo de hierarquia 
(FACELI et al., 2011). O agrupamento pode ser definido como a busca por 
uma estrutura de clusters (grupos) nos quais as suas instâncias compartilham 
características similares relevantes para a análise dos dados. 
É importante destacar que o resultado do agrupamento não carrega definição sobre 
os grupos formados, ouseja, apesar de os dados serem divididos como em uma 
tarefa de classificação, no agrupamento, não há rótulo definido para eles. No entanto, 
sabe-se que, qualquer que seja o rótulo passível de ser atribuído ao grupo, os dados 
pertencentes a ele têm características similares, como em uma tarefa de classificação. 
Apesar disso, tarefas de agrupamento são muito úteis justamente para analisar dados 
que ainda não têm sua estrutura conhecida, ou ainda, na tentativa de buscar por novos 
padrões e características relevantes em uma estrutura.
Uma vez agrupados, os clusters formados podem ser analisados por um 
observador que poderá rotulá-los conforme suas características em comum. 
Isso torna a tarefa de agrupamento uma técnica recorrente na análise de 
dados que deverão ser classificados no futuro a partir das categorias a serem 
descobertas por ela. Também é possível que a tarefa de agrupamento encontre 
objetos intrusos, ou outliers, em inglês. Os outliers correspondem a instâncias 
no conjunto de dados que não são possíveis de inserir em nenhum grupo, pois 
possuem características muito diferentes de todos eles.
Os grupos, ou clusters, podem se apresentar de diversas formas, segundo 
o tipo de algoritmo e o objetivo pretendido no agrupamento (FACELI et al., 
2011). Cluster bem separado (Figura 2a) diz respeito ao grupo cujas instâncias 
estão, em todos os casos, mais próximas dos membros desse mesmo grupo 
do que de outras instâncias de outros grupos. Há uma divisão nítida entre os 
3Aprendizagem não supervisionada: agrupamento
grupos. Cluster com base em centro (Figura 2b) adota o centro do grupo como 
referência. Assim, as instâncias que pertencem a ele são definidas segundo 
a distância desse ponto central, e não dos demais membros em si como na 
situação anterior (FACELI et al., 2011). Nesse caso, podem existir instâncias, 
especialmente, nas bordas do grupo, próximas das instâncias de outro grupo.
O cluster contínuo é similar ao cluster bem separado, exceto que, para o 
caso contínuo, o vizinho mais próximo serve de referência (Figura 2c). Assim, 
apesar de, na média de todos os membros do grupo, um ponto poder ser mais 
perto de outro grupo, apenas o ponto mais próximo é considerado para definir 
a que grupo pertence. O cluster com base em densidade (Figura 2d) divide os 
grupos segundo níveis de densidade. Logo, o que separa um grupo de outro 
são as transições de baixa densidade entre eles, ou seja, regiões em que há 
pouca quantidade de dados, e cada grupo configura um aglomerado de grande 
quantidade de dados bem distribuídos dentro dele. Há ainda a definição de 
cluster por similaridade (Figura 2e), em que o critério de agrupamento adota 
a presença ou não de similaridades entre os membros (FACELI et al., 2011).
Figura 2. (a) Cluster bem separado; (b) com base no centro; (c) cluster contínuo; (d) com 
base em densidade e (e) cluster por similaridade.
Fonte: Maikon Lucian Lenz/Shutterstock.com. 
Aprendizagem não supervisionada: agrupamento4
Três critérios podem ser utilizados para avaliar o agrupamento: compacta-
ção, encadeamento ou separação espacial. A compactação visa à associação 
de objetos com pequena variação dentro do mesmo cluster mais eficientes 
na detecção de grupos esféricos. O encadeamento lida com o conceito de 
vizinhança, em que objetos próximos devem pertencer ao mesmo grupo, além 
de ter bons resultados em grupos bem separados. Já a separação espacial é 
mais genérica e considera apenas a distância entre os clusters (FACELI et al., 
2011). Qualquer que seja o critério de agrupamento, espera-se que esse tipo de 
aprendizado não supervisionado separe os dados em grupos com características 
similares entre si para que possam ser futuramente utilizadas para análises 
ou tarefas de classificação.
2 Algoritmo K-Médias
O algoritmo de K-Médias utiliza o critério de compactação e naturalmente 
apresenta resultados bastante satisfatórios para grupos de formato esférico 
(FACELI et al., 2011).
Assim como outros algoritmos, o K-Médias define cada grupo segundo 
um objeto representativo através de medidas de centroide (ponto médio do 
cluster) da Equação 1 ou de medoide (ponto mais representativo do cluster, 
corresponde, em geral, ao ponto de menor distância para os demais membros, 
conforme a Equação 2). Enquanto o centroide é apenas um ponto de referência, 
podendo estar associado à mesma posição de um objeto do cluster ou não, o 
medoide é a escolha de um dos membros do cluster para servir de referência. 
(1)
onde:
j: índice do cluster
: centroide do j-ésimo cluster
nj: número de instâncias no cluster
Cj: j-ésimo cluster
xi: i-ésima instância
5Aprendizagem não supervisionada: agrupamento
(2)
onde:
xm: m-ésima instância do cluster
d: função de distância
O K-Médias é um algoritmo do tipo particional que busca reduzir o erro 
quadrático médio dos agrupamentos de forma iterativa. Adotando-se E como 
sendo o erro, é função do K-médias encontrar o agrupamento que minimiza 
o erro (E) de acordo com a Equação 3 (FACELI et al., 2011):
(3)
onde:
E: erro quadrático médio
k: quantidade de clusters
A Equação 3 determina a quantidade de clusters pretendidos a partir do 
valor de k. O algoritmo deve então buscar um valor que minimize o erro dada 
uma função de distância d que pode ser a simples diferença entre a instância 
xi e o centroide . Encontrar o valor ideal de k é um dos grandes desafios 
desse tipo de abordagem, uma vez que o conjunto de dados pode apresentar 
diferentes estruturas e quantidades variadas dessas estruturas, dependendo 
da forma que se está buscando.
O valor de k é livre para ser determinado pelo usuário. Esse valor afetará 
diretamente o processo de aprendizado, uma vez determinada a quantidade de 
clusters que devem ser formados. A definição desse número pode ter base em 
conhecimentos prévios do usuário que, apesar de não possuir dados rotulados, 
sabe quais as categorias que se pretende obter. Em outros casos, o k pode ser 
simplesmente resultado de testes com diferentes parâmetros para, só após os 
resultados de agrupamento, concluir a quantidade mais adequada de clusters 
que devem ser formados para o problema pretendido.
Aprendizagem não supervisionada: agrupamento6
A seguir, o algoritmo, em pseudocódigo, apresenta o conceito básico do 
algoritmo de K-Médias. Deve-se ressaltar, no entanto, que muitas variações 
desse algoritmo já foram criadas, cada uma com vantagens em aplicações 
específicas.
Iniciar os valores de centroides dos k clusters 
Enquanto houver alterações no centroide, repetir:
Iterar conjunto de dados fazendo para cada instância:
Calcular a função de distância entre a instância e o centroide dos clusters.
Vincular a instância ao cluster mais próximo.
Fim da iteração
Iterar cada conjunto de dados fazendo para cada cluster:
Calcular o novo centroide
Fim da iteração
Fim da repetição
A inicialização dos valores de centroide pode ser feita de maneira aleató-
ria. Os dados são vinculados ao centroide mais próximo, que é recalculado. 
O processo se repete até que nenhuma instância mude de grupo, mantendo 
o centroide constante. Conhecendo o algoritmo é fácil compreender o nome 
K-Médias adotado, em que o termo k faz menção ao parâmetro que especifica 
a quantidade de clusters buscados, enquanto médias se refere ao critério de 
distância adotado: média quadrática (WITTEN; FRANK, 2005).
Assim como para outros algoritmos de agrupamento, o algoritmo de 
K-Médias dificilmente resultará em um mínimo global (solução ideal). Nesse 
caso, a limitação decorre da influência que o valor inicial dos centroides, em 
geral, escolhidos de maneira aleatória, tem sobre os clusters formados. Grupos 
diferentes podem ser formados apenas alterando os valores iniciais de centroide.
Inexistem algoritmos capazes de detectar todos os tipos de estruturas pre-
sentes em um conjunto de dados. O algoritmo será mais ou menos eficiente a de-
pender da forma como os dados estão distribuídos. Por exemplo, é provável que 
o K-Médias não seja capazde detectar o grupo em forma de anel da Figura 3, 
apenas os grupos em formas esféricas (FACELI et al., 2011).
7Aprendizagem não supervisionada: agrupamento
Figura 3. Grupos detectados pelo K-Médias.
Fonte: Maikon Lucian Lenz/Shutterstock.com.
Por conta dessas restrições, é importante que sejam feitas avaliações dos 
grupos formados para que os parâmetros do algoritmo possam ser refinados, 
substituídos por outro modelo de agrupamento ou até mesmo complementados 
com outros. O simples fato de encontrar e sugerir grupos para os dados em 
questão não quer dizer que o agrupamento está sendo efetivo.
3 Avaliação de grupos
Os grupos formados pelo algoritmo de K-Médias podem variar em quanti-
dade e em relação a quais instâncias pertencem ao mesmo grupo. Diferentes 
parâmetros resultarão em diferentes níveis de dispersão, tanto entre os grupos 
(intercluster) quanto entre as instâncias (intracluster). Esses conceitos são 
apresentados na Figura 4.
Aprendizagem não supervisionada: agrupamento8
Figura 4. Tipos de dispersão: intercluster e 
intracluster.
Fonte: Maikon Lucian Lenz/Shutterstock.com.
A distância entre dois clusters corresponde à menor distância entre duas 
instâncias pertencentes a cada um deles e pode ser calculada por meio da 
Equação 4:
d(Ca,Cb) = min d(xai,xbj) (4)
onde:
Ca,Cb: clusters diferentes
xai: i-ésima instância do cluster Ca
xbj: j-ésima instância do cluster Cb
O problema em se determinar a quantidade de grupos pode ser simplificado 
medindo o quanto a inclusão de um novo grupo contribui para reduzir as 
dispersões intercluster e intracluster. Para tanto, deve-se repetir o algoritmo 
de K-Médias e selecionar o valor de k a partir do qual a redução na dispersão 
pouco é afetada. Esse método é conhecido como método de Elbow, ou cotovelo, 
já que representa a mudança drástica de sentido no gráfico que relaciona o 
parâmetro k à dispersão entre os grupos (intercluster) ou entre as instâncias 
de um mesmo grupo (intracluster), conforme é possível ver na Figura 5.
9Aprendizagem não supervisionada: agrupamento
Figura 5. Método Elbow de seleção do parâmetro k.
Fonte: Adaptada de Maikon Lucian Lenz/Shutterstock.com.
M
ét
ric
a
Parâmetro k
A variância é comumente utilizada como função para medir a dispersão in-
tracluster, além de mensurar o quão compacto um cluster pode ser (Equação 5):
(5)
onde:
nx: quantidade total de instâncias
A conectividade mede o quanto instâncias de maior proximidade, ditas 
vizinhas, pertencem ao mesmo grupo (Equação 6):
(6)
onde:
nv: quantidade total de instâncias vizinhas à instância xi
vij: j-ésima instância vizinha à instância xi
Aprendizagem não supervisionada: agrupamento10
Por fim, a silhueta é uma métrica que avalia o quanto uma instância está 
adequadamente vinculada a um cluster. Os valores de silhueta variam de –1, 
quando um objeto deveria estar vinculado a outro cluster, até 1, quando um 
objeto está associado ao cluster ideal (FACELI et al., 2011). A medida de 
silhueta utiliza os valores de distância média de uma instância para os seus 
parceiros de cluster (Equação 7) e a menor distância deste para os demais clus-
ters (Equação 8) para avaliar tanto as instâncias individualmente (Equação 8) 
quanto a totalidade dos clusters em si (Equação 9) (FACELI et al., 2011).
(7)
(8)
(9)
(10)
onde:
n: quantidade de instâncias do cluster
11Aprendizagem não supervisionada: agrupamento
Os critérios de avaliação citados lidam com abordagens de aprendizado não 
supervisionada, portanto, não buscam por soluções corretas, mas por soluções 
que encontrem estruturas apropriadas e que possam revelar outras ocultas. 
Isso porque um mesmo conjunto de dados pode ter diferentes soluções em 
uma mesma quantidade de grupos, utilizando atributos e critérios diferentes 
de agrupamento. Nem por isso, algum deles estará errado. Em outras pala-
vras, a avaliação tem por objetivo determinar se a estrutura encontrada de 
fato existe e se faz sentido (FACELI et al., 2011). A Figura 6 apresenta duas 
soluções de K-Médias para o mesmo conjunto de dados utilizando diferentes 
parâmetros de k.
Figura 6. (a) Dois clusters (k = 2). (b) Quatro clusters (k = 4).
Fonte: Maikon Lucian Lenz/Shutterstock.com.
O baixo custo computacional, geralmente associado ao algoritmo de 
K-Médias, é um dos fatores que o tornam tão utilizado, entretanto, a dificul-
dade em se encontrar a quantidade de clusters mais adequada e inicializar 
os centroides de cada cluster demandam o uso de rotinas de validação que 
recorrem a medidas de distância e dispersão intercluster e intracluster. Esse 
tipo de algoritmo responde melhor para grupos de formato esférico sem so-
breposição entre eles (JAMES, et al., 2013).
Aprendizagem não supervisionada: agrupamento12
FACELI, K. et al. Inteligência artificial: uma abordagem de aprendizado de máquina. Rio 
de Janeiro: LTC, 2011.
JAMES, G. et al. An introduction to statistical learning: with application in R. New York: 
Springer, 2013.
WITTEN, I. H.; FRANK, E. Data mining: practical machine learning tools and techniques. 
2nd ed. Boston: Morgan Kaufmann, 2005.
Leituras recomendadas
NILSSON, N. J.  Artificial intelligence: a new synthesis.  San Francisco: Morgan Kaufmann, 
1998.
RUSSELL, S. J.; NORVIG, P. Inteligência artificial. 2. ed. Rio de Janeiro: Campus, 2004.
13Aprendizagem não supervisionada: agrupamento
FUNDAMENTOS 
DE APRENDIZAGEM 
DE MÁQUINA 
Maikon Lucian Lenz
Aprendizagem não 
supervisionada: 
aplicação do k-means
Objetivos de aprendizagem
Ao final deste texto, você deve apresentar os seguintes aprendizados:
 � Processar um conjunto de dados para a tarefa de agrupamento 
(clustering).
 � Empregar o algoritmo k-means para uma tarefa de agrupamento.
 � Aplicar métricas para avaliar uma formação dos clusters.
Introdução
A aplicação de algoritmo de agrupamento depende de uma seleção 
adequada dos dados, e inúmeras ferramentas foram desenvolvidas para 
facilitar a implementação desses dados, com destaque para a biblioteca 
SciKit-Learn para Python. A biblioteca inclui métodos e classes configurá-
veis para todas as abordagens de aprendizado. O algoritmo de k-means 
permite a configuração de diversos parâmetros que influenciarão não 
apenas os clusters encontrados, mas também a velocidade com que os 
dados são processados e a quantidade de memória necessária.
Neste capítulo, você verá como dados podem ser carregados para 
variáveis com o auxílio das bibliotecas de SciKit-Learn, organizados e 
manipulados a partir de bibliotecas como Pandas e Seaborn. Também 
serão treinados diferentes conjuntos de dados utilizando o algoritmo de 
k-means, incluso nessas bibliotecas, e as métricas disponíveis para avaliar 
a eficiência dos agrupamentos realizados.
1 Ferramentas e dados
Existem muitas linguagens de programação e ferramentas adequadas para todo 
o tipo de aplicação. Você pode optar pela linguagem de sua preferência para 
desenvolver sistemas que abordem algum tipo de aprendizado de máquina. 
No entanto, a linguagem Python é uma das primeiras opções entre os desenvol-
vedores e pesquisadores quando o assunto é análise e processamento de dados.
Devido à sintaxe simplificada e de fácil aprendizado, o Python conquistou 
espaço significativo em trabalhos acadêmicos, a maioria deles sobre análise 
de dados. Assim, surgiram muitas bibliotecas e ferramentas associadas ao 
Python que permitiram a manipulação cada vez mais facilitada de dados.
Em aprendizado de máquina, uma das bibliotecas mais importantes, espe-
cialmente para aqueles que estão iniciando na área, é a SciKit-Learn, totalmente 
voltada para problemas de aprendizado de máquina. Ela conta com ferramentas 
de pré-processamento de dados, interpretação de arquivos, criação de gráficos 
e outras formas de exibição das informações.
Também estão inclusos na biblioteca SciKit-Learn conjuntos de dados úteis 
para todos os tipos de abordagens de aprendizado de máquina, com destaque 
para: o conjunto íris, com 150 amostras de três espécies deflores do gênero íris 
em que, para cada uma, são atribuídos o comprimento e a largura de pétalas 
e sépalas, além da espécie em si, utilizado para modelos de classificação; 
e o conjunto Boston house-prices (preço de casas em Boston), utilizado para 
modelos de regressão, com 506 amostras de casas acompanhadas do atributo 
alvo preço e de 13 atributos previsores que incluem a taxa de criminalidade 
per capita da região, o número de quartos, entre outros.
Outras bibliotecas bastante úteis na análise de dados são: Numpy, com 
recursos que facilitam o cálculo e a manipulação de vetores, além de servir 
de base para o SciKit-Learn; Pandas, para criar estruturas de dados de fácil 
visualização e integração; Matplotlib e uma extensão chamada Seaborn, ambas 
para criação de gráficos.
Com todos esses recursos, você será capaz de: carregar dados de diferentes 
fontes, arquivos, páginas da web e conjuntos de dados embutidos nas biblio-
tecas; criar conjuntos aleatórios; visualizar e analisar os dados recebidos, 
além de suas estatísticas que serão úteis para determinar qual é a melhor 
abordagem a seguir no aprendizado de máquina, bem como para adequá-los 
aos próximos passos, por exemplo, ajustando a escala dos atributos para que 
todos contribuam igualmente no processo de treinamento; testar diferentes 
algoritmos de aprendizado e o impacto que mudanças no conjunto de dados 
Aprendizagem não supervisionada: aplicação do k-means2
e seus respectivos parâmetros têm sobre o modelo escolhido; exibir as infor-
mações utilizando gráficos e recursos visuais de forma facilitada.
Todos os exemplos apresentados e as bibliotecas mencionadas podem ser 
utilizados no ambiente de desenvolvimento do Jupyter, que pode ser facilmente 
instalado por meio da plataforma Anaconda. A instalação das bibliotecas pode 
ser feita pelo prompt de comando do Anaconda utilizando o comando conda 
install package, em que o termo package deve ser substituído pela 
biblioteca desejada. As bibliotecas aqui utilizadas podem ser instaladas por 
meio de um único comando: conda install scikit-learn pandas 
seaborn matplotlib numpy. Concluídas as instalações, o Jupyter 
pode ser iniciado pelo comando: jupyter notebook. O exemplo a seguir 
demonstra de que forma um conjunto de dados da biblioteca SciKit-Learn é 
carregado.
# Exemplo 1
# importa o módulo que contém os conjuntos de dados
from sklearn import datasets as ds
# carrega o conjunto iris de dados
iris = ds.load_iris()
A biblioteca SciKit-Learn é dividida em módulos, e o módulo datasets 
é destinado, exclusivamente, aos conjuntos de dados embarcados na biblioteca. 
O caractere # indica que o restante da linha será ignorado pelo compilador, 
servindo apenas de comentário. A primeira linha de instrução importa o 
módulo datasets existente na biblioteca SciKit-Learn (sklearn), que 
passará a ser referenciado somente pelo nome ds. Na sequência, a variável 
iris recebe um dicionário contendo o conjunto de dados íris através do 
método load_iris(). A variável iris contém seis itens:
 � data — matriz ou vetor em que cada linha representa uma instância, 
e as colunas são diferentes atributos de uma mesma instância;
 � target — índice para os rótulos de cada instância na mesma ordem 
em que aparecem em data;
3Aprendizagem não supervisionada: aplicação do k-means
 � target_names — os nomes dados a cada um dos rótulos;
 � feature_names — nomes de cada uma das colunas de atributos;
 � DESCR — um texto descrevendo autoria e características do conjunto 
de dados;
 � filename — caminho em que se encontra o arquivo com os dados.
Essa disposição não é a mais prática para visualizar e analisar os dados. 
Então, é possível recorrer à biblioteca Pandas e criar um objeto DataFrame, 
que se parece com uma planilha, conforme o exemplo a seguir.
# Exemplo 2
# importa a biblioteca pandas
import pandas as pa
# cria um DataFrame a partir do objeto íris 
d f = p a . D a t a F r a m e ( d a t a = i r i s [ ' d a t a ' ] , 
columns=iris['feature_names'])
# adiciona ao DataFrame a coluna de atributos alvo
dfT = df.copy()
dfT['target'] = iris['target']
display(df), display(dfT)
O parâmetro columns utiliza o vetor feature_names para nomear 
cada uma das colunas de atributos. Já o parâmetro data pode receber todos 
os valores de atributos previsores e do atributo alvo, para isso, basta que os 
vetores sejam concatenados antes da criação do DataFrame. No entanto, 
adicionar essa coluna do atributo alvo separadamente é mais simples e legível. 
O resultado dessa transformação pode ser visualizado no Quadro 1.
Aprendizagem não supervisionada: aplicação do k-means4
sepal 
length 
(cm)
sepal 
width 
(cm)
petal 
lenght 
(cm)
petal 
width 
(cm)
target
0 5.1 3.5 1.4 0.2 0
1 4.9 3.0 1.4 0.2 0
2 4.7 3.2 1.3 0.2 0
3 4.6 3.1 1.5 0.2 0
4 5.0 3.6 1.4 0.2 0
… … … … … …
Quadro 1. Quadro de dados utilizando a biblioteca Pandas e o conjunto de dados íris do 
SciKit-Learn
Observe que o conjunto de dados íris contém quatro atributos previsores 
que especificam tamanhos de sépala e pétala, que são: sepal length (compri-
mento da sépala); sepal width (largura da sépala); petal length (comprimento 
da pétala); e petal width (largura da pétala). Todos os atributos previsores são 
dados em centímetros. O Quadro 1 exibe apenas as cinco primeiras instâncias 
do conjunto em que cada linha representa uma delas com seus respectivos 
valores para cada atributo.
O atributo denominado target é o atributo alvo, e os seus valores indicam 
uma das três classes possíveis de flor que a instância pode pertencer: setosa 
(0), versicolor (1) e virginica (2). Esse atributo, no entanto, não será utilizado 
no treinamento de tarefas de agrupamento, já que esse tipo de tarefa é de 
aprendizado não supervisionado e visa encontrar clusters que descrevam 
características intrínsecas dos dados.
Outra vantagem de se utilizar o DataFrame é o uso do método des-
cribe, que exibe um resumo com estatísticas a respeito de cada coluna 
de atributos (Quadro 2). Essas informações poderão guiá-lo na escolha da 
abordagem de aprendizado a ser utilizada e na necessidade da preparação e 
adequação dos dados.
5Aprendizagem não supervisionada: aplicação do k-means
sepal 
length 
(cm)
sepal 
width 
(cm)
petal 
length 
(cm)
petal 
width 
(cm)
target
count 150.000000 150.000000 150.000000 150.000000 150.000000
mean 5.843333 3.057333 3.758000 1.199333 1.000000
std 0.828066 0.435866 1.765298 0.762238 0.819232
min 4.300000 2.000000 1.000000 0.100000 0.000000
25% 5.100000 2.800000 1.600000 0.300000 0.000000
50% 5.800000 3.000000 4.350000 1.300000 1.000000
75% 6.400000 3.300000 5.100000 1.800000 2.000000
max 7.900000 4.400000 6.900000 2.500000 2.000000
Quadro 2. Resumo estatístico do DataFrame do conjunto de dados íris
A biblioteca Pandas conta ainda com diversos métodos de leitura de dados 
a partir de outras fontes, por exemplo:
 � read_clipboard — cria um DataFrame a partir dos dados co-
piados na prancheta (clipboard) do sistema operacional;
 � read_csv — arquivos em que colunas (atributos) são separadas por 
algum caractere especial, geralmente uma vírgula, e cada linha repre-
senta uma nova instância;
 � read_html — varre uma página na web na busca por tabelas que 
possam conter dados;
 � read_json — formato textual para representação de dados de qual-
quer tipo;
 � read_sql — leitura de banco de dados SQL, entre outros.
Aprendizagem não supervisionada: aplicação do k-means6
Além disso, é possível criar conjuntos de dados com valores aleatórios 
utilizando métodos como o make_blobs da biblioteca SciKit-Learn. 
Nos parâmetros, devem ser especificados a quantidade de instâncias (n_sam-
ples), a quantidade de atributos (n_features), um número aleatório 
para servir de base (random_state), o desvio padrão que os dados devem 
apresentar (cluster_std) e outros menos usuais. O exemplo a seguir mostra 
como criar um conjunto de dados de 100 instâncias com quatro atributos.
# Exemplo 3:
from sklearn import datasetsas ds
mb = ds.make_blobs(n_samples=100, n_features=4)
O resultado é uma tupla em que o primeiro item é uma matriz contendo 
os valores de cada um dos quatro atributos das 100 instâncias, e o segundo 
item é um vetor contendo o rótulo de cada instância.
2 Aplicação de k-means em um conjunto de 
dados
O SciKit-Learn inclui diversos algoritmos de agrupamento por meio do módulo 
sklearn.cluster. São classes com métodos de treinamento e predição. 
Para utilizar esses recursos, um objeto deve ser criado a partir da classe do 
algoritmo que se deseja implementar, configurando as propriedades do objeto 
para alterar os parâmetros do algoritmo (SCIKIT-LEARN, 2019a).
A biblioteca implementa o algoritmo de k-means. No modo padrão, é feita 
a escolha aleatória dos centroides (conforme quantidade especificada pelo 
parâmetro k), iniciada a classificação dos objetos mais próximos de cada 
centroide e feito o cálculo dos novos centroides a partir dos objetos perten-
centes ao grupo. Os últimos dois passos são repetidos até que não ocorram 
modificações nos grupos entre as iterações. Há ainda a possibilidade de utilizar 
uma versão modificada do algoritmo de k-means conhecida como k-means++, 
que seleciona os pontos iniciais de centroide por meio de um método, parte 
7Aprendizagem não supervisionada: aplicação do k-means
aleatório, parte estatístico, que evitará os piores casos de inicialização que 
poderiam ocorrer no algoritmo básico (ARTHUR; VASSILVITSKII, 2007).
O k-means++ não apenas está disponível na biblioteca do SciKit-Learn 
como é a opção padrão do módulo k-means. A inicialização aleatória pode 
ser utilizada por meio do parâmetro init='random', conforme o exemplo 
a seguir.
# Exemplo 4
# importação do módulo KMeans da biblioteca SciKit-Learn
from sklearn.cluster import KMeans
# alg recebe o objeto do método KMeans aleatório básico
alg = KMeans(init='random')
Caso seja omitido, o parâmetro init padrão será init=’k-means++’. 
Outros parâmetros podem ser configurados, como: n_clusters, n_init, 
max_iter, tol, precompute_distances, verbose, random_state, 
copy_x, n_jobs e algorithm.
O parâmetro n_clusters recebe um valor inteiro e define a quantidade 
de grupos buscados, geralmente conhecido por parâmetro k. O n_init, 
também do tipo inteiro, determina a quantidade de vezes que o algoritmo 
será executado na íntegra com novos valores iniciais para os centroides, en-
tretanto, apenas o melhor resultado será selecionado. O padrão é de 10 vezes 
(SCIKIT-LEARN, 2019b).
A quantidade de iterações máximas executadas também pode ser limitada 
pelo valor de max_iter (padrão de 300 iterações). Caso o algoritmo de 
k-means não estabilize antes desse limite, as iterações são interrompidas de 
qualquer forma (SCIKIT-LEARN, 2019b). Apesar de contrariar a teoria do 
algoritmo, essa é uma limitação prática para evitar que problemas excessiva-
mente complexos resultem em numerosas iterações atrasando o restante da 
aplicação, muitas vezes, sem grande contribuição para melhorar o resultado.
Aprendizagem não supervisionada: aplicação do k-means8
A variável tol é um valor do tipo float (ponto flutuante) para determinar 
a tolerância da variância admitida para que seja admitida a convergência do 
resultado (SCIKIT-LEARN, 2019b). Idealmente, espera-se que somente uma 
solução seja válida, no entanto, arredondamentos e limitações de casas decimais 
no cálculo poderiam fazer com que pequenas variações fossem mascaradas, 
resultando em mudanças de agrupamento que não estabilizariam o algoritmo. 
Por padrão: tol = 0,0001.
O parâmetro precompute_distances pode ser definido como auto 
(padrão) ou true/false. Quando ativado, ele acelera o processo de cálculo 
das distâncias, porém pode consumir uma quantidade significativa de memória 
para problemas com muitos clusters e amostras. No modo automático (auto), 
a pré-computação das distâncias será feita sempre que clusters · amostras ≤ 
12.000.000 (SCIKIT-LEARN, 2019b). Já o valor de verbose, de tipo inteiro, 
define o nível de informações retornadas pelo algoritmo durante as iterações. 
Se omitido, assumirá o valor zero, e nenhuma informação é retornada durante 
o processo. Pode ser útil para a depuração do código e para compreender com 
mais profundidade a forma como o algoritmo é executado (SCIKIT-LEARN, 
2019b).
Para iniciar os centroides de forma aleatória, o algoritmo depende de um 
algoritmo gerador de valores pseudoaleatórios com base no valor inteiro de 
random_state para melhorar a condição de aleatoriedade (SCIKIT-LEARN, 
2019b). Por padrão, copy_x recebe o valor true, determinando que os 
valores originais não sejam diretamente manipulados durante as iterações, 
preservando o resultado de pequenas variações durante o cálculo que poderiam 
atrasar o algoritmo (SCIKIT-LEARN, 2019b). Essa configuração, no entanto, 
afeta a quantidade de memória utilizada por demandar a cópia dos valores 
antes de cada iteração.
O valor de n_jobs permite efetuar mais de uma inicialização do k-means 
em tarefas paralelas. É um inteiro que define a quantidade de processamentos 
em paralelo, o padrão é apenas 1, fazendo com que a quantidade máxima 
permitida de processadores seja selecionada através do valor –1 (SCIKIT-
-LEARN, 2019b). Por fim, algorithm seleciona entre três formatos de 
cálculo das distâncias:
1. full — padrão dos algoritmos de k-means que calcula a distância de 
todos os pontos com relação ao centro;
2. elkan — converge para os mesmos resultados, mas reduz, a partir 
de triangulações, a quantidade de distâncias calculadas, eliminando 
muitas etapas desnecessárias/redundantes;
9Aprendizagem não supervisionada: aplicação do k-means
3. auto — recorre ao método convencional para conjuntos de dados 
esparsos, em que o algoritmo elkan implementado é incapaz de con-
vergir, e ao método elkan para conjuntos de dados densos (SCIKIT-
-LEARN, 2019b).
Apesar da simplicidade com que é definido, o algoritmo de k-means, 
como muitos outros algoritmos, tem inúmeras limitações e parâmetros na 
prática, a maioria relacionada ao tempo e à taxa de processamento deman-
dados. Na maior parte das vezes, especialmente quando estiver lidando com 
conjuntos de dados pequenos, as configurações se limitarão à quantidade de 
clusters (n_clusters) e ao valor de base para geração de pontos aleatórios 
(random_state). O código a seguir exemplifica a criação de um objeto 
da classe k-means a partir desses dois parâmetros, definindo k = 4 e para o 
random_state.
# Exemplo 5
# importação do módulo KMeans da biblioteca SciKit-Learn
from sklearn.cluster import KMeans
# alg recebe o objeto do método KMeans configurado para 
# identificar 4 clusters. O valor 50 serve de base para o 
# cálculo do ponto inicial de cada centroide.
alg = KMeans(n_clusters=4, random_state=50)
Uma vez criado o objeto com as devidas configurações, o conjunto de 
dados deve ser fornecido através da função fit que fará o treinamento do 
modelo. Nela, os parâmetros X e sample_weight (opcional) correspondem, 
respectivamente, aos dados de treinamento, em forma de vetor ou matriz, e 
aos pesos que devem ser dados para cada observação. O código a seguir faz 
o treinamento de dados com 100 amostras, dois atributos separados em três 
grupos de centro diferentes produzidos a partir do método make_blobs e.
Aprendizagem não supervisionada: aplicação do k-means10
# Exemplo 6
# carrega bibliotecas e módulos necessários
from sklearn import datasets as ds
from sklearn.cluster import KMeans
import pandas as pa
import seaborn as sb
import matplotlib.pyplot as pp
# distribuição aleatória: 100 objetos, 4 grupos, 2 carac-
terísticas desvio padrão de 1,3
X, y = ds.make_blobs(n_samples=100, n_features=2, cen-
ters=4, cluster_std=1.3)
# inicializa e treina um algoritmo de K-Means
km = KMeans(n_clusters=4, random_state=50)
km.fit(X)
prevs = km.predict(X)
# DataFrames para o conjunto de dados original com seu 
# atributo alvo e outro quadro com o atributo alvo previsto 
# a partir do K-Means
xDF =pa.DataFrame(data=X, columns=['Attr1', 'Attr2'])
pDF = xDF.copy()
xDF['Target'] = y
pDF['Target'] = prevs
# divisão da figura em duas colunas para plotar os dois 
# conjuntos
fig, axes = pp.subplots(1, 2, figsize=(12,4))
sb.scatterplot(data=xDF, x='Attr1', y='Attr2', hue='Target', 
palette='rainbow', ax=axes[0])
sb.scatterplot(data=pDF, x='Attr1', y='Attr2', hue='Target', 
palette='rainbow', ax=axes[1])
11Aprendizagem não supervisionada: aplicação do k-means
Com o auxílio das bibliotecas Pandas e Seaborn, são criados os 
DataFrame e os gráficos de dispersão (scatterplot), respectivamente. 
Uma vez que o método make_blobs retorna uma tupla, o resultado é des-
membrado em duas variáveis: x para os atributos previsores e y para o atributo 
alvo. O método predict cria um vetor para o atributo previsor a partir dos 
clusters descobertos pelo método fit anteriormente. Os quadros (Data-
Frame) facilitam tanto a apresentação dos dados quanto sua utilização em 
outras funções do Seaborn, quando é possível fornecer os índices de caracte-
rística (x e y) e o índice que representa as classes pelo atributo hue. A Figura 1 
apresenta um comparativo entre os dados originais e suas classificações e os 
dados previstos pelo k-means.
Figura 1. Comparativo entre os dados originais e suas classificações (à esquerda) e os dados 
previstos pelo k-means (à direita).
Como é possível perceber na Figura 1, clusters parecidos foram detectados, 
contudo, devido a pontos de sobreposição (imagem da esquerda), alguns objetos 
dos grupos 2 e 3 foram invertidos na imagem da direita. Também devido a 
isso, não foram atribuídos exatamente os mesmos rótulos para cada grupo, 
porque cada função utilizou os objetos em ordens diferentes. Os nomes dados, 
no entanto, não possuem qualquer relevância, não é atribuição dos algoritmos 
de agrupamento atribuir um rótulo, mas encontrar grupos que possam ser 
rotulados. Nesse caso, pode-se perceber que o treinamento, apesar de possuir 
imprecisões, foi muito eficiente, apresentando poucas divergências de clusters.
Aprendizagem não supervisionada: aplicação do k-means12
3 Agrupamento e avaliação
A fim de compreender o algoritmo de agrupamento, um novo exemplo utili-
zando o conjunto de dados íris é criado no código a seguir.
# Exemplo 7
# importação das bibliotecas e seleção dos módulos a serem 
# utilizados
from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
import pandas as pa
import seaborn as sb
import matplotlib.pyplot as pp
import numpy as np
# importação e separação dos dados
iDS = load_iris()
iData, iTarget, iTarget_Names, _, iFeature_Names, _ = 
iDS.values()
# formatação dos dados em quadro da biblioteca pandas para 
# facilitar a visualização
iDF = pa.DataFrame(data=iData, columns=iFeature_Names)
iDF_Target = iDF.copy()
iDF_Target['specie'] = iTarget_Names[iTarget]
# visualizar a sobreposição das espécies entre todas as 
# combinações de pares de características
sb.pairplot(data=iDF_Target, hue='specie')
A tupla retornada por load_iris() é desmembrada em seis variáveis:
 � iData — matriz contendo os valores de cada instância de cada atributo 
previsor;
 � iTarget — vetor contendo os valores de atributo alvo para cada instância;
13Aprendizagem não supervisionada: aplicação do k-means
 � iTarget_Names — vetor com os nomes dados a cada uma das três 
espécies rotuladas;
 � iFeature_Names — vetor com o nome dado aos atributos previsores;
 � outros dois itens da tupla recebem um nome qualquer, pois não há 
interesse em seus usos, referem-se a uma string contendo a descrição 
e a outra contendo o caminho para o arquivo.
Os dados de entrada e saída (atributos previsores e atributo alvo) são 
utilizados para construir um DataFrame. A coluna alvo recebe o nome 
specie (espécie). O DataFrame é utilizado na plotagem da distribuição 
dos dados aos pares de atributos (função pairplot), sempre classificados 
segundo a coluna specie, conforme especificado pelo parâmetro hue. 
O resultado pode ser visto na Figura 2.
Figura 2. Gráficos de distribuição das instâncias selecionando pares de cada um dos 
atributos.
Aprendizagem não supervisionada: aplicação do k-means14
Qualquer combinação de características pode ser utilizada na tarefa de 
agrupamento. O resultado, no entanto, será muito diferente de uma para outra. 
Todos os gráficos da Figura 2 possuem algum nível de sobreposição, algumas 
combinações parecem ter maiores distinções entre os agrupamentos do que 
outras. Poderíamos descartar o cruzamento entre as duas características das 
sépalas (sepal) apenas visualizando os gráficos. Para esse exemplo, optou-se 
pela combinação sepal length e petal width por relacionar características 
bem diferentes e aparentar uma distribuição com boa separação de espécies. 
No entanto, outras combinações poderiam resultar em agrupamentos ainda 
melhores.
O exemplo a seguir apresenta a seleção dos atributos que serão utilizados, 
respectivamente, a primeira (índice 0) e a quarta (índice 3) coluna da matriz, 
como foi possível ver nos gráficos da Figura 2. Mais uma vez é criado um 
DataFrame e adicionada a coluna dos rótulos originais ao novo DataFrame.
# Exemplo 8
# seleção das duas características
iData_SL_PW = iData[:, [0,3]]
iDF_SL_PW = pa.DataFrame(data=iData_SL_PW, 
columns=[iFeature_Names[0], iFeature_Names[3]])
iDF_SL_PW_T = iDF_SL_PW.copy()
iDF_SL_PW_T['specie'] = iDF_Target['specie']
# distribuição após seleção dos atributos sem rótulos 
# definidos
prevFeatureNames = iDF_SL_PW_T.keys()
sb.scatterplot(data=iDF_SL_PW_T, x=prevFeatureNames[0], 
y=prevFeatureNames[1])
O gráfico da Figura 3 mostra novamente a distribuição dos dados segundo 
o par de características selecionadas, porém, sem qualquer rótulo ou agrupa-
mento que as separe.
15Aprendizagem não supervisionada: aplicação do k-means
Figura 3. Distribuição dos dados sem clusters formados.
O algoritmo de k-means é configurado para buscar a mesma quantidade de clus-
ters que a quantidade de espécies esperada, a previsão de agrupamento é treinada 
e feita segundo os clusters encontrados para o mesmo conjunto de dados utilizados 
no treinamento. O vetor resultante é atribuído ao novo DataFrame, agora com 
os dados das duas características de entrada, mas como atributo alvo os valores 
previstos pelo algoritmo. A seguir, é apresentado o código desse procedimento.
# Exemplo 9
# quantidade de clusters será a mesma da quantidade de 
# espécies do conjunto de dados
k = len(iTarget_Names)
# configuração do algoritmo e treinamento
alg = KMeans(n_clusters=k, random_state=50)
alg.fit(X=iData_SL_PW)
# construção de novo quadro considerando os agrupamentos 
# previstos pelo K-Means
prevDataFrame = iDF_SL_PW.copy()
prevDataFrame['specie'] = alg.predict(iData_SL_PW)
prevDataFrame
Aprendizagem não supervisionada: aplicação do k-means16
O gráfico da Figura 4 serve de base para que os grupos encontrados sejam 
então rotulados pelo usuário. É possível observar que a ordem detectada não 
é a mesma, mas é visível qual cluster se refere a qual espécie.
Figura 4. Clusters encontrados.
Na Figura 4, é possível notar três clusters em posições equivalentes aos 
formados pelas espécies setosa, virginca e versicolor, como já observado no 
pairplot entre as características selecionadas da Figura 4. 
# Exemplo 10
translateDic = { 0: 'virginica', 1: 'setosa', 2: 'versicolor' }
prevDataFrame['specie'] = [translateDic[s] for s in 
prevDataFrame['specie']]
fig, axes = pp.subplots(1, 2, figsize=(12,4))
fig1 = sb.scatterplot(data=iDF_SL_PW_T, 
x=prevFeatureNames[0], y=prevFeatureNames[1], hue='specie', 
ax=axes[0])
fig2 = sb.scatterplot(data=prevDataFrame, 
x=prevFeatureNames[0], y=prevFeatureNames[1], hue='specie', 
ax=axes[1])
17Aprendizagem não supervisionada: aplicação do k-means
O exemplo anterior faz a tradução e termina por exibir um comparativo 
entre os clusters