Upload 3 files

app.py

@@ -0,0 +1,246 @@
+import streamlit as st
+import pandas as pd
+import joblib
+import matplotlib.pyplot as plt
+import seaborn as sns
+import shap
+import numpy as np
+
+# --- CONFIGURAÇÃO DA PÁGINA ---
+st.set_page_config(page_title="CrediFast Risk System", layout="wide")
+
+st.title("🏦 CrediFast: Sistema Multi-Modelo de Risco")
+st.markdown("""
+Este painel permite comparar a decisão de diferentes famílias de algoritmos de Machine Learning,
+desde métodos clássicos baseados em distância até redes neurais.
+""")
+
+# --- CARREGAMENTO DOS DADOS E MODELOS ---
+@st.cache_data
+def load_data():
+    return pd.read_csv("dados_credito_clean.csv")
+
+@st.cache_resource
+def load_models():
+    # Carrega o dicionário salvo no passo anterior
+    return joblib.load("todos_modelos.pkl")
+
+try:
+    df = load_data()
+    models_dict = load_models()
+except FileNotFoundError:
+    st.error("Erro Crítico: Arquivos 'dados_credito_clean.csv' ou 'todos_modelos.pkl' não encontrados. Por favor, faça o upload no menu 'Files'.")
+    st.stop()
+
+# --- BARRA LATERAL (CONFIGURAÇÃO HIERÁRQUICA) ---
+st.sidebar.header("⚙️ Configuração da Simulação")
+
+# 1. DEFINIÇÃO DA TAXONOMIA (Categorias)
+# Mapeia quais modelos pertencem a qual categoria
+taxonomia = {
+    "Métodos de Boosting (SOTA)": ["LightGBM (Campeão)", "XGBoost", "Gradient Boosting", "AdaBoost"],
+    "Árvores e Bagging": ["Random Forest", "Decision Tree"],
+    "Modelos Baseados em Distância": ["KNN", "SVM"],
+    "Redes Neurais": ["MPL (Rede Neural)"]
+}
+
+# 2. SELEÇÃO DE CATEGORIA
+categoria_selecionada = st.sidebar.selectbox("1º Escolha a Família do Algoritmo:", list(taxonomia.keys()))
+
+# 3. FILTRAGEM DE MODELOS DISPONÍVEIS
+# Verifica quais modelos dessa categoria realmente existem no arquivo .pkl carregado
+modelos_disponiveis = [m for m in taxonomia[categoria_selecionada] if m in models_dict]
+
+if not modelos_disponiveis:
+    st.sidebar.error(f"Nenhum modelo da categoria '{categoria_selecionada}' foi encontrado no arquivo carregado.")
+    st.stop()
+
+# 4. SELEÇÃO FINAL DO MODELO
+model_name = st.sidebar.selectbox("2º Escolha o Modelo Específico:", modelos_disponiveis)
+current_model = models_dict[model_name]
+
+st.sidebar.markdown(f"**Modelo Ativo:** `{model_name}`")
+st.sidebar.markdown("---")
+
+# --- FORMULÁRIO DE INPUT DO UTILIZADOR ---
+st.sidebar.header("📝 Perfil do Cliente")
+
+def user_input_features():
+    # Inputs numéricos
+    income = st.sidebar.number_input("Renda Anual (R$)", min_value=4000, max_value=2000000, value=65000, step=1000)
+    age = st.sidebar.number_input("Idade", min_value=18, max_value=80, value=25)
+    emp_length = st.sidebar.number_input("Tempo de Emprego (Anos)", min_value=0.0, max_value=60.0, value=2.0)
+    loan_amnt = st.sidebar.number_input("Valor do Empréstimo (R$)", min_value=1000, max_value=35000, value=15000, step=500)
+    int_rate = st.sidebar.slider("Taxa de Juros (%)", 5.0, 25.0, 11.0, step=0.1)
+    
+    percent_income = loan_amnt / income
+    
+    # Inputs categóricos
+    home_ownership = st.sidebar.selectbox("Tipo de Moradia", ["ALUGUEL (RENT)", "PRÓPRIA (OWN)", "FINANCIADA (MORTGAGE)", "OUTROS"])
+    loan_intent = st.sidebar.selectbox("Motivo", ["PESSOAL", "EDUCAÇÃO", "MÉDICO", "VENTURE", "REFORMA", "CONSOLIDAÇÃO DÍVIDA"])
+    loan_grade = st.sidebar.selectbox("Grade de Risco", ["A", "B", "C", "D", "E", "F", "G"])
+    cb_default = st.sidebar.selectbox("Já teve calote?", ["Não (N)", "Sim (Y)"])
+    
+    # Dicionário bruto
+    data = {
+        'person_age': age,
+        'person_income': income,
+        'person_emp_length': emp_length,
+        'loan_amnt': loan_amnt,
+        'loan_int_rate': int_rate,
+        'loan_percent_income': percent_income,
+        'cb_person_cred_hist_length': max(2, int(age - 20))
+    }
+    
+    # --- PREPARAÇÃO DAS COLUNAS (DUMMIES) ---
+    # Tenta descobrir as colunas que o modelo espera
+    try:
+        if hasattr(current_model, "feature_names_in_"):
+            model_cols = current_model.feature_names_in_
+        elif hasattr(current_model, "feature_name_"):
+            model_cols = current_model.feature_name_
+        else:
+            # Fallback manual caso o modelo não tenha metadados de colunas (comum em versões antigas do sklearn)
+            model_cols = ['person_age', 'person_income', 'person_emp_length', 'loan_amnt', 
+                          'loan_int_rate', 'loan_percent_income', 'cb_person_cred_hist_length',
+                          'person_home_ownership_MORTGAGE', 'person_home_ownership_OTHER', 
+                          'person_home_ownership_OWN', 'person_home_ownership_RENT',
+                          'loan_intent_EDUCATION', 'loan_intent_HOMEIMPROVEMENT', 'loan_intent_MEDICAL',
+                          'loan_intent_PERSONAL', 'loan_intent_VENTURE', 'loan_intent_DEBTCONSOLIDATION',
+                          'loan_grade_A', 'loan_grade_B', 'loan_grade_C', 'loan_grade_D', 
+                          'loan_grade_E', 'loan_grade_F', 'loan_grade_G',
+                          'cb_person_default_on_file_Y']
+    except:
+         model_cols = []
+
+    # Cria DF zerado com as colunas certas
+    df_input = pd.DataFrame(0, index=[0], columns=model_cols)
+    
+    # Preenche numéricos
+    for col in data:
+        if col in df_input.columns: df_input[col] = data[col]
+            
+    # Preenche categóricos (One-Hot Manual)
+    # Mapeamento Moradia
+    mapping_ownership = {'ALUGUEL': 'RENT', 'PRÓPRIA': 'OWN', 'FINANCIADA': 'MORTGAGE', 'OUTROS': 'OTHER'}
+    key_home = f"person_home_ownership_{mapping_ownership.get(home_ownership.split()[0], 'OTHER')}"
+    if key_home in df_input.columns: df_input[key_home] = 1
+        
+    # Mapeamento Motivo
+    intent_map_en = {"PESSOAL": "PERSONAL", "EDUCAÇÃO": "EDUCATION", "MÉDICO": "MEDICAL", 
+                     "VENTURE": "VENTURE", "REFORMA": "HOMEIMPROVEMENT", "CONSOLIDAÇÃO DÍVIDA": "DEBTCONSOLIDATION"}
+    key_intent = f"loan_intent_{intent_map_en.get(loan_intent, 'PERSONAL')}"
+    if key_intent in df_input.columns: df_input[key_intent] = 1
+        
+    # Mapeamento Grade
+    key_grade = f"loan_grade_{loan_grade}"
+    if key_grade in df_input.columns: df_input[key_grade] = 1
+        
+    # Mapeamento Histórico
+    if "Sim" in cb_default and "cb_person_default_on_file_Y" in df_input.columns:
+        df_input["cb_person_default_on_file_Y"] = 1
+        
+    return df_input
+
+input_df = user_input_features()
+
+# --- TABS DE RESULTADO ---
+tab1, tab2, tab3 = st.tabs(["📊 Carteira & Dados", "🧩 Clusterização", "🔮 Predição (IA)"])
+
+with tab1:
+    st.header("Visão da Base de Dados")
+    col1, col2, col3 = st.columns(3)
+    col1.metric("Total Clientes", f"{len(df):,}")
+    col2.metric("Inadimplência Média", f"{df['loan_status'].mean():.1%}")
+    col3.metric("Ticket Médio", f"R$ {df['loan_amnt'].mean():.2f}")
+    
+    st.subheader("Distribuição de Risco por Grau (Grade)")
+    fig = plt.figure(figsize=(10, 4))
+    sns.countplot(data=df, x='loan_grade', hue='loan_status', palette='viridis', order=sorted(df['loan_grade'].unique()))
+    st.pyplot(fig)
+
+with tab2:
+    st.header("Segmentação de Clientes (K-Means)")
+    if 'Cluster' in df.columns:
+        st.markdown("Médias por Cluster:")
+        cols_cluster_view = ['person_age', 'person_income', 'loan_amnt', 'loan_status']
+        st.dataframe(df.groupby('Cluster')[cols_cluster_view].mean().style.format({'person_income': 'R$ {:,.2f}', 'loan_status': '{:.1%}'}))
+        
+        st.subheader("Visualização: Renda vs Empréstimo")
+        fig2 = plt.figure(figsize=(10, 6))
+        sns.scatterplot(data=df, x='person_income', y='loan_amnt', hue='Cluster', palette='deep', alpha=0.7)
+        plt.xlim(0, 200000)
+        plt.title("Clusters de Perfil Financeiro")
+        st.pyplot(fig2)
+    else:
+        st.info("A coluna 'Cluster' não foi encontrada no dataset exportado.")
+
+with tab3:
+    st.header(f"Análise de Risco com: {model_name}")
+    st.caption(f"Categoria: {categoria_selecionada}")
+    
+    if st.button("Calcular Risco de Calote"):
+        try:
+            # 1. PREDIÇÃO
+            # O predict_proba retorna [Prob_Classe0, Prob_Classe1]
+            proba = current_model.predict_proba(input_df)[0][1]
+            
+            # Threshold visual de 50%
+            status = "REPROVADO" if proba > 0.5 else "APROVADO"
+            
+            # Exibição
+            c1, c2 = st.columns(2)
+            if status == "APROVADO":
+                c1.success(f"## {status}")
+                c1.markdown(f"**Cliente Seguro**")
+            else:
+                c1.error(f"## {status}")
+                c1.markdown(f"**Alto Risco**")
+                
+            c2.metric("Probabilidade de Calote", f"{proba:.1%}")
+            
+            st.divider()
+            
+            # 2. EXPLICABILIDADE (SHAP) - Lógica Condicional
+            st.subheader("Por que o modelo tomou essa decisão?")
+            
+            # Lista de modelos compatíveis com o TreeExplainer (Rápido e Visual)
+            modelos_arvore = ['LightGBM', 'XGBoost', 'Random Forest', 'Decision Tree', 'Gradient Boosting', 'AdaBoost']
+            eh_modelo_arvore = any(nome in model_name for nome in modelos_arvore)
+            
+            if eh_modelo_arvore:
+                try:
+                    # Configura o explicador de árvore
+                    explainer = shap.TreeExplainer(current_model)
+                    
+                    # Calcula valores SHAP
+                    shap_values = explainer(input_df)
+                    
+                    # Tratamento para Random Forest (que retorna lista para cada classe)
+                    # Se tiver 3 dimensões (amostra, features, classes), pegamos a classe 1
+                    if len(shap_values.shape) == 3:
+                        shap_values = shap_values[:, :, 1]
+                        
+                    # Plota o Waterfall
+                    fig_shap = plt.figure(figsize=(10, 5))
+                    shap.plots.waterfall(shap_values[0], show=False, max_display=10)
+                    st.pyplot(fig_shap)
+                    
+                    st.info("💡 **Interpretação:** Barras Vermelhas empurram o risco para cima. Barras Azuis protegem o cliente.")
+                    
+                except Exception as e:
+                    st.warning(f"Erro ao gerar SHAP para este modelo de árvore: {e}")
+            
+            else:
+                # Caso seja KNN, SVM ou MLP (Rede Neural)
+                st.warning(f"⚠️ A visualização SHAP (Waterfall) não está disponível para modelos baseados em **{categoria_selecionada}** neste ambiente Web.")
+                st.markdown("""
+                **Motivo:** Modelos como SVM, KNN e Redes Neurais exigem o uso do `KernelExplainer`, que é computacionalmente muito pesado 
+                para rodar em tempo real na nuvem gratuita. Para ver a explicabilidade destes modelos, consulte o relatório estático HTML.
+                """)
+
+        except Exception as e:
+            st.error(f"Erro na execução do modelo. Detalhes técnicos: {e}")
+
+st.markdown("---")
+st.caption("Sistema desenvolvido para a Prova Final de Sistemas de Informação - Engenharia de Produção")

todos_modelos.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ce3b68735b2a9f35b6b455f99af687bbb293864a895837887b7597826bdff56
+size 101442357