Uma árvore de decisão é um tipo de algoritmo de aprendizado supervisionado usado tanto pra classificação quanto pra regressão. Apesar do nome lembrar a estrutura de dados de uma “árvore binária”, ela não é bem isso, ela só usa um formato de árvore, com perguntas nos galhos e respostas nas folhas.
A ideia é simples: o algoritmo usa perguntas para tomar decisões. Cada nó da árvore é uma pergunta baseada nos dados, e cada resposta leva a outra pergunta ou a uma decisão last.
Por exemplo: “Esse cliente vai pagar a dívida?. Qual o melhor ônibus pra chegar no destino X?”
O algoritmo aprende com os dados e descobre quais variáveis são mais importantes. A mais importante vai professional nó da raiz, que é a primeira pergunta da árvore. A partir daí, ele vai dividindo os dados em blocos menores, até chegar numa resposta last nas folhas.
Exemplo bem simples
Imagina que você quer saber se um aluno vai passar ou não numa matéria, você tem os seguintes dados:
O algoritmo de árvore de decisão começa analisando qual variável (atributo) é mais útil para separar os dados. Para isso, ele usa uma medida chamada entropia, que calcula o “grau de bagunça” ou incerteza.
Depois disso, ele calcula o ganho de informação de cada atributo (o quanto a entropia diminui se usarmos aquele atributo para dividir os dados). A variável que mais “organiza” os dados é escolhida como raiz da árvore.
A entropia inicial da coluna “Passou” é calculada assim: Temos 3 alunos que passaram e 3 que não passaram, então:
Agora vamos ver como essa entropia muda se dividirmos os dados com base em uma das variáveis, como “Estuda Muito”.
- Estuda Muito = Sim → 3 registros
| Passou: Sim, Não, Sim → 2 sim / 1 não
Entropia = 0.918 - Estuda Muito = Não → 3 registros
| Passou: Não, Não, Sim → 1 sim / 2 não
Entropia = 0.918
Esse valor é pequeno, se outra variável der um ganho maior, ela será escolhida como raiz. Você repetiria isso para “Faltou Muito” e “Nota Alta”, e escolheria a variável com maior ganho de informação.
Depois que o algoritmo escolher a melhor variável (vamos supor que seja Nota Alta), ele monta a árvore:
Para este pequeno artigo utilizarei um pequeno dataset de risco de credito, onde um registro representa um cliente de um banco. Objetivo last é que nossa árvore de decisão tente prever com base nos dados qual o risco de emprestar dinheiro a este cliente.
Importando As Bibliotecas
import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.tree import DecisionTreeClassifier
import matplotlib.pyplot as plt
Importando a Base de Dados
base_risco_credito = pd.read_csv("risco_credito.csv")
Pegando os Atributos Previsores e o Atributo Alvo
# Pegando os valores previsores
X_credito = base_risco_credito.iloc[:, 0:4].values# Pegando a classe alvo
y_credito = base_risco_credito.iloc[:, 4].values
Tratamento de Dados
Algoritmos de Machine Studying não lidam muito bem com dados em formato de texto (strings). Como a nossa base é praticamente toda composta por colunas categóricas, será necessário transformar esses valores em números. Para isso, vamos utilizar o LabelEncoder, que converte cada categoria em um número inteiro, facilitando o processamento pelos algoritmos.
# Aplicando labelEncoder
label_encoder_historia = LabelEncoder()
label_encoder_divida = LabelEncoder()
label_encoder_garantia = LabelEncoder()
label_encoder_renda = LabelEncoder()X_credito[:, 0] = label_encoder_historia.fit_transform(X_credito[:, 0])
X_credito[:, 1] = label_encoder_divida.fit_transform(X_credito[:, 1])
X_credito[:, 2] = label_encoder_garantia.fit_transform(X_credito[:, 2])
X_credito[:, 3] = label_encoder_renda.fit_transform(X_credito[:, 3])
Portanto nossos atributos previsores ficaram desta maneira:
Criando a Árvore de Decisão
Agora vamos criar nossa árvore de decisão e treinar o nosso modelo.
tree_credit = DecisionTreeClassifier(criterion="entropy")
tree_credit.match(X_credito, y_credito)
Vamos Visualizar a Árvore
previsores = ['historia', 'dívida', 'garantia', 'renda']
figura, eixos = plt.subplots(nrows=1, ncols=1, figsize=(10,10))
tree.plot_tree(tree_credit, feature_names=previsores, class_names=tree_credit.classes_, crammed=True);
Neste artigo, construímos uma árvore de decisão simples, passo a passo, para entender como o algoritmo funciona por trás das previsões. Usamos um exemplo prático com dados fictícios.
A ideia foi aprender na prática como o modelo toma decisões com base em dados. Sei que ainda estou no começo da jornada em Machine Studying, então desculpa se cometi algum erro ou se algo ficou confuso, estou aprendendo e compartilhando o que estou entendendo.
