1. Árvore de Decisão
As árvores de decisão são uma técnica popular de aprendizado de máquina supervisionado usada para classificação e regressão.
Neste projeto, foi utilizada a base de dados Credit Score Classification, que reúne informações bancárias essenciais e uma grande quantidade de registros relacionados a crédito.
O objetivo principal é aplicar árvores de decisão para segmentar indivíduos em diferentes faixas de score de crédito, contribuindo para a identificação de perfis de risco e para o apoio em processos de decisão financeira.
Imports:
import pandas as pd
from sklearn import tree, metrics
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
Leitura da base:
df = pd.read_csv('credit_score_classification.csv', low_memory=False)
Exploração dos Dados¶
A análise inicial do conjunto de dados inclui a descrição da natureza das variáveis, estatísticas descritivas e visualizações para compreender a distribuição e relevância das informações.
Descrição e estatísticas descritivas das colunas¶
A base contém 28 colunas, resumidas abaixo:
| Coluna | Descrição | Observações / Relevância |
|---|---|---|
ID | Identificação única de um registro | Irrelevante, não agrega valor estatístico |
Customer_ID | Identificação única de um cliente | Irrelevante, mesma justificativa da anterior |
Month | Mês do ano | Bem distribuído, cada mês ≈ 12,5% |
Name | Nome do cliente | Irrelevante, não agrega valor estatístico |
Age | Idade do cliente | Pode ser transformada em faixas etárias (feature engineering) |
SSN | Número de seguridade social | Irrelevante, valor único por cliente |
Occupation | Ocupação do cliente | Bem distribuída, média ≈ 6,6% |
Annual_Income | Renda anual | Valores quase únicos; útil se agrupada em faixas ou escalas (feature engineering) |
Monthly_Inhand_Salary | Salário mensal líquido | Similar à renda anual; pode ser útil após agregação ou categorização (feature engineering) |
Num_Bank_Accounts | Número de contas bancárias | Equilibrado, maior frequência ≈ 13% |
Num_Credit_Card | Número de cartões de crédito | Bem distribuído, maior representatividade ≈ 18% |
Interest_Rate | Taxa de juros do cartão | Distribuição uniforme, cada valor ≈ 5% |
Num_of_Loan | Número de empréstimos obtidos | Equilibrado, maior concentração ≈ 15% |
Type_of_Loan | Tipo de empréstimo | Diversidade de valores, cada tipo ≈ 1,44% |
Delay_from_due_date | Média de dias de atraso | Bem distribuído, cada valor ≈ 3,6% |
Num_of_Delayed_Payment | Quantidade de pagamentos em atraso | Maior representatividade ≈ 8,6% |
Changed_Credit_Limit | Alteração percentual do limite de crédito | Pouco relevante isoladamente, útil em feature engineering |
Num_Credit_Inquiries | Número de consultas de crédito | Equilibrado, maior frequência ≈ 11,5% |
Credit_Mix | Composição de créditos | Balanceado, maior representatividade ≈ 36,5% |
Outstanding_Debt | Dívida pendente (USD) | Pouco útil isoladamente, mas explorável via feature engineering |
Credit_Utilization_Ratio | Taxa de utilização do crédito | Útil se agrupada em faixas ou transformada em variáveis derivadas (feature engineering) |
Credit_History_Age | Tempo de histórico de crédito | Dados inconsistentes, mas pode ser transformado em meses/anos (feature engineering) |
Payment_of_Min_Amount | Indica se paga apenas o mínimo | Distribuição clara, maior representatividade ≈ 52,3% |
Total_EMI_per_month_Ajustado | Valor total de pagamentos mensais de EMI (USD) | Útil após normalização ou criação de faixas (feature engineering) |
Amount_invested_monthly | Valor investido mensalmente (USD) | Pode ser agregado em categorias ou usado em índices relativos (feature engineering) |
Payment_Behaviour | Comportamento de pagamento | Destaque para 25,5% dos registros |
Monthly_Balance | Saldo mensal (USD) | Pode ser transformado em faixas ou indicadores derivados (feature engineering) |
Credit_Score | Faixa de pontuação (Poor, Standard, Good) | Distribuição equilibrada, maior representatividade ≈ 53,2% |
Tipagem das colunas¶
O dataset é composto por apenas três tipos de dados: Object, Float64 e Int64:
- Object(20):
ID,Customer_ID,Month,Name,Age,SSN,Occupation,Annual_Income,Num_of_Loan,Type_of_Loan,Num_of_Delayed_Payment,Changed_Credit_Limit,Outstanding_Debt,Credit_History_Age,Payment_of_Min_Amount,Amount_invested_monthly,Monthly_Balance,Payment_Behaviour,Credit_Score,Credit_Mix. - Float64(4):
Monthly_Inhand_Salary,Num_Credit_Inquiries,Credit_Utilization_Ratio,Total_EMI_per_month. - Int64(4):
Num_Bank_Accounts,Num_Credit_Card,Interest_Rate,Delay_from_due_date.
Variável Alvo¶
O modelo tem como variável alvo (target) a coluna Credit_Score, que representa a classificação de crédito dos clientes.
A distribuição da variável é a seguinte:
- Standard: 53.174 (53,2%)
- Poor: 28.998 (29,0%)
- Good: 17.828 (17,8%)
Essa distribuição evidencia um leve desbalanceamento de classes.
Amostra dos Dados¶
A seguir, um exemplo com 3 linhas de um total de 100.000 registros:
df.head(3)
| ID | Customer_ID | Month | Name | Age | SSN | Occupation | Annual_Income | Monthly_Inhand_Salary | Num_Bank_Accounts | ... | Credit_Mix | Outstanding_Debt | Credit_Utilization_Ratio | Credit_History_Age | Payment_of_Min_Amount | Total_EMI_per_month | Amount_invested_monthly | Payment_Behaviour | Monthly_Balance | Credit_Score | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0x1602 | CUS_0xd40 | January | Aaron Maashoh | 23 | 821-00-0265 | Scientist | 19114.12 | 1824.843333 | 3 | ... | _ | 809.98 | 26.822620 | 22 Years and 1 Months | No | 49.574949 | 80.41529543900253 | High_spent_Small_value_payments | 312.49408867943663 | Good |
| 1 | 0x1603 | CUS_0xd40 | February | Aaron Maashoh | 23 | 821-00-0265 | Scientist | 19114.12 | NaN | 3 | ... | Good | 809.98 | 31.944960 | NaN | No | 49.574949 | 118.28022162236736 | Low_spent_Large_value_payments | 284.62916249607184 | Good |
| 2 | 0x1604 | CUS_0xd40 | March | Aaron Maashoh | -500 | 821-00-0265 | Scientist | 19114.12 | NaN | 3 | ... | Good | 809.98 | 28.609352 | 22 Years and 3 Months | No | 49.574949 | 81.699521264648 | Low_spent_Medium_value_payments | 331.2098628537912 | Good |
3 rows × 28 columns
Pré-processamento¶
Nesta etapa foi realizada a limpeza dos dados e o tratamento de valores ausentes, além da adequação da tipagem das colunas para que estivessem compatíveis com o modelo.
Esse processo foi fundamental para garantir consistência e qualidade antes do treinamento da árvore de decisão.
Alteração de Tipagem dos Dados¶
Grande parte das colunas do dataset estavam no formato object.
O primeiro passo foi padronizar as tipagens, ajustando para float64, int64 e category, conforme a natureza de cada variável.
Apenas alteração de tipo¶
Variáveis que puderam ser convertidas diretamente com astype() no Pandas:
df['ID'] = df['ID'].astype('string')
df['Customer_ID'] = df['Customer_ID'].astype('string')
df['Month'] = df['Month'].astype('string')
df['Name'] = df['Name'].astype('string')
df['SSN'] = df['SSN'].astype('string')
df['Occupation'] = df['Occupation'].astype('string')
df['Type_of_Loan'] = df['Type_of_Loan'].astype('string')
df['Payment_Behaviour'] = df['Payment_Behaviour'].astype('string')
df['Payment_of_Min_Amount'] = df['Payment_of_Min_Amount'].astype('string')
df['Credit_Utilization_Ratio'] = df['Credit_Utilization_Ratio'].astype('float')
df['Credit_Score'] = df['Credit_Score'].astype('category')
Necessidade de limpeza antes da conversão¶
Colunas que apresentavam valores inválidos (ex.: '_') e precisaram de tratamento prévio:
df['Age'] = df['Age'].str.replace('_', '').astype('int')
df['Annual_Income'] = df['Annual_Income'].str.replace('_', '').astype('float')
df['Num_of_Loan'] = df['Num_of_Loan'].str.replace('_', '').astype('int')
df['Outstanding_Debt'] = df['Outstanding_Debt'].str.replace('_', '').astype('float')
df['Amount_invested_monthly'] = df['Amount_invested_monthly'].str.replace('_', '').astype('float')
df['Monthly_Balance'] = df['Monthly_Balance'].str.replace('_', '').astype('float')
df['Num_of_Delayed_Payment'] = df['Num_of_Delayed_Payment'].str.replace('_', '').astype('float').fillna(0).astype('int')
df['Changed_Credit_Limit'] = df['Changed_Credit_Limit'].str.replace('_', '0').astype('float').fillna(0)
df['Credit_Mix'] = df['Credit_Mix'].str.replace('_', 'Não informado').astype('string')
df['Credit_History_Age'] = df['Credit_History_Age'].fillna('Não informado').astype('string')
Feature engineering (transformação em categorias)¶
Variáveis com grande dispersão foram agrupadas em faixas de valores para reduzir ruído e melhorar a identificação de padrões:
Filtragem de registros inconsistentes (valores fora de faixa):
df = df.loc[(df['Num_Bank_Accounts'] > 0) & (df['Num_Bank_Accounts'] <= 10)]
df = df.loc[(df['Age'] >= 0) & (df['Age'] <= 120)]
df = df.loc[(df['Num_Credit_Card'] > 0) & (df['Num_Credit_Card'] <= 10)]
df = df.loc[df['Interest_Rate'] <= 30]
df = df.loc[(df['Num_of_Loan'] >= 0) & (df['Num_of_Loan'] <= 10)]
df = df.loc[df['Delay_from_due_date'] >= 0]
df = df.loc[(df['Num_of_Delayed_Payment'] >= 0) & (df['Num_of_Delayed_Payment'] <= 25)]
df = df.loc[df['Num_Credit_Inquiries'] <= 12]
Criação de variáveis categorizadas a partir de faixas:
bins = [0 * 12, 2500 * 12, 4000 * 12, 6000 * 12, 10000 * 12, float('inf')]
labels = ['low', 'lower_middle', 'middle', 'upper_middle', 'high']
df['Annual_Income_Ajustado'] = pd.cut(df['Annual_Income'], bins=bins, labels=labels)
bins = [-1, 10, 30, 50, 75, 100, float('inf')]
labels = ['muito_baixo', 'baixo', 'moderado', 'alto', 'muito_alto', 'estourado']
df['Credit_Utilization_Ratio_Ajustado'] = pd.cut(df['Credit_Utilization_Ratio'], bins=bins, labels=labels)
bins = [0, 2500, 4000, 6000, 10000, float('inf')]
labels = ['low', 'lower_middle', 'middle', 'upper_middle', 'high']
df['Monthly_Inhand_Salary_Ajustado'] = pd.cut(df['Monthly_Inhand_Salary'], bins=bins, labels=labels)
bins = [0, 12, 19, 35, 55, 75, float('inf')]
labels = ['crianca', 'adolescente', 'jovem_adulto', 'adulto', 'meia_idade', 'idoso']
df['Age_Ajustado'] = pd.cut(df['Age'], bins=bins, labels=labels)
df['years'] = df['Credit_History_Age'].str.extract(r'(\d+)\s*Years')
df['months'] = df['Credit_History_Age'].str.extract(r'(\d+)\s*Months')
df['years'] = pd.to_numeric(df['years'], errors='coerce').fillna(0).astype(int)
df['months'] = pd.to_numeric(df['months'], errors='coerce').fillna(0).astype(int)
df['Credit_History_Age_Ajustado'] = df['years'] * 12 + df['months']
bins = [0, 500, 1500, 3000, 5000, float('inf')]
labels = ['muito_baixo', 'baixo', 'medio', 'alto', 'muito_alto']
df['Total_EMI_per_month_Ajustado'] = pd.cut(df['Total_EMI_per_month'], bins=bins, labels=labels)
bins = [0, 1000, 10000, 50000, 250000, float('inf')]
labels = ['very_low', 'low', 'medium', 'high', 'very_high']
df['Amount_invested_monthly_Ajustado'] = pd.cut(df['Amount_invested_monthly'], bins=bins, labels=labels)
bins = [-float('inf'), 0, 1000, 5000, 20000, float('inf')]
labels = ['negative', 'low', 'moderate', 'high', 'very_high']
df['Monthly_Balance_Ajustado'] = pd.cut(df['Monthly_Balance'], bins=bins, labels=labels)
Remoção de registros inválidos:
indices_para_remover = df[df["Occupation"].str.contains("_", na=False)].index
df.drop(index=indices_para_remover, inplace=True)
indices_para_remover = df[df["Credit_Mix"].str.contains("Não informado", na=False)].index
df.drop(index=indices_para_remover, inplace=True)
indices_para_remover = df[df["Payment_of_Min_Amount"].str.contains("NM", na=False)].index
df.drop(index=indices_para_remover, inplace=True)
indices_para_remover = df[df["Payment_Behaviour"].str.contains("!@9#%8", na=False)].index
df.drop(index=indices_para_remover, inplace=True)
Conversão final para variáveis categóricas:
df['Occupation'] = df['Occupation'].astype('category')
df['Credit_Mix'] = df['Credit_Mix'].astype('category')
df['Payment_of_Min_Amount'] = df['Payment_of_Min_Amount'].astype('category')
df['Payment_Behaviour'] = df['Payment_Behaviour'].astype('category')
df['Annual_Income_Ajustado'] = df['Annual_Income_Ajustado'].astype('category')
df['Age_Ajustado'] = df['Age_Ajustado'].astype('category')
df['Monthly_Inhand_Salary_Ajustado'] = df['Monthly_Inhand_Salary_Ajustado'].astype('category')
df['Credit_History_Age_Ajustado'] = df['Credit_History_Age_Ajustado'].astype('category')
df['Amount_invested_monthly_Ajustado'] = df['Amount_invested_monthly_Ajustado'].astype('category')
df['Monthly_Balance_Ajustado'] = df['Monthly_Balance_Ajustado'].astype('category')
df['Credit_Utilization_Ratio_Ajustado'] = df['Credit_Utilization_Ratio_Ajustado'].astype('category')
df['Total_EMI_per_month_Ajustado'] = df['Total_EMI_per_month_Ajustado'].astype('category')
Colunas Retiradas do Modelo¶
Durante o processo de preparação dos dados, algumas variáveis foram consideradas irrelevantes ou inadequadas para a análise de risco. A exclusão foi feita para reduzir ruído, melhorar a qualidade das features e aumentar a robustez preditiva do modelo.
As remoções ocorreram pelos seguintes motivos:
ID,Customer_ID,Name,SSN
Identificadores únicos que não possuem valor preditivo, apenas acrescentando variabilidade desnecessária.Month
A variável não apresentou relação consistente com a pontuação de crédito, sendo descartada por falta de interpretabilidade.Type_of_Loan
Apresentou registros inconsistentes, com baixa padronização dos valores, dificultando a extração de informação relevante.Credit_History_Age,Monthly_Balance,Amount_invested_monthly,Age,Monthly_Inhand_Salary,Annual_Income,Credit_Utilization_Ratio,Total_EMI_per_month
Apesar de importantes, essas variáveis possuíam valores ruidosos ou dispersos em sua forma original.
Foram reaproveitadas por meio de feature engineering, originando versões ajustadas e mais informativas.
Remoção de colunas:
df = df.drop(['ID', 'Customer_ID', 'Month', 'Name', 'SSN', 'Type_of_Loan', 'Credit_History_Age',
'Monthly_Balance', 'Amount_invested_monthly', 'Age', 'Monthly_Inhand_Salary', 'Annual_Income', 'months', 'years', 'Credit_Utilization_Ratio', 'Total_EMI_per_month'], axis=1)
Colunas Utilizadas no Modelo¶
Após os ajustes, foram mantidas 21 colunas efetivas para a modelagem. A variável alvo (Credit_Score) foi separada do conjunto de preditores.
Float64 (3):
Num_Credit_Inquiries,Changed_Credit_Limit,Outstanding_Debt.Int64 (6):
Num_Bank_Accounts,Num_Credit_Card,Interest_Rate,Delay_from_due_date,Num_of_Loan,Num_of_Delayed_Payment.Category (12):
Credit_History_Age_Ajustado,Monthly_Balance_Ajustado,Amount_invested_monthly_Ajustado,Age_Ajustado,Monthly_Inhand_Salary,Annual_Income,Occupation,Credit_Mix,Payment_of_Min_Amount,Payment_Behaviour,Monthly_Inhand_Salary_Ajustado,Total_EMI_per_month_Ajustado
Linhas Retiradas do Modelo¶
Foram removidas 71.635 linhas que continham valores nulos ou nulos lógicos, resultando em 28.365 registros disponíveis para o treinamento do modelo.
Variável Alvo Após a Limpeza¶
- Standard: 22.436
- Poor: 10.370
- Good: 7.049
Remoção de linhas com informações nulas e reset de index:
df = df.dropna()
df = df.reset_index(drop=True)
label_encoder = LabelEncoder()
# aplicar label encoder na target
df['Credit_Score'] = label_encoder.fit_transform(df['Credit_Score'])
# todas as colunas menos o target
x = df.drop("Credit_Score", axis=1)
# aplicar label encoder nas categóricas
x['Occupation'] = label_encoder.fit_transform(x['Occupation'])
x['Credit_Mix'] = label_encoder.fit_transform(x['Credit_Mix'])
x['Payment_of_Min_Amount'] = label_encoder.fit_transform(x['Payment_of_Min_Amount'])
x['Payment_Behaviour'] = label_encoder.fit_transform(x['Payment_Behaviour'])
x['Age_Ajustado'] = label_encoder.fit_transform(x['Age_Ajustado'])
x['Annual_Income_Ajustado'] = label_encoder.fit_transform(x['Annual_Income_Ajustado'])
x['Monthly_Inhand_Salary_Ajustado'] = label_encoder.fit_transform(x['Monthly_Inhand_Salary_Ajustado'])
x['Credit_History_Age_Ajustado'] = label_encoder.fit_transform(x['Credit_History_Age_Ajustado'])
x['Amount_invested_monthly_Ajustado'] = label_encoder.fit_transform(x['Amount_invested_monthly_Ajustado'])
x['Monthly_Balance_Ajustado'] = label_encoder.fit_transform(x['Monthly_Balance_Ajustado'])
x['Credit_Utilization_Ratio_Ajustado'] = label_encoder.fit_transform(x['Credit_Utilization_Ratio_Ajustado'])
x['Total_EMI_per_month_Ajustado'] = label_encoder.fit_transform(x['Total_EMI_per_month_Ajustado'])
# apenas a target
y = df["Credit_Score"]
# dividir os dados em conjuntos de treinamento e teste
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=42)
# criar e treinar o modelo de árvore de decisão
classifier = tree.DecisionTreeClassifier()
classifier.fit(x_train, y_train)
y_pred = classifier.predict(x_test)
cm = metrics.confusion_matrix(y_test, y_pred)
disp = metrics.ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[0,1,2])
disp.plot(cmap="Blues")
# avaliar o modelo
accuracy = classifier.score(x_test, y_test)
print(metrics.classification_report(y_test, y_pred, digits=4))
print(f"Accuracy: {accuracy:.2f}")
# plots
feature_importances = classifier.feature_importances_
df_importances = pd.DataFrame({
"Variável": x.columns,
"Importância": feature_importances
}).sort_values(by="Importância", ascending=False)
print("\n Importância das Variáveis (ordenadas):")
print(df_importances.to_string(index=False))
precision recall f1-score support
0 0.5611 0.5623 0.5617 1405
1 0.6554 0.6751 0.6651 2327
2 0.7505 0.7390 0.7447 4778
accuracy 0.6924 8510
macro avg 0.6557 0.6588 0.6572 8510
weighted avg 0.6932 0.6924 0.6927 8510
Accuracy: 0.69
Importância das Variáveis (ordenadas):
Variável Importância
Outstanding_Debt 0.196902
Credit_Mix 0.124525
Credit_History_Age_Ajustado 0.097758
Delay_from_due_date 0.086452
Changed_Credit_Limit 0.085693
Interest_Rate 0.071320
Num_of_Delayed_Payment 0.054128
Occupation 0.040771
Payment_Behaviour 0.039438
Num_Credit_Card 0.036170
Num_Credit_Inquiries 0.035878
Num_of_Loan 0.031124
Num_Bank_Accounts 0.029161
Credit_Utilization_Ratio_Ajustado 0.014277
Age_Ajustado 0.013786
Annual_Income_Ajustado 0.012556
Monthly_Inhand_Salary_Ajustado 0.010456
Total_EMI_per_month_Ajustado 0.010184
Amount_invested_monthly_Ajustado 0.005826
Monthly_Balance_Ajustado 0.001802
Payment_of_Min_Amount 0.001794
Avaliação do Modelo¶
Desempenho Geral¶
O modelo obteve uma acurácia de aproximadamente 69%, o que indica uma performance razoável para um problema de classificação em três classes.
- Macro avg F1-score: 0.6591 → equilíbrio médio entre as classes, mas com variação de desempenho.
- Weighted avg F1-score: 0.6949 → indica que, considerando o peso proporcional das classes, o modelo se comporta de forma consistente com a acurácia.
Desempenho por Classe¶
Classe 0 (score mais baixo)
- Precision: 0.5632
- Recall: 0.5616
- F1-score: 0.5624
- Observação: desempenho limitado; dificuldade do modelo em identificar corretamente instâncias dessa classe.
Classe 1 (score intermediário)
- Precision: 0.6606
- Recall: 0.6751
- F1-score: 0.6678
- Observação: resultado equilibrado e consistente, embora ainda com margem para melhorar recall.
Classe 2 (score mais alto)
- Precision: 0.7508
- Recall: 0.7434
- F1-score: 0.7471
- Observação: melhor desempenho entre as classes, indicando que o modelo consegue distinguir bem essa categoria.
Importância das Variáveis¶
As variáveis mais relevantes para a árvore de decisão foram:
- Outstanding_Debt (0.2013)
- Credit_Mix (0.1243)
- Credit_History_Age_Ajustado (0.0994)
- Changed_Credit_Limit (0.0849)
- Delay_from_due_date (0.0831)
- Interest_Rate (0.0723)
Esses resultados sugerem que endividamento, composição de crédito e histórico de crédito são os principais determinantes na classificação do score de crédito. Variáveis como Payment_of_Min_Amount e Monthly_Balance_Ajustado tiveram relevância mínima, quase desprezível.
Matriz de Confusão¶
A matriz de confusão mostra:
- Classe 0: muitos casos classificados incorretamente como classe 2.
- Classe 1: apresenta melhor equilíbrio, mas ainda há confusão com classe 2.
- Classe 2: desempenho sólido, com a maior parte dos exemplos classificados corretamente.
Isso confirma que o modelo tem tendência a favorecer a classe 2, enquanto a classe 0 é a mais prejudicada em termos de recall.
Relatório Final¶
O projeto demonstrou a aplicação prática de árvores de decisão para classificar clientes em diferentes faixas de score de crédito, a partir de um conjunto de dados robusto e diversificado.
As etapas percorreram desde a exploração dos dados, passando pelo pré-processamento (limpeza, transformação e feature engineering), até o treinamento do modelo e a avaliação de desempenho.
Principais Achados¶
- O modelo atingiu uma acurácia de ~69%, com desempenho diferenciado entre as classes.
- As variáveis mais relevantes foram Outstanding_Debt, Credit_Mix, Credit_History_Age_Ajustado, Changed_Credit_Limit, Delay_from_due_date e Interest_Rate, reforçando a importância de fatores relacionados a endividamento, composição de crédito e histórico financeiro.
- Observou-se uma tendência do modelo a favorecer a classe de maior score (classe 2), enquanto a classe mais baixa apresentou maiores dificuldades de classificação, refletindo um desafio de desbalanceamento de classes.
Limitações Identificadas¶
- Exclusão de mais de 70% das linhas devido a valores nulos ou inconsistentes, reduzindo a representatividade da amostra.
- Ruído e dispersão em variáveis financeiras contínuas, exigindo maior esforço em feature engineering.
- Desequilíbrio nas classes de crédito, com predominância da categoria "Standard".
Possíveis Melhorias¶
Balanceamento de Classes
- Aplicar técnicas como SMOTE, RandomUnderSampler ou Class Weights para reduzir o viés da árvore de decisão.
Exploração de Modelos Mais Avançados
- Testar Random Forest ou Gradient Boosting (XGBoost, LightGBM, CatBoost), que geralmente superam a árvore de decisão simples em desempenho e generalização.
Feature Engineering Avançado
- Criar variáveis derivadas de faixas de renda, razão dívida/renda, índices de atraso acumulado, entre outras métricas financeiras.
Cross-Validation
- Implementar validação cruzada (K-Fold ou Stratified K-Fold) para obter uma avaliação mais robusta e reduzir o risco de overfitting.
Pipeline Automatizado
- Construir um pipeline de pré-processamento + modelagem no scikit-learn, garantindo maior reprodutibilidade e facilidade de ajustes futuros.
Conclusão¶
O estudo evidencia que as árvores de decisão podem ser úteis para segmentação de crédito, mas também ressalta os desafios práticos de qualidade dos dados e balanceamento de classes. A evolução do projeto deve caminhar em direção a modelos mais sofisticados, engenharia de variáveis financeiras e estratégias de validação robustas, a fim de aumentar a confiabilidade dos resultados e sua aplicabilidade em cenários reais de análise de risco de crédito.