Chore: fix

.gitignore

@@ -0,0 +1,2 @@
+env/
+.dist/

app.py

@@ -8,127 +8,130 @@ from sklearn.model_selection import train_test_split
 from tensorflow.keras.layers import Input, Embedding, Flatten, Concatenate, Dense, BatchNormalization, Dropout
 from tensorflow.keras.models import Model
 import matplotlib.pyplot as plt
+# app.py
 
-# Título
-st.title("Provisionamento de Indenizações - Modelo de Deep Learning")
+# Função de Preprocessamento
+def preprocess_data(base_final):
+    # Convertendo indenização e tempo para numéricos
+    base_final['indenizacao_num'] = pd.to_numeric(base_final['indenizacao'], errors='coerce')
+    base_final['tempo_num'] = pd.to_numeric(base_final['tempo_meses'], errors='coerce')
 
-# Upload de Dados
-st.sidebar.header("Upload de Dados")
-uploaded_file = st.sidebar.file_uploader("Envie seu arquivo Excel", type=["xlsx"])
+    # Identificar variáveis categóricas e numéricas
+    categorical_cols = ['classe', 'comarca', 'danos', 'resultado']
+    numerical_cols = base_final.select_dtypes(include=['float64', 'int64']).columns
+
+    # Imputação para variáveis categóricas
+    from sklearn.impute import SimpleImputer
+    imputer_cat = SimpleImputer(strategy='most_frequent')
+    base_final[categorical_cols] = imputer_cat.fit_transform(base_final[categorical_cols])
+
+    # Imputação para variáveis numéricas
+    imputer_num = SimpleImputer(strategy='mean')
+    base_final[numerical_cols] = imputer_num.fit_transform(base_final[numerical_cols])
+
+    # Criar dummies para todas as variáveis categóricas
+    from sklearn.preprocessing import OneHotEncoder
+    encoder = OneHotEncoder(drop='first', sparse_output=False)
+    dummies = pd.DataFrame(
+        encoder.fit_transform(base_final[categorical_cols]),
+        columns=encoder.get_feature_names_out(categorical_cols),
+        index=base_final.index
+    )
+
+    # Combinar variáveis contínuas com dummies
+    base_final_preprocessed = pd.concat([base_final, dummies], axis=1)
+    base_final_preprocessed.drop(columns=categorical_cols, inplace=True)
+    base_final_preprocessed = base_final_preprocessed.select_dtypes(include=[np.number])
+
+    return base_final_preprocessed
+
+# Função de Modelagem para Indenização
+def model_indenizacao(base_final_preprocessed):
+    X = base_final_preprocessed.drop(columns=['tempo_num', 'indenizacao_num'], errors='ignore')
+    y_indenizacao = base_final_preprocessed['indenizacao_num']
+
+    # Divisão entre treino e teste
+    X_train, X_test, y_train_indenizacao, y_test_indenizacao = train_test_split(X, y_indenizacao, test_size=0.3, random_state=42)
+
+    rf_model_indenizacao = RandomForestRegressor(n_estimators=100, random_state=42)
+    rf_model_indenizacao.fit(X_train, y_train_indenizacao)
+    y_pred_indenizacao = rf_model_indenizacao.predict(X_test)
+    rmse_indenizacao = np.sqrt(mean_squared_error(y_test_indenizacao, y_pred_indenizacao))
+
+    return rf_model_indenizacao, rmse_indenizacao
+
+# Função de Modelagem para Tempo
+def model_tempo(base_final_preprocessed):
+    X = base_final_preprocessed.drop(columns=['tempo_num', 'indenizacao_num'], errors='ignore')
+    y_tempo = base_final_preprocessed['tempo_num']
+
+    # Divisão entre treino e teste
+    X_train, X_test, y_train_tempo, y_test_tempo = train_test_split(X, y_tempo, test_size=0.3, random_state=42)
+
+    rf_model_tempo = RandomForestRegressor(n_estimators=100, random_state=42)
+    rf_model_tempo.fit(X_train, y_train_tempo)
+    y_pred_tempo = rf_model_tempo.predict(X_test)
+    rmse_tempo = np.sqrt(mean_squared_error(y_test_tempo, y_pred_tempo))
+
+    return rf_model_tempo, rmse_tempo
+
+# Função de Classificação de Risco
+def model_risco(base_final, X_test, rf_model_indenizacao, rf_model_tempo):
+    logistic_model = LogisticRegression(max_iter=500)
+    logistic_model.fit(X_test, (base_final['resultado'] == 'Procedente').astype(int))
+    y_pred_proba = logistic_model.predict_proba(X_test)[:, 1]
+    provisionamento_esperado = (y_pred_indenizacao * y_pred_proba).sum()
+
+    # Classificação de Risco
+    X_test_df = base_final.loc[X_test.index].copy()
+    X_test_df['prob_perda'] = y_pred_proba
+    X_test_df['risco'] = np.select(
+        [X_test_df['prob_perda'] < 0.3, 
+         (X_test_df['prob_perda'] >= 0.3) & (X_test_df['prob_perda'] < 0.7), 
+         X_test_df['prob_perda'] >= 0.7],
+        ['Remoto', 'Possível', 'Provável'],
+        default='Desconhecido'
+    )
+
+    return provisionamento_esperado, X_test_df
+
+# Título do App
+st.title("Sistema Jurídico - Modelagem de Indenização e Tempo de Processo")
+
+# Upload de arquivo
+uploaded_file = st.file_uploader("Faça o upload do arquivo Excel", type=["xlsx"])
 
 if uploaded_file:
     # Carregar os dados
     base_final = pd.read_excel(uploaded_file)
-    
-    # Preprocessamento
-    st.sidebar.subheader("Configurações de Pré-processamento")
-    date_columns = st.sidebar.multiselect("Colunas de Data a Remover", options=base_final.columns)#, default=['data', 'data_presumida'])
-    base_final = base_final.drop(columns=date_columns, errors='ignore')
-    
-    base_final['indenizacao'] = base_final['indenizacao'].replace('Valor Não Previsto/Mencionado', np.nan).astype(float)
-    base_final['remuneracao_magistrado'] = base_final['remuneracao_magistrado'].fillna(base_final['remuneracao_magistrado'].mean())
-    base_final['entrancia'] = base_final['entrancia'].fillna('Desconhecido')
-    base_final['latitude'] = base_final['latitude'].fillna(base_final['latitude'].mean())
-    base_final['longitude'] = base_final['longitude'].fillna(base_final['longitude'].mean())
-    base_final['count'] = base_final['count'].fillna(base_final['count'].mean())
-    base_final['tempo_por_comarca'] = base_final['tempo_meses'] * base_final['count']
-    base_final['tempo_por_comarca'] = base_final['tempo_por_comarca'].fillna(0)
-
-    base_final = base_final[base_final['indenizacao'].notna()]
-    
-    # Separar variáveis categóricas, numéricas e alvo
-    categorical_columns = ['classe', 'assunto', 'magistrado', 'comarca', 'foro', 'vara', 'decisao', 'resultado', 'danos', 'entrancia']
-    numerical_columns = ['ano_processo', 'tempo_meses', 'remuneracao_magistrado', 'latitude', 'longitude', 'count']
-    target = 'indenizacao'
-    
-    label_encoders = {}
-    for col in categorical_columns:
-        le = LabelEncoder()
-        base_final[col] = le.fit_transform(base_final[col])
-        label_encoders[col] = le
-    
-    scaler = StandardScaler()
-    base_final[numerical_columns + ['tempo_por_comarca']] = scaler.fit_transform(base_final[numerical_columns + ['tempo_por_comarca']])
-    
-    X = base_final[categorical_columns + numerical_columns + ['tempo_por_comarca']]
-    y = base_final[target].values
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-    
-    # Construção do Modelo
-    inputs = []
-    encoded_layers = []
-    
-    for col in categorical_columns:
-        input_cat = Input(shape=(1,), name=f"input_{col}")
-        inputs.append(input_cat)
-        num_unique_vals = base_final[col].nunique()
-        embedding_dim = min(50, num_unique_vals // 2)
-        embedding = Embedding(input_dim=num_unique_vals + 1, output_dim=embedding_dim, name=f"embedding_{col}")(input_cat)
-        flatten = Flatten()(embedding)
-        encoded_layers.append(flatten)
-    
-    tempo_por_comarca_input = Input(shape=(1,), name="tempo_por_comarca_input")
-    inputs.append(tempo_por_comarca_input)
-    encoded_layers.append(tempo_por_comarca_input)
-    
-    input_num = Input(shape=(len(numerical_columns),), name="input_numerical")
-    inputs.append(input_num)
-    encoded_layers.append(input_num)
-    
-    concat = Concatenate()(encoded_layers)
-    x = Dense(128, activation="relu")(concat)
-    x = BatchNormalization()(x)
-    x = Dropout(0.3)(x)
-    x = Dense(64, activation="relu")(x)
-    x = BatchNormalization()(x)
-    x = Dropout(0.3)(x)
-    output = Dense(1, activation="linear", name="output")(x)
-    
-    model = Model(inputs=inputs, outputs=output)
-    model.compile(optimizer="adam", loss="mse", metrics=["mae"])
-    
-    # Preparar os dados para o modelo
-    input_data = [X_train[col].values.reshape(-1, 1) for col in categorical_columns]
-    input_data.append(X_train['tempo_por_comarca'].values.reshape(-1, 1))
-    input_data.append(X_train[numerical_columns].values)
-    
-    val_data = (
-        [X_test[col].values.reshape(-1, 1) for col in categorical_columns]
-        + [X_test['tempo_por_comarca'].values.reshape(-1, 1)]
-        + [X_test[numerical_columns].values],
-        y_test
+
+    st.subheader("Passo 1: Preprocessamento")
+    base_final_preprocessed = preprocess_data(base_final)
+    st.write("Dados preprocessados:", base_final_preprocessed.head())
+
+    st.subheader("Passo 2: Modelos Preditivos")
+    rf_model_indenizacao, rmse_indenizacao = model_indenizacao(base_final_preprocessed)
+    st.write(f"RMSE (Indenização): {rmse_indenizacao:.2f}")
+
+    rf_model_tempo, rmse_tempo = model_tempo(base_final_preprocessed)
+    st.write(f"RMSE (Tempo do Processo): {rmse_tempo:.2f}")
+
+    st.subheader("Passo 3: Provisionamento e Classificação de Risco")
+    provisionamento_esperado, X_test_df = model_risco(base_final, base_final_preprocessed, rf_model_indenizacao, rf_model_tempo)
+    st.write(f"Provisionamento esperado: R$ {provisionamento_esperado:.2f}")
+    st.write("Classificação de Risco:", X_test_df[['risco', 'indenizacao_num']].head())
+
+    st.subheader("Passo 4: Classificação de Tempo do Processo")
+    X_test_df['tempo_estimado'] = rf_model_tempo.predict(X_test_df)
+    X_test_df['categoria_tempo'] = np.select(
+        [X_test_df['tempo_estimado'] < 6, 
+         (X_test_df['tempo_estimado'] >= 6) & (X_test_df['tempo_estimado'] < 12), 
+         X_test_df['tempo_estimado'] >= 12],
+        ['Curto', 'Moderado', 'Longo'],
+        default='Desconhecido'
     )
-    
-    # Treinamento
-    st.sidebar.subheader("Treinamento")
-    epochs = st.sidebar.slider("Épocas", min_value=10, max_value=100, value=50, step=10)
-    batch_size = st.sidebar.slider("Tamanho do Batch", min_value=16, max_value=128, value=32, step=16)
-    
-    with st.spinner("Treinando o modelo..."):
-        history = model.fit(
-            input_data[:12],
-            y_train,
-            validation_data=(val_data[0][:12], val_data[1]),
-            epochs=epochs,
-            batch_size=batch_size,
-            callbacks=[tf.keras.callbacks.EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True)],
-            verbose=0
-        )
-    
-    st.success("Modelo treinado com sucesso!")
-    
-    # Avaliação
-    st.subheader("Resultados do Modelo")
-    results = model.evaluate([val_data[0][i] for i in range(12)], val_data[1], verbose=0)
-    st.write(f"Loss (MSE): {results[0]:.4f}")
-    st.write(f"MAE: {results[1]:.4f}")
-    
-    # Gráfico de Treinamento
-    st.subheader("Curva de Treinamento")
-    plt.figure(figsize=(10, 6))
-    plt.plot(history.history['loss'], label='Loss de Treinamento')
-    plt.plot(history.history['val_loss'], label='Loss de Validação')
-    plt.xlabel('Épocas')
-    plt.ylabel('Loss')
-    plt.legend()
-    st.pyplot(plt.gcf())
+    st.write("Classificação de Tempo:", X_test_df[['categoria_tempo', 'tempo_meses']].head())
+
+    # Gráficos opcionais
+    st.subheader("Distribuição de Previsões")
+    st.bar_chart(X_test_df['risco'].value_counts())