Olá pessoal, espero que todos estejam bem! Estava meio sumido aqui devido ao trabalho e novos projetos que estava envolvido, mas agora estou de volta e pretendo criar uma nova serie de postagens incríveis para desvendarmos juntos a inteligência synthetic, e para começar essa história vamos começar com as árvores de decisões, bora la!
As árvores de decisão são uma ferramenta poderosa e amplamente utilizada em aprendizado de máquina e análise de dados. Elas são intuitivas, fáceis de entender e podem ser aplicadas em diversas áreas para resolver problemas de classificação e regressão. Neste artigo, exploraremos o que são árvores de decisão, algumas de suas aplicações e forneceremos um exemplo prático de como implementá-las em Python.
O que são Árvores de Decisão?
Árvores de decisão são estruturas hierárquicas usadas para tomar decisões com base em uma série de perguntas sim/não (ou decisões binárias). Cada nó da árvore representa uma pergunta ou condição sobre uma característica do dado, e as folhas representam os resultados ou decisões finais. As ramificações da árvore são os possíveis resultados das perguntas que levam a novos nós ou folhas.
A construção de uma árvore de decisão envolve a divisão repetida do conjunto de dados em subconjuntos, com base nos valores dos atributos, de forma a maximizar a pureza dos subconjuntos resultantes. Esse processo é chamado de “divisão recursiva”.
Aplicações das Árvores de Decisão
As árvores de decisão são aplicáveis em várias áreas, incluindo:
- Diagnóstico Médico: Ajuda a identificar doenças com base em sintomas.
- Detecção de Fraude: Usadas por instituições financeiras para identificar transações suspeitas.
- Advertising and marketing: Para segmentar clientes e prever comportamentos de
- compra.
- Financeiro: Para prever falências e avaliar riscos de crédito.
- Engenharia: Auxilia no controle de qualidade e manutenção preditiva.
Exemplo Prático em Python
Vamos criar um modelo de árvore de decisão para prever se uma pessoa vai jogar tênis com base em condições meteorológicas. Usaremos um conjunto de dados que inclui atributos como outlook (perspectiva), temperature (temperatura), humidity (umidade) e wind (vento).
Passo 1: Importar Bibliotecas Necessárias
Primeiro, precisamos importar as bibliotecas essenciais e instalar graphviz e pydotplus para a visualização da árvore:
!pip set up graphviz pydotplusimport pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.preprocessing import LabelEncoder
import matplotlib.pyplot as plt
import graphviz
from sklearn.tree import export_graphviz
import pydotplus
from IPython.show import Picture
Passo 2: Carregar e Processar os Dados
Em seguida, carregamos os dados, codificamos as variáveis categóricas e dividimos os dados em conjuntos de treinamento e teste:
Baixe o arquivo CSV: https://pastebin.com/uFEC7y2r
# Carregar os dados do CSV
information = pd.read_csv('tennis.csv')# Inicializar os codificadores de rótulos para variáveis categóricas
outlook_encoder = LabelEncoder()
wind_encoder = LabelEncoder()
play_encoder = LabelEncoder()
# Codificar as variáveis categóricas
information['outlook'] = outlook_encoder.fit_transform(information['outlook'])
information['wind'] = wind_encoder.fit_transform(information['wind'])
information['play'] = play_encoder.fit_transform(information['play'])
# Exibir os mapeamentos de valores codificados
print("Mapeamento de 'outlook':", dict(zip(outlook_encoder.classes_, outlook_encoder.remodel(outlook_encoder.classes_))))
print("Mapeamento de 'wind':", dict(zip(wind_encoder.classes_, wind_encoder.remodel(wind_encoder.classes_))))
print("Mapeamento de 'play':", dict(zip(play_encoder.classes_, play_encoder.remodel(play_encoder.classes_))))
# Separar as características (options) e o rótulo (label)
X = information[['outlook', 'temperature', 'humidity', 'wind']]
y = information['play']
# Dividir os dados em conjunto de treinamento e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
Passo 3: Treinar o Modelo de Árvore de Decisão
Agora, criamos e treinamos o modelo de árvore de decisão:
# Criar o modelo de árvore de decisão
clf = DecisionTreeClassifier()# Treinar o modelo
clf.match(X_train, y_train)
Passo 4: Fazer Previsões com Novos Dados
Vamos usar o modelo treinado para prever se uma pessoa vai jogar tênis com base em novos dados de entrada:
# Definir novos dados para previsão
new_data = {'outlook': 'sunny', 'temperature': 75, 'humidity': 70, 'wind': 'false'}# Converter os novos dados usando os mesmos label encoders treinados
new_data['outlook'] = outlook_encoder.remodel([new_data['outlook']])[0]
new_data['wind'] = wind_encoder.remodel([new_data['wind']])[0]
# Exibir os valores codificados dos novos dados
print("Novos dados codificados:", new_data)
# Converter para DataFrame
new_data_df = pd.DataFrame([new_data])
# Fazer a previsão
prediction = clf.predict(new_data_df)
# Converter a previsão de volta para o valor authentic
play_prediction = play_encoder.inverse_transform(prediction)
print(f"Vai jogar tênis? {'Sim' if play_prediction[0] == 'sure' else 'Não'}")
Passo 5: Visualizar a Árvore de Decisão
Por fim, vamos visualizar a árvore de decisão gerada:
# Visualizar a árvore de decisão
plt.determine(figsize=(20,10))
plot_tree(clf, feature_names=['outlook', 'temperature', 'humidity', 'wind'], class_names=['no', 'yes'], crammed=True)
plt.present()# Exportar a árvore para um arquivo Graphviz e visualizar como uma imagem
dot_data = export_graphviz(clf, out_file=None,
feature_names=['outlook', 'temperature', 'humidity', 'wind'],
class_names=['no', 'yes'],
crammed=True, rounded=True,
special_characters=True)
graph = pydotplus.graph_from_dot_data(dot_data)
Picture(graph.create_png())
No closing sera exibido a representação da árvore formada.
Conclusão
As árvores de decisão são uma técnica versátil e intuitiva para classificação e regressão. Elas são fáceis de entender e interpretar, o que as torna uma escolha widespread em muitas aplicações do mundo actual. No exemplo prático acima, mostramos como construir, treinar e visualizar uma árvore de decisão usando Python, com uma aplicação simples na previsão de atividades ao ar livre com base nas condições meteorológicas.
Espero que este artigo tenha fornecido uma boa introdução às árvores de decisão e suas aplicações. Sinta-se à vontade para experimentar com diferentes conjuntos de dados e parâmetros para explorar mais sobre essa poderosa ferramenta de aprendizado de máquina.
Gostou deste artigo?
Siga-me para mais conteúdos sobre ciência de dados e aprendizado de máquina! Se tiver alguma dúvida ou sugestão, deixe um comentário abaixo.
