Python para Risco de Crédito: Modelos e Avaliação
Python é uma ferramenta poderosa para análise de risco, permitindo desde a limpeza de dados até a construção de modelos preditivos e avaliação de performance. Neste artigo, exploraremos passo a passo como construir um sistema de risco de crédito em Python.
1. Etapas na Análise de Risco de Crédito
O processo típico de avaliação envolve:
Coleta de Dados – histórico de clientes, crédito e pagamentos.
Pré-processamento – tratamento de valores ausentes, codificação de variáveis e normalização.
Feature Engineering – criação de indicadores relevantes (ex.: idade, histórico de inadimplência, score de crédito).
Modelagem – uso de algoritmos estatísticos ou de machine learning para prever inadimplência.
Avaliação do Modelo – métricas como ROC-AUC, precisão, recall e matriz de confusão.
Monitoramento e Atualização – ajustar o modelo conforme mudanças no mercado e comportamento dos clientes.
2. Preparando o Ambiente
Instale as bibliotecas principais:
pip install pandas numpy scikit-learn matplotlib seaborn
pandas / numpy → manipulação e cálculo de dados.
scikit-learn → modelos de machine learning e métricas.
matplotlib / seaborn → visualização de dados.
3. Carregando e Explorando Dados
Para este exemplo, vamos utilizar o dataset “German Credit Data”, um clássico em risco de crédito.
import pandas as pd
url = "https://raw.githubusercontent.com/selva86/datasets/master/GermanCredit.csv"
df = pd.read_csv(url)
print(df.head())
print(df.info())
Este dataset possui variáveis como:
Age → idade do cliente
CreditAmount → valor do crédito solicitado
Duration → duração do empréstimo em meses
Purpose → finalidade do empréstimo
Risk → 1 = bom pagador, 2 = mau pagador
4. Pré-processamento de Dados
4.1 Lidando com valores ausentes
df.isnull().sum() # verificar missing values
Se houver valores faltantes, podemos imputar ou remover:
df = df.dropna() # neste caso simples, apenas removemos
4.2 Codificação de variáveis categóricas
df_encoded = pd.get_dummies(df, drop_first=True)
print(df_encoded.head())
4.3 Separando features e target
X = df_encoded.drop("Risk_2", axis=1) # 1 = bom pagador, 2 = mau pagador
y = df_encoded["Risk_2"]
5. Dividindo dados em treino e teste
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
6. Modelagem de Crédito
6.1 Regressão Logística
A regressão logística é amplamente utilizada em risco de crédito devido à interpretabilidade.
from sklearn.linear_model import LogisticRegression
modelo = LogisticRegression(max_iter=1000)
modelo.fit(X_train, y_train)
y_pred = modelo.predict(X_test)
6.2 Random Forest
Um modelo mais robusto e não linear:
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimators=200, random_state=42)
rf.fit(X_train, y_train)
y_pred_rf = rf.predict(X_test)
7. Avaliando o Modelo
7.1 Matriz de Confusão
from sklearn.metrics import confusion_matrix, classification_report
print("Regressão Logística")
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))
print("Random Forest")
print(confusion_matrix(y_test, y_pred_rf))
print(classification_report(y_test, y_pred_rf))
7.2 ROC-AUC
from sklearn.metrics import roc_auc_score, roc_curve
import matplotlib.pyplot as plt
# Probabilidades
y_prob = modelo.predict_proba(X_test)[:,1]
y_prob_rf = rf.predict_proba(X_test)[:,1]
# ROC Curves
fpr, tpr, _ = roc_curve(y_test, y_prob)
fpr_rf, tpr_rf, _ = roc_curve(y_test, y_prob_rf)
plt.figure(figsize=(8,6))
plt.plot(fpr, tpr, label="Logistic Regression")
plt.plot(fpr_rf, tpr_rf, label="Random Forest")
plt.plot([0,1],[0,1],"k--")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve - Risco de Crédito")
plt.legend()
plt.show()
print("ROC-AUC Logistic Regression:", round(roc_auc_score(y_test, y_prob), 3))
print("ROC-AUC Random Forest:", round(roc_auc_score(y_test, y_prob_rf), 3))
📌 Um modelo com ROC-AUC próximo de 1 é altamente preditivo.
8. Interpretação de Resultados
Regressão Logística → fornece coeficientes interpretáveis: podemos ver quais variáveis aumentam o risco de inadimplência.
Random Forest → boa performance para capturar relações não lineares.
Métricas importantes: precisão, recall, F1-score, ROC-AUC e matriz de confusão.
9. Feature Importance
Para identificar quais fatores influenciam mais o risco:
import seaborn as sns
importancia = pd.Series(rf.feature_importances_, index=X.columns).sort_values(ascending=False)
plt.figure(figsize=(10,6))
sns.barplot(x=importancia.values, y=importancia.index)
plt.title("Importância das Features - Random Forest")
plt.show()
📌 Isso ajuda a equipe de crédito a priorizar variáveis críticas.
10. Boas Práticas
Atualizar modelos periodicamente com novos dados.
Evitar viés de dados históricos (ex.: discriminação por idade, gênero).
Testar diferentes algoritmos e parâmetros.
Monitorar performance em produção e recalibrar scores.
Usar modelos explicáveis para decisões regulatórias.
11. Conclusão
Python permite construir sistemas robustos de avaliação de crédito que:
Automatizam análises de risco.
Auxiliam na decisão de concessão de empréstimos.
Reduzem inadimplência através de previsões mais precisas.
Neste artigo, cobrimos:
Pré-processamento de dados financeiros.
Modelos de regressão logística e Random Forest.
Avaliação com métricas clássicas (ROC-AUC, matriz de confusão, feature importance).
Boas práticas para monitoramento e atualização.
O uso de Python em risco de crédito transforma dados em insights estratégicos, aumentando a eficiência e segurança da tomada de decisão em instituições financeiras.
Comentários
Postar um comentário