Imagem do responsável
Árvores de decisão dividem decisões difíceis em fases simples e fáceis de seguir, funcionando assim uma vez que cérebros humanos.
Na ciência de dados, esses instrumentos fortes são amplamente aplicados para facilitar na estudo de dados e na direção da tomada de decisões.
Neste item, abordarei uma vez que as árvores de decisão funcionam, darei exemplos do mundo real e darei algumas dicas para melhorá-las.
Estrutura das Árvores de Decisão
Fundamentalmente, árvores de decisão são ferramentas simples e claras. Elas quebram opções difíceis em escolhas mais simples e sequenciais, refletindo, portanto, a tomada de decisão humana. Vamos agora explorar os principais elementos que formam uma árvore de decisão.
Nós, Ramos e Folhas
Três componentes básicos definem uma árvore de decisão: folhas, galhos e nós. Cada um deles é absolutamente precípuo para o processo de tomada de decisões.
- Nós: São pontos de decisão pelos quais a árvore decide dependendo dos dados de ingresso. Ao simbolizar todos os dados, o nó raiz é o ponto de partida.
- Galhos: Eles relacionam o resultado de uma decisão e nós de relação. Cada ramificação corresponde a um resultado ou valor potencial de um nó de decisão.
- Folhas: As extremidades da árvore de decisão são folhas, às vezes conhecidas uma vez que nós-folha. Cada nó-folha oferece uma certa consequência ou rótulo; eles refletem a última escolha ou classificação.
Exemplo conceitual
Suponha que você esteja escolhendo Sua visita nos ajuda a continuar oferecendo o melhor para você! vai se aventurar lá fora dependendo da temperatura. “Está chovendo?”, o nó raiz perguntaria. Se sim, você pode encontrar um branch indo em direção a “Ligeiro um guarda-chuva”. Leste não deveria ser o caso; outro branch poderia expressar, “Use óculos de sol”.
Essas estruturas tornam as árvores de decisão fáceis de interpretar e visualizar, por isso são populares em vários campos.
Exemplo do mundo real: a proeza da aprovação de empréstimos
Imagine a seguinte situação: você é um mago no Banco Gringotes, decidindo quem recebe um empréstimo para sua novidade vassoura.
- Nó raiz: “A pontuação de crédito deles é mágica?”
- Se sim → Vá para “Aprove mais rápido do que você consegue expressar Quadribol!”
- Se não → Vá para “Verificar as reservas de ouro dos goblins”.
- Se cume →, “Aprove, mas fique de olho neles”.
- Se reles → “Negue mais rápido que uma Nimbus 2000.”
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
import matplotlib.pyplot as plt
data = {
'Credit_Score': [700, 650, 600, 580, 720],
'Income': [50000, 45000, 40000, 38000, 52000],
'Approved': ['Yes', 'No', 'No', 'No', 'Yes']
}
df = pd.DataFrame(data)
X = df[['Credit_Score', 'Income']]
y = df['Approved']
clf = DecisionTreeClassifier()
clf = clf.fit(X, y)
plt.figure(figsize=(10, 8))
tree.plot_tree(clf, feature_names=['Credit_Score', 'Income'], class_names=['No', 'Yes'], filled=True)
plt.show()Cá está o resultado.
Quando você executar esta magia, verá uma árvore nascer! É uma vez que o Planta do Maroto de aprovações de empréstimos:
- O nó raiz se divide em Credit_Score
- Se for ≤ 675, aventuramo-nos para a esquerda
- Se for > 675, viajamos para a direita
- As folhas mostram nossas decisões finais: “Sim” para ratificado, “Não” para refutado
Voilà! Você acaba de fabricar uma globo de cristal para tomada de decisões!
Quebra-mentes: Se sua vida fosse uma árvore de decisão, qual seria a pergunta do nó raiz? “Tomei moca esta manhã?” pode levar a alguns galhos interessantes!
Árvores de decisão: por trás dos galhos
Árvores de decisão funcionam de forma similar a um fluxograma ou estrutura de árvore, com uma sucessão de pontos de decisão. Elas começam dividindo um conjunto de dados em pedaços menores e, portanto, constroem uma árvore de decisão para acompanhá-lo. A maneira uma vez que essas árvores lidam com a subdivisão de dados e diferentes variáveis é um tanto que devemos observar.
Critérios de subdivisão: Impureza de Gini e proveito de informação
Escolher a melhor qualidade para dividir os dados é o objetivo principal da construção de uma árvore de decisão. É provável estabelecer esse procedimento usando critérios fornecidos por Information Gain e Gini Impurity.
- Impureza de Gini: Imagine-se no meio de um jogo de adivinhação. Com que frequência você se enganaria se selecionasse aleatoriamente um rótulo? É isso que a Impureza de Gini mede. Podemos fazer melhores suposições e ter uma árvore mais feliz com um coeficiente de Gini menor.
- Lucro de informação: O momento “aha!” em uma história de mistério é o que você pode confrontar a isso. O quanto uma dica (atributo) ajuda a resolver o caso é medido por ela. Um “aha!” maior significa mais proveito, o que significa uma árvore extática!
Para prever se um cliente compraria um resultado do seu conjunto de dados, você pode Sua visita nos ajuda a continuar oferecendo o melhor para você! com informações demográficas básicas, uma vez que idade, renda e histórico de compras. A abordagem leva tudo isso em consideração e encontra o que separa os compradores dos outros.
Manipulando dados contínuos e categóricos
Não há nenhum tipo de informação que nossos detetives de árvores não possam examinar.
Para características que são fáceis de mudar, uma vez que idade ou renda, a árvore configura uma embuste de velocidade. “Qualquer pessoa com mais de 30 anos, por cá!”
Quando se trata de dados categóricos, uma vez que gênero ou tipo de resultado, é mais uma vez que uma fileira. “Smartphones ficam à esquerda; laptops à direita!”
Caso arquivado do mundo real: o preditor de compra do cliente
Para entender melhor uma vez que as árvores de decisão funcionam, vamos examinar um exemplo da vida real: usar a idade e a renda de um cliente para imaginar se ele comprará um resultado.
Para imaginar o que as pessoas comprarão, faremos uma coleção simples e uma árvore de decisão.
Uma descrição do código
- Importamos bibliotecas uma vez que o pandas para trabalhar com os dados, o DecisionTreeClassifier do scikit-learn para edificar a árvore e o matplotlib para mostrar os resultados.
- Gerar conjunto de dados: idade, renda e status de compra são usados para fabricar um conjunto de dados de exemplar.
- Prepare os recursos e as metas: a variável de meta (Comprado) e os recursos (Idade, Renda) são configurados.
- Treinar o protótipo: as informações são usadas para configurar e treinar o classificador de árvore de decisão.
- Veja a árvore: Por termo, desenhamos a árvore de decisão para que possamos ver uma vez que as escolhas são feitas.
Cá está o código.
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
import matplotlib.pyplot as plt
data = {
'Age': [25, 45, 35, 50, 23],
'Income': [50000, 100000, 75000, 120000, 60000],
'Purchased': ['No', 'Yes', 'No', 'Yes', 'No']
}
df = pd.DataFrame(data)
X = df[['Age', 'Income']]
y = df['Purchased']
clf = DecisionTreeClassifier()
clf = clf.fit(X, y)
plt.figure(figsize=(10, 8))
tree.plot_tree(clf, feature_names=['Age', 'Income'], class_names=['No', 'Yes'], filled=True)
plt.show()Cá está o resultado.
A árvore de decisão final mostrará uma vez que a árvore se divide com base na idade e na renda para deslindar se um cliente tem verosimilhança de comprar um resultado. Cada nó é um ponto de decisão, e os ramos mostram resultados diferentes. A decisão final é mostrada pelos nós folha.
Agora, vamos ver uma vez que as entrevistas podem ser usadas no mundo real!
Aplicações do mundo real
Leste projeto foi criado uma vez que uma tarefa para levar para mansão para cargos de ciência de dados do Meta (Facebook). O objetivo é edificar um algoritmo de classificação que preveja se um filme no Rotten Tomatoes é rotulado uma vez que ‘Rotten’, ‘Fresh’ ou ‘Certified Fresh’.
Cá está o link para leste projeto: https://platform.stratascratch.com/data-projects/rotten-tomatoes-movies-rating-prediction
Agora, vamos dividir a solução em etapas codificáveis.
Solução passo a passo
- Preparação de dados:Iremos mesclar os dois conjuntos de dados no link_tomates_podres pilar. Isso nos dará um conjunto de dados abrangente com informações sobre filmes e análises de críticos.
- Seleção de recursos e engenharia: Selecionaremos recursos relevantes e executaremos as transformações necessárias. Isso inclui transformar variáveis categóricas em numéricas, manipular valores ausentes e regularizar os valores dos recursos.
- Treinamento de protótipo:Treinaremos um classificador de árvore de decisão no conjunto de dados processado e usaremos validação cruzada para calcular o desempenho robusto do protótipo.
- Avaliação:Por termo, avaliaremos o desempenho do protótipo usando métricas uma vez que exatidão, exatidão, recall e pontuação F1.
Cá está o código.
import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report
from sklearn.preprocessing import StandardScaler
movies_df = pd.read_csv('rotten_tomatoes_movies.csv')
reviews_df = pd.read_csv('rotten_tomatoes_critic_reviews_50k.csv')
merged_df = pd.merge(movies_df, reviews_df, on='rotten_tomatoes_link')
features = ['content_rating', 'genres', 'directors', 'runtime', 'tomatometer_rating', 'audience_rating']
target="tomatometer_status"
merged_df['content_rating'] = merged_df['content_rating'].astype('category').cat.codes
merged_df['genres'] = merged_df['genres'].astype('category').cat.codes
merged_df['directors'] = merged_df['directors'].astype('category').cat.codes
merged_df = merged_df.dropna(subset=features + [target])
X = merged_df[features]
y = merged_df[target].astype('category').cat.codes
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, random_state=42)
clf = DecisionTreeClassifier(max_depth=10, min_samples_split=10, min_samples_leaf=5)
scores = cross_val_score(clf, X_train, y_train, cv=5)
print("Cross-validation scores:", scores)
print("Average cross-validation score:", scores.mean())
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
classification_report_output = classification_report(y_test, y_pred, target_names=['Rotten', 'Fresh', 'Certified-Fresh'])
print(classification_report_output)Cá está o resultado.
O protótipo mostra subida precisão e pontuações F1 em todas as classes, indicando bom desempenho. Vamos ver as principais conclusões.
Principais conclusões
- A seleção de recursos é crucial para o desempenho do protótipo. Gêneros de classificação de teor, tempo de realização dos diretores e classificações provaram ser preditores valiosos.
- Um classificador de árvore de decisão conquista efetivamente relacionamentos complexos em dados de filmes.
- A validação cruzada garante a confiabilidade do protótipo em diferentes subconjuntos de dados.
- O cume desempenho na classe “Certified-Fresh” justifica uma investigação mais aprofundada sobre o potencial desequilíbrio de classes.
- O protótipo é promissor para emprego no mundo real na previsão de classificações de filmes e na melhoria da experiência do usuário em plataformas uma vez que o Rotten Tomatoes.
Melhorando as árvores de decisão: transformando sua muda em um poderoso roble
Portanto, você criou sua primeira árvore de decisão. Impressionante! Mas por que parar por aí? Vamos transformar essa muda em um gigante da floresta que deixaria até Groot com inveja. Pronto para substanciar sua árvore? Vamos submergir!
Técnicas de poda
Pruning é um método usado para trinchar o tamanho de uma árvore de decisão eliminando partes que têm capacidade mínima na vaticinação de variáveis-alvo. Isso ajuda a reduzir o overfitting em pessoal.
- Pré-poda: Frequentemente chamado de paragem precoce, isso envolve parar o prolongamento da árvore imediatamente. Antes do treinamento, o protótipo tem parâmetros especificados, incluindo profundidade máxima (profundidade_máxima), amostras mínimas necessárias para dividir um nó (min_amostras_divisão), e amostras mínimas necessárias em um nó folha (min_amostras_folha). Isso evita que a árvore cresça de forma muito complicada.
- Pós-poda: Leste método faz a árvore crescer até sua profundidade máxima e remove nós que não oferecem muito poder. Embora seja mais desgastante computacionalmente do que a pré-poda, a pós-poda pode ser mais bem-sucedida.
Métodos de conjunto
Técnicas de ensemble combinam vários modelos para gerar desempenho supra do de qualquer protótipo. Duas formas primárias de técnicas de ensemble aplicadas com árvores de decisão são bagging e boosting.
- Bagging (reunião bootstrap): Leste método treina várias árvores de decisão em vários subconjuntos de dados (gerados por amostragem com substituição) e portanto faz a média de suas previsões. Uma técnica de bagging frequentemente usada é a Random Forest. Ela diminui a variância e auxilia na prevenção de overfit. Confira “Algoritmo de Árvore de Decisão e Floresta Aleatória“para abordar profundamente tudo relacionado ao algoritmo Decision Tree e sua extensão “Random Forest algorithm”.
- Impulsionando: O Boosting cria árvores uma em seguida a outra, pois cada uma procura consertar os erros da próxima. Técnicas de Boosting abundam em algoritmos, incluindo AdaBoost e Gradient Boosting. Ao enfatizar exemplos desafiadores de prever, esses algoritmos às vezes fornecem modelos mais exatos.
Ajuste de hiperparâmetros
O ajuste de hiperparâmetros é o processo de estabelecer o conjunto de hiperparâmetros ideal para um protótipo de árvore de decisão para aumentar seu desempenho. Usando métodos uma vez Sua visita nos ajuda a continuar oferecendo o melhor para você! Grid Search ou Random Search, por meio dos quais várias combinações de hiperparâmetros são avaliadas para identificar a melhor feição, isso pode ser realizado.
Epílogo
Neste item, discutimos a estrutura, o mecanismo de funcionamento, as aplicações no mundo real e os métodos para melhorar o desempenho da árvore de decisão.
Praticar árvores de decisão é crucial para dominar seu uso e entender suas nuances. Trabalhar em projetos de dados do mundo real também pode fornecer experiência valiosa e melhorar habilidades de solução de problemas.
Nate Rosidi é um investigador de dados e em estratégia de produtos. Ele também é um professor junto ensinando estudo e é o fundador da StrataScratch, uma plataforma que ajuda cientistas de dados a se prepararem para suas entrevistas com perguntas de entrevistas reais de grandes empresas. Nate escreve sobre as últimas tendências no mercado de curso, dá conselhos para entrevistas, compartilha projetos de ciência de dados e cobre tudo sobre SQL.
