Update app.py

app.py

@@ -18,18 +18,19 @@ import warnings
 # Configuração da Página
 st.set_page_config(page_title="CrediFast - Risco de Crédito", layout="wide", page_icon="💰")
 
-# Desativar avisos
+# Desativar avisos de depreciação do Pyplot e outros warnings
+st.set_option('deprecation.showPyplotGlobalUse', False) 
 warnings.filterwarnings('ignore')
 
 # Título e Cabeçalho
 st.title("💰 CrediFast: Sistema Inteligente de Risco de Crédito")
 st.markdown("---")
 
-# --- FUNÇÕES DE CACHE (Para performance) ---
+# --- FUNÇÕES DE CACHE (Para performance e estabilidade) ---
 
 @st.cache_data
 def carregar_dados():
-    # Carrega diretamente o arquivo local
+    # Tenta carregar o arquivo localmente
     try:
         df = pd.read_csv('credit_risk_dataset.csv')
         return df
@@ -46,7 +47,7 @@ def processar_dados(df):
     X = df.drop(columns=[target])
     y = df[target]
     
-    # 3. Tratamento de Nulos e Encoding
+    # 3. Tratamento de Nulos
     # Numéricas
     num_cols = X.select_dtypes(include=['number']).columns.tolist()
     imputer_num = SimpleImputer(strategy='median')
@@ -58,61 +59,58 @@ def processar_dados(df):
     
     return X, y, df # Retorna df original limpo para visualização
 
-# Renomeado para v2 para forçar o Streamlit a limpar o cache antigo e aplicar o fix do base_score
+# Usamos v4 no nome para garantir que o cache antigo seja invalidado
 @st.cache_resource
-def treinar_modelo_v2(X, y):
+def treinar_modelo_v4(X, y):
     # Split
     X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)
     
-    # SMOTE
+    # SMOTE (Apenas no treino)
     smote = SMOTE(random_state=42)
     X_train_bal, y_train_bal = smote.fit_resample(X_train, y_train)
     
-    # Scaling (necessário para Clusters, opcional para XGBoost mas bom para padronizar)
+    # Scaling
     scaler = StandardScaler()
     X_train_scaled = scaler.fit_transform(X_train_bal)
     X_test_scaled = scaler.transform(X_test)
     
-    # Recuperar nomes das colunas para interpretabilidade
+    # Recuperar nomes das colunas
     feature_names = X.columns.tolist()
     X_train_final = pd.DataFrame(X_train_scaled, columns=feature_names)
     X_test_final = pd.DataFrame(X_test_scaled, columns=feature_names)
     
     # Treinamento XGBoost
-    # FIX: base_score=0.5 ajuda a evitar o erro '[5E-1]' no SHAP com XGBoost novos
-    model = XGBClassifier(use_label_encoder=False, eval_metric='logloss', random_state=42, base_score=0.5)
+    # Definimos base_score=0.5 explicitamente para ajudar na compatibilidade com SHAP
+    model = XGBClassifier(
+        use_label_encoder=False, 
+        eval_metric='logloss', 
+        random_state=42,
+        base_score=0.5
+    )
     model.fit(X_train_final, y_train_bal)
     
-    # Garantia extra: forçar parametro no booster interno
-    try:
-        model.get_booster().set_param({'base_score': 0.5})
-    except:
-        pass
-    
     return model, scaler, X_test_final, y_test, X_train_final, feature_names
 
-# --- LOGICA PRINCIPAL ---
+# --- LÓGICA PRINCIPAL DO DASHBOARD ---
 
-# Tenta carregar os dados automaticamente
+# Tenta carregar os dados
 df_raw = carregar_dados()
 
 if df_raw is not None:
     # Processamento Automático
-    # Mostra um spinner enquanto carrega para o usuário saber que está trabalhando
     with st.spinner('Inicializando sistema: Processando dados e treinando IA...'):
         X, y, df_clean = processar_dados(df_raw)
-        # Chamando a função v2 para garantir que o fix seja usado
-        model, scaler, X_test, y_test, X_train, feature_names = treinar_modelo_v2(X, y)
+        model, scaler, X_test, y_test, X_train, feature_names = treinar_modelo_v4(X, y)
     
-    # --- SIDEBAR (Simulador) ---
+    # --- BARRA LATERAL (Simulador) ---
     st.sidebar.header("📂 Menu")
-    st.sidebar.success("✅ Modelo Carregado e Pronto")
+    st.sidebar.success("✅ Modelo Carregado")
     
     st.sidebar.markdown("---")
     st.sidebar.subheader("🎲 Simulador de Crédito")
     st.sidebar.info("Simule um perfil para ver a probabilidade de calote.")
     
-    # Inputs do Simulador (Principais features)
+    # Inputs do Simulador
     sim_income = st.sidebar.number_input("Renda Anual", value=50000)
     sim_age = st.sidebar.number_input("Idade", value=25)
     sim_loan = st.sidebar.number_input("Valor do Empréstimo", value=10000)
@@ -121,16 +119,18 @@ if df_raw is not None:
     
     # Botão Simular
     if st.sidebar.button("Calcular Risco"):
-        # Lógica simplificada de simulação
+        # Criação do dataframe de input
         input_data = pd.DataFrame(0, index=[0], columns=feature_names)
-        input_data['person_income'] = sim_income
-        input_data['person_age'] = sim_age
-        input_data['loan_amnt'] = sim_loan
-        input_data['loan_int_rate'] = sim_int_rate
-        input_data['person_emp_length'] = sim_emp_length
-        input_data['loan_percent_income'] = sim_loan / sim_income if sim_income > 0 else 0
+        # Preenchendo valores
+        if 'person_income' in input_data.columns: input_data['person_income'] = sim_income
+        if 'person_age' in input_data.columns: input_data['person_age'] = sim_age
+        if 'loan_amnt' in input_data.columns: input_data['loan_amnt'] = sim_loan
+        if 'loan_int_rate' in input_data.columns: input_data['loan_int_rate'] = sim_int_rate
+        if 'person_emp_length' in input_data.columns: input_data['person_emp_length'] = sim_emp_length
+        if 'loan_percent_income' in input_data.columns: 
+            input_data['loan_percent_income'] = sim_loan / sim_income if sim_income > 0 else 0
         
-        # Escalonar
+        # Escalonar e Prever
         input_scaled = scaler.transform(input_data)
         prob = model.predict_proba(input_scaled)[0][1]
         
@@ -139,13 +139,13 @@ if df_raw is not None:
         else:
             st.sidebar.success(f"🟢 Aprovado: {prob:.1%} de chance de Default")
 
-    # --- TABS DO DASHBOARD ---
+    # --- ABAS ---
     tab1, tab2, tab3, tab4, tab5 = st.tabs([
         "📊 Diagnóstico", 
-        "🤖 Performance do Modelo", 
+        "🤖 Performance", 
         "🧠 Explicabilidade (SHAP)", 
-        "🧩 Segmentação (Clusters)", 
-        "📝 Relatório Gerencial"
+        "🧩 Segmentação", 
+        "📝 Relatório"
     ])
     
     # TAB 1: Diagnóstico
@@ -158,88 +158,95 @@ if df_raw is not None:
             fig_pie = px.pie(names=['Good (0)', 'Bad (1)'], 
                              values=y.value_counts().values,
                              color_discrete_sequence=['blue', 'red'])
-            st.plotly_chart(fig_pie, width="stretch")
+            st.plotly_chart(fig_pie, use_container_width=True) # Versão antiga compatível
             
         with col2:
-            st.markdown("**Distribuição de Renda vs Empréstimo**")
+            st.markdown("**Distribuição: Renda vs Empréstimo**")
             fig_scatter = px.scatter(df_clean.head(1000), x='person_income', y='loan_amnt', 
                                      color=y.head(1000).astype(str),
                                      color_discrete_map={'0': 'blue', '1': 'red'},
                                      title="Amostra de 1000 clientes")
-            st.plotly_chart(fig_scatter, width="stretch")
+            st.plotly_chart(fig_scatter, use_container_width=True)
             
-        st.warning("Nota: Foi aplicado SMOTE (Balanceamento) nos dados de treino para corrigir a desproporção vista acima.")
+        st.warning("Nota: Foi aplicado SMOTE (Balanceamento) nos dados de treino.")
 
     # TAB 2: Performance
     with tab2:
-        st.subheader("Avaliação do Modelo Vencedor (XGBoost)")
+        st.subheader("Performance do Modelo (XGBoost)")
         
         y_pred = model.predict(X_test)
         y_proba = model.predict_proba(X_test)[:, 1]
         
-        m1, m2, m3, m4 = st.columns(4)
-        m1.metric("AUC Score", f"{roc_auc_score(y_test, y_proba):.3f}")
-        m2.metric("Recall (Segurança)", f"{recall_score(y_test, y_pred):.3f}")
-        m3.metric("Precisão", f"{precision_score(y_test, y_pred):.3f}")
-        m4.metric("Acurácia", f"{accuracy_score(y_test, y_pred):.3f}")
+        c1, c2, c3, c4 = st.columns(4)
+        c1.metric("AUC Score", f"{roc_auc_score(y_test, y_proba):.3f}")
+        c2.metric("Recall (Segurança)", f"{recall_score(y_test, y_pred):.3f}")
+        c3.metric("Precisão", f"{precision_score(y_test, y_pred):.3f}")
+        c4.metric("Acurácia", f"{accuracy_score(y_test, y_pred):.3f}")
         
         st.markdown("### Matriz de Confusão")
         cm = confusion_matrix(y_test, y_pred)
         fig_cm = px.imshow(cm, text_auto=True, color_continuous_scale='Blues',
                            labels=dict(x="Predito", y="Real", color="Qtd"),
                            x=['Good', 'Bad'], y=['Good', 'Bad'])
-        st.plotly_chart(fig_cm)
+        st.plotly_chart(fig_cm, use_container_width=True)
 
-    # TAB 3: SHAP
+    # TAB 3: SHAP (Com Correção de Erro)
     with tab3:
-        st.subheader("Por que o modelo toma essas decisões?")
+        st.subheader("Interpretabilidade do Modelo")
         
         try:
-            # Calcular SHAP
-            # TENTATIVA 1: Explainer Padrão
+            # Tenta criar o explainer padrão
             explainer = shap.TreeExplainer(model)
             shap_values = explainer.shap_values(X_test)
+            
+            st.markdown("**1. Impacto Global das Variáveis**")
+            
+            # Matplotlib Figure explícita para evitar warnings
+            fig, ax = plt.subplots()
+            shap.summary_plot(shap_values, X_test, show=False)
+            st.pyplot(fig)
+            plt.clf() # Limpar figura
+            
+            st.markdown("---")
+            st.markdown("**2. Análise Local (Waterfall)**")
+            
+            idx = st.number_input("ID do Cliente para auditar:", 0, len(X_test)-1, 0)
+            
+            real_txt = 'Bad' if y_test.iloc[idx] == 1 else 'Good'
+            pred_txt = 'Bad' if y_pred[idx] == 1 else 'Good'
+            st.info(f"Cliente {idx}: Real = {real_txt} | Predito = {pred_txt}")
+            
+            fig_waterfall = plt.figure()
+            shap.plots.waterfall(shap.Explanation(values=shap_values[idx], 
+                                                  base_values=explainer.expected_value, 
+                                                  data=X_test.iloc[idx],
+                                                  feature_names=X_test.columns.tolist()),
+                                 max_display=10, show=False)
+            st.pyplot(fig_waterfall)
+            plt.clf()
+
         except Exception as e:
-            # TENTATIVA 2: Fallback para erro de versão XGBoost/SHAP
+            # Fallback para o erro de versão XGBoost/SHAP
             if "could not convert string to float" in str(e):
-                st.warning("🔄 Ajustando compatibilidade do SHAP... (Isso é normal em versões novas)")
-                # Usa o booster interno diretamente, ignorando o wrapper sklearn que causa o erro
-                explainer = shap.TreeExplainer(model.get_booster())
-                shap_values = explainer.shap_values(X_test)
+                st.warning("⚠️ Ajustando visualização SHAP (Modo de Compatibilidade)...")
+                try:
+                    # Usa o booster interno
+                    explainer = shap.TreeExplainer(model.get_booster())
+                    shap_values = explainer.shap_values(X_test)
+                    
+                    fig, ax = plt.subplots()
+                    shap.summary_plot(shap_values, X_test, show=False)
+                    st.pyplot(fig)
+                except:
+                    st.error("Não foi possível gerar os gráficos SHAP devido a incompatibilidade de versão.")
             else:
-                raise e
-            
-        st.markdown("**1. Visão Global (Quais variáveis importam mais?)**")
-        # Correção para exibir o gráfico sem warning: criar figura explícita e passar para st.pyplot
-        fig_summary, ax = plt.subplots()
-        shap.summary_plot(shap_values, X_test, show=False)
-        st.pyplot(plt.gcf())
-        plt.clf() # Limpar figura atual
-        
-        st.markdown("---")
-        st.markdown("**2. Visão Local (Análise caso a caso)**")
-        
-        # Seletor de índice
-        idx = st.number_input("Selecione o ID do Cliente para auditar:", min_value=0, max_value=len(X_test)-1, value=0)
-        
-        real_val = y_test.iloc[idx]
-        pred_val = y_pred[idx]
-        st.write(f"Cliente ID {idx} | Real: {'Bad' if real_val==1 else 'Good'} | Predito: {'Bad' if pred_val==1 else 'Good'}")
-        
-        # Waterfall Plot
-        fig_waterfall = plt.figure()
-        shap.plots.waterfall(shap.Explanation(values=shap_values[idx], 
-                                                base_values=explainer.expected_value, 
-                                                data=X_test.iloc[idx],
-                                                feature_names=X_test.columns.tolist()),
-                                max_display=10, show=False)
-        st.pyplot(fig_waterfall)
+                st.error(f"Erro ao calcular SHAP: {e}")
 
     # TAB 4: Clusters
     with tab4:
-        st.subheader("Segmentação de Clientes (KMeans & PCA)")
+        st.subheader("Segmentação (KMeans & DBSCAN)")
         
-        with st.spinner("Gerando Clusters..."):
+        with st.spinner("Calculando clusters..."):
             # KMeans
             kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
             clusters = kmeans.fit_predict(X_test)
@@ -248,7 +255,7 @@ if df_raw is not None:
             dbscan = DBSCAN(eps=3.0, min_samples=5)
             outliers = dbscan.fit_predict(X_test)
             
-            # PCA
+            # PCA 2D
             pca = PCA(n_components=2)
             components = pca.fit_transform(X_test)
             
@@ -258,42 +265,35 @@ if df_raw is not None:
             df_viz['Status Real'] = y_test.values
             df_viz['Status Real'] = df_viz['Status Real'].map({0: 'Good', 1: 'Bad'})
             
-            # Plot
             fig_cluster = px.scatter(df_viz, x='PC1', y='PC2', color='Cluster',
                                      symbol='Status Real',
                                      title="Mapa de Segmentação de Risco",
                                      color_discrete_sequence=px.colors.qualitative.Safe)
-            st.plotly_chart(fig_cluster, width="stretch")
+            st.plotly_chart(fig_cluster, use_container_width=True)
             
-            st.markdown("#### Detecção de Anomalias (Outliers)")
-            st.info(f"O algoritmo DBSCAN detectou {sum(outliers == -1)} casos anômalos que requerem revisão manual.")
+            num_outliers = sum(outliers == -1)
+            st.error(f"🚨 **DBSCAN:** Foram detectadas {num_outliers} anomalias (Outliers) que exigem revisão manual.")
 
-    # TAB 5: Recomendações
+    # TAB 5: Relatório
     with tab5:
-        st.subheader("📋 Relatório Gerencial e Estratégia")
-        
+        st.subheader("📋 Relatório Gerencial")
         st.markdown("""
-        ### 1. Diagnóstico do Modelo
-        O modelo **XGBoost** foi selecionado como o mais robusto. Priorizamos o **Recall** para minimizar perdas financeiras (falsos negativos), mantendo uma precisão operacionalmente viável.
-
-        ### 2. Fatores Críticos (SHAP)
-        * **Comprometimento de Renda (`loan_percent_income`):** É o maior preditor de risco. Clientes comprometendo >30% da renda disparam alarmes.
-        * **Histórico (`cb_person_default_on_file`):** Inadimplência prévia é determinante.
-        * **Taxa de Juros (`loan_int_rate`):** Juros abusivos correlacionam com maior inadimplência (seleção adversa).
-
-        ### 3. Plano de Ação (Recomendações)
+        ### Diagnóstico & Estratégia
         
-        | Ação | Descrição | Impacto Esperado |
-        | :--- | :--- | :--- |
-        | **Travas de Segurança** | Bloquear empréstimos onde parcela > 30% da renda sem garantia real. | Redução drástica de Default. |
-        | **Mesa de Crédito** | Clientes do **Cluster de Risco** ou com histórico negativo vão para análise humana. | Melhoria na qualidade da carteira. |
-        | **Juros Inteligentes** | Evitar taxas predatórias que forçam o calote; focar em crédito sustentável. | Aumento do LTV (Lifetime Value). |
+        1. **Modelo Selecionado:** XGBoost (Foco em Recall).
+           - Identifica a maioria dos inadimplentes, protegendo o capital da CrediFast.
         
-        ---
-        *Relatório gerado automaticamente pelo Sistema CrediFast AI.*
+        2. **Fatores de Risco (SHAP):**
+           - **Renda Comprometida:** >30% é crítico.
+           - **Histórico Negativo:** Maior preditor isolado.
+           - **Juros:** Taxas muito altas atraem maus pagadores.
+           
+        3. **Plano de Ação:**
+           - [x] Implementar trava automática para parcela > 30% da renda.
+           - [x] Criar esteira de aprovação manual para o **Cluster de Risco**.
+           - [x] Revisar política de juros para clientes 'Good' para aumentar retenção.
         """)
 
 else:
-    # Caso o arquivo não seja encontrado
-    st.error("🚨 Arquivo `credit_risk_dataset.csv` não encontrado no diretório.")
-    st.info("Por favor, adicione o arquivo csv na aba 'Files' do Hugging Face Spaces junto com este app.py.")
+    st.error("🚨 Arquivo `credit_risk_dataset.csv` não encontrado.")
+    st.info("Por favor, certifique-se de que o arquivo CSV está na mesma pasta (Files) do Hugging Face.")