Create app.py

app.py

@@ -0,0 +1,357 @@
+import pandas as pd
+import gradio as gr
+import numpy as np
+import statsmodels.api as sm
+from statsmodels.stats.stattools import jarque_bera
+import textwrap
+import plotly.express as px
+import plotly.graph_objects as go
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# função para conversão da escala das variáveis:
+def aplicar_operacao(df, scv, col_index):
+    if scv == 'x':
+        pass
+    elif scv == 'lnx':
+        df.iloc[:, col_index] = round(np.log(df.iloc[:, col_index]), 3)
+    elif scv == '1/x':
+        df.iloc[:, col_index] = round(1 / df.iloc[:, col_index], 3)
+    elif scv == 'x²':
+        df.iloc[:, col_index] = round(df.iloc[:, col_index] ** 2, 3)
+        
+# função para plotagem dos gráficos de dispersão:        
+def criar_grafico_dispersao(df, x_column, y_column, hover_name, trendline_color):
+    # Calculando a correlação entre as variáveis x e y
+    correlacao = df[x_column].corr(df[y_column])
+    
+    # Criando o gráfico de dispersão com a linha de tendência
+    fig = px.scatter(df, x=x_column, y=y_column, hover_name=hover_name, trendline="ols")
+    # Definindo a cor de fundo e do papel
+    fig.update_layout(
+        plot_bgcolor='rgb(240, 240, 240)',  
+        paper_bgcolor='rgb(240, 240, 240)'  
+    )
+    # Definindo a cor dos pontos
+    fig.update_traces(marker=dict(color=trendline_color, size=8))
+    # Definindo a cor da linha de tendência
+    fig.update_traces(line=dict(color="black"))
+    # Adicionando o texto com a correlação na linha de tendência
+    fig.add_annotation(
+        x=df[x_column].max(),
+        y=df[y_column].max(),
+        text=f"Correlação: {correlacao:.2f}",
+        showarrow=False,
+        font=dict(color="black")
+    )
+    return fig
+      
+# função para a regressão linear
+def avaliacao_imovel(planilha, v_1, v_2, v_3, v_4, v_5, v_6, v_7, scv_d, scv_1, scv_2, scv_3, scv_4, scv_5, scv_6, scv_7, linhas):
+    
+    # ---------------------------------Planilha------------------------------#
+    
+    df_dados = pd.read_excel(planilha.name)
+    df_original = df_dados.copy()
+    
+    #-----------------------------------Escalas------------------------------#
+    
+    aplicar_operacao(df_dados, scv_d, 1)
+    aplicar_operacao(df_dados, scv_1, 2)
+    aplicar_operacao(df_dados, scv_2, 3)
+    aplicar_operacao(df_dados, scv_3, 4)
+    aplicar_operacao(df_dados, scv_4, 5)
+    aplicar_operacao(df_dados, scv_5, 6)
+    aplicar_operacao(df_dados, scv_6, 7)
+    aplicar_operacao(df_dados, scv_7, 8)
+    
+    #----------------Manipulação das linhas (dados / outiliers----------------#
+    
+    num_linhas = df_dados.shape[0]
+    linhas_selecionadas = [int(linha) - 1 for linha in linhas if int(linha) - 1 < num_linhas]
+    df_filtrado = df_dados.iloc[linhas_selecionadas]
+    df_outliers = df_dados.drop(linhas_selecionadas)
+    df_filtrado.sort_values(by=df_filtrado.columns[0], inplace=True)
+    
+    #----------------Manipulação das Colunas (variáveis)-----------------------#
+    
+    # Variáveis independentes
+    X = pd.DataFrame()
+
+    # Iterar sobre as colunas do DataFrame df_filtrado
+    for i, col in enumerate(df_filtrado.columns):
+        # Verificar se a coluna atual deve ser adicionada com base na condição e se ela existe no DataFrame
+        if (i == 2 and v_1) or (i == 3 and v_2) or (i == 4 and v_3) or (i == 5 and v_4) or (i == 6 and v_5) or (i == 7 and v_6) or (i == 8 and v_7):
+            if i < len(df_filtrado.columns):
+                X[col] = df_filtrado.iloc[:, i]
+    
+    #---------------------------Gráficos de dispersão--------------------------#
+    
+    fig_v1 = None
+    fig_v2 = None
+    fig_v3 = None
+    fig_v4 = None
+    fig_v5 = None
+    fig_v6 = None
+    fig_v7 = None
+    
+    if v_1:
+        fig_v1 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[2], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
+    if v_2:
+        fig_v2 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[3], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
+    if v_3:
+        fig_v3 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[4], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
+    if v_4:
+        fig_v4 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[5], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
+    if v_5:
+        fig_v5 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[6], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
+    if v_6:
+        fig_v6 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[7], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
+    if v_7:
+        fig_v7 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[8], df_filtrado.columns[1], df_filtrado.columns[0], "orange")    
+    
+    #--------------------------Regressão Linerar------------------------------#
+    
+    # Variável dependente
+    y = df_filtrado.iloc[:, 1:2]
+    
+    # Adicionando uma constante à variável independente (intercepto)
+    X = sm.add_constant(X)
+
+    # Inicializando o modelo de regressão linear
+    modelo = sm.OLS(y, X)
+
+    # Ajustando o modelo aos dados
+    resultado = modelo.fit()
+    
+    # Calculando os resíduos do modelo
+    residuos = resultado.resid
+
+    # Calculando Desvio Padrão dos Resíduos
+    #desvio_padrao_residuos = round(np.std(resultado.resid), 4)
+    desvio_padrao_residuos = round(np.std(residuos), 4)
+    # Calculando Estatística F
+    estatistica_F = round(resultado.fvalue, 4)
+    # Obtendo Nível de Significância do Modelo
+    nivel_significancia = round(resultado.f_pvalue, 4)
+    # Calculando R²
+    r_squared = round(resultado.rsquared, 4)
+    # Calculando R² ajustado
+    r_squared_adjusted = round(resultado.rsquared_adj, 4)
+    # Obtendo Número de Observações
+    num_observacoes = round(resultado.nobs, 0)
+    # Calculando Coeficiente de Correlação
+    coef_correlacao = round(np.sqrt(r_squared), 4)
+    # Calculando o teste de Jarque-Bera para os resíduos
+    jarque_bera_test, p_value, skewness, kurtosis = jarque_bera(residuos)
+    # Formatando os resultados com 4 casas decimais
+    jarque_bera_test = round(jarque_bera_test, 4)
+    p_value = round(p_value, 4)
+    skewness = round(skewness, 4)
+    kurtosis = round(kurtosis, 4)
+    # Extrair os coeficientes da regressão
+    coeficientes = resultado.params 
+    # Calcular a distância de Cook
+    distancia_cook = resultado.get_influence().cooks_distance[0]
+    
+    # String com os resultados
+    resultados_gerais = f"""
+    Desvio Padrão: {desvio_padrao_residuos}
+    Estatística F: {estatistica_F}
+    Nível de Significância do Modelo: {nivel_significancia}
+    R²: {r_squared}
+    R² ajustado: {r_squared_adjusted}
+    Número de observações: {num_observacoes}
+    Coeficianete de Correlação: {coef_correlacao}
+    Teste de Jarque-Bera:
+      - Estatística do teste: {jarque_bera_test}
+      - Valor-p: {p_value}
+      - Assimetria (Skewness): {skewness}
+      - Curtose (Kurtosis): {kurtosis}
+    """
+    
+    # Equação do modelo
+    # Inicialize a equação do modelo
+    equacao_modelo = "y ="
+    # Iterar sobre os coeficientes estimados
+    for nome_coluna, coeficiente in zip(X.columns, coeficientes):
+        # Se o nome da coluna for 'const', adicione apenas o coeficiente
+        if nome_coluna == 'const':
+            equacao_modelo += f" {coeficiente:.4f} +"
+        else:
+            # Adicionar o termo à equação do modelo
+            equacao_modelo += f" {coeficiente:.4f} * {nome_coluna} +"
+    # Remover o último sinal de adição
+    equacao_modelo = equacao_modelo[:-1]
+    # Exibindo estatísticas do modelo
+    resultado_summary = resultado.summary()
+    resultado_html = resultado.summary().tables[1].as_html()
+    # Obtenha as estatísticas do modelo em formato de DataFrame
+    #resultado_summary_df = pd.DataFrame(resultado_summary.tables[1])
+    
+    #---------------------df_final (utilizado na regressão)----------------------#
+    
+    # Adicionando a primeira coluna de df_filtrado ao início de df_final
+    ordem = df_filtrado[[df_filtrado.columns[0]]].copy()
+    df_final = pd.concat([ordem, y, X], axis=1)
+    df_final = df_final.drop(columns=['const'])
+
+    #--------------------df_final (adiciona o erro_padronizado)------------------#
+
+    # Calculando o erro padronizado
+    erro_padronizado = round(residuos / desvio_padrao_residuos, 3)
+    # Adicionando a coluna de erro padronizado ao df_final
+    df_final['Erro Padronizado'] = erro_padronizado
+    
+    #-------------------df_maiores_que_2 (possíveis outliers)--------------------#
+    
+    # Criar DataFrame apenas com os dados cujo erro padronizado é maior que 2
+    df_maiores_que_2 = df_final[abs(df_final['Erro Padronizado']) > 2]
+    
+    #------------df_correl (Valores Ajustados x Preços Observados)---------------#
+    
+    # Obtendo os valores previstos
+    valores_previstos = resultado.predict(X)
+    # Adicionando os valores previstos como uma nova coluna ao df_final
+    df_final['Valores Ajustados'] = round(valores_previstos, 2)
+    # Criando uma dataframe para os Valores Ajustados x Preços Observados
+    df_correl = df_final[[df_filtrado.columns[0], df_filtrado.columns[1], 'Valores Ajustados']]
+    df_correl = df_correl.rename(columns={df_filtrado.columns[1]: 'Preços Observados'})
+    # Desfazendo a conversão da escala
+    if scv_d == 'lnx':
+        df_correl['Valores Ajustados'] = round(np.exp(df_correl['Valores Ajustados']), 2)
+        df_correl['Preços Observados'] = round(np.exp(df_correl['Preços Observados']), 2)
+    elif scv_d == '1/x':
+        df_correl['Valores Ajustados'] = round(1 / df_correl['Valores Ajustados'], 2)
+        df_correl['Preços Observados'] = round(1 / df_correl['Preços Observados'], 2)
+    elif scv_d == 'x²':
+        df_correl['Valores Ajustados'] = round(np.sqrt(df_correl['Valores Ajustados']), 2)
+        df_correl['Preços Observados'] = round(np.sqrt(df_correl['Preços Observados']), 2)
+    else:
+        pass  # Nenhuma transformação é necessária
+    
+    df_correl['Diferença %'] = round(((df_correl['Valores Ajustados']/df_correl['Preços Observados'])-1)*100, 2)
+    
+    #------------Gráficos dos Valores Ajustados x Resíduos Padronizados e Histograma---------------#
+    
+    # Criando subplots
+    fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(8, 12))
+
+    # Plotagem dos resíduos padronizados
+    ax1.scatter(df_final['Valores Ajustados'], erro_padronizado, color='orange', alpha=0.6)
+    ax1.axhline(y=0, color='black', linestyle='--', linewidth=1)  # Linha zero
+    ax1.axhline(y=2, color='red', linestyle='-', linewidth=1)  # Linhas vermelhas em ±2
+    ax1.axhline(y=-2, color='red', linestyle='-', linewidth=1)
+    ax1.set_title('Gráfico de Resíduos Padronizados')
+    ax1.set_xlabel('Valores Ajustados')
+    ax1.set_ylabel('Resíduos Padronizados')
+    ax1.grid(True)
+    
+    # Adicionando rótulos aos pontos com resíduos padronizados > 2
+    #for i, txt in enumerate(df_final.iloc[:, 0]):
+        #if abs(erro_padronizado[i]) > 2:
+            #ax1.annotate(txt, (df_final['Valores Ajustados'][i], erro_padronizado[i]), color='black')
+
+    # Histograma dos resíduos padronizados
+    sns.histplot(erro_padronizado, kde=True, color='orange', alpha=0.6, ax=ax2)
+    ax2.set_title('Histograma dos Resíduos Padronizados')
+    ax2.set_xlabel('Resíduos Padronizados')
+    ax2.set_ylabel('Frequência')
+    ax2.grid(True)
+
+    # Gráfico da distância de Cook
+    ax3.plot(distancia_cook, marker='o', linestyle='None', color='orange')
+    ax3.axhline(y=1, color='red', linestyle='--', linewidth=1)
+    ax3.set_title('Gráfico da Distância de Cook')
+    ax3.set_xlabel('Número da Observação')
+    ax3.set_ylabel('Distância de Cook')
+    ax3.grid(True)
+    
+    # Adicionando rótulos aos pontos
+    for i, txt in enumerate(df_final.iloc[:, 0]):
+        ax3.annotate(txt, (i, distancia_cook[i]))
+    
+    # Ajustando a posição dos subplots
+    plt.tight_layout()
+
+    # Exibindo os subplots
+    plt.show()
+    
+    # Listagem de pontos discrepantes
+    limite_cook = 4 / (len(df_final) - len(resultado.params))
+    pontos_discrepantes = []
+    for i, cook_dist in enumerate(distancia_cook):
+        if cook_dist > limite_cook:
+            pontos_discrepantes.append(df_final.iloc[i, 0])  # Usando a primeira coluna como rótulo
+    # Listagem de pontos influentes  
+    limite_cook = 1
+    pontos_influentes = []
+    for i, cook_dist in enumerate(distancia_cook):
+        if cook_dist > limite_cook:
+            pontos_influentes.append(df_final.iloc[i, 0])  # Usando a primeira coluna como rótulo
+
+    #---------------------------------------Outputs----------------------------------#
+    
+    return df_original, resultados_gerais, resultado_html, equacao_modelo, df_final, df_maiores_que_2, df_outliers, df_correl, fig_v1, fig_v2, fig_v3, fig_v4, fig_v5, fig_v6, fig_v7, plt, pontos_discrepantes, pontos_influentes
+ 
+    #df_filtrado,resultado_summary_df,
+    
+    #--------------------------------------Interface---------------------------------#
+    
+numeros = [str(i) for i in range(0, 501)]
+    
+interface = gr.Interface(
+    fn=avaliacao_imovel,
+    inputs=[
+        gr.components.File(label="Upload planilha", type="file", info="Importação de planilha"),
+        gr.components.Checkbox(value=False, label="Variável independente 1"),
+        gr.components.Checkbox(value=False, label="Variável independente 2"),
+        gr.components.Checkbox(value=False, label="Variável independente 3"),
+        gr.components.Checkbox(value=False, label="Variável independente 4"),
+        gr.components.Checkbox(value=False, label="Variável independente 5"),
+        gr.components.Checkbox(value=False, label="Variável independente 6"),
+        gr.components.Checkbox(value=False, label="Variável independente 7"),
+        gr.Radio(['x', 'lnx', '1/x', 'x²'], label="Escala VARIÁVEL DEPENDENTE", value='x'),
+        gr.Radio(['x', 'lnx', '1/x', 'x²'], label="--->  Escala variável independente 1", value='x'),
+        gr.Radio(['x', 'lnx', '1/x', 'x²'], label="--->  Escala variável independente 2", value='x'),
+        gr.Radio(['x', 'lnx', '1/x', 'x²'], label="--->  Escala variável independente 3", value='x'),
+        gr.Radio(['x', 'lnx', '1/x', 'x²'], label="--->  Escala variável independente 4", value='x'),
+        gr.Radio(['x', 'lnx', '1/x', 'x²'], label="--->  Escala variável independente 5", value='x'),
+        gr.Radio(['x', 'lnx', '1/x', 'x²'], label="--->  Escala variável independente 6", value='x'),
+        gr.Radio(['x', 'lnx', '1/x', 'x²'], label="--->  Escala variável independente 7", value='x'),
+        gr.components.CheckboxGroup(numeros, value=numeros[1:501], label="Selecionar dados", type="index"),
+    ],
+    outputs=[
+        gr.Dataframe(label="Planilha de dados original"),
+        #gr.Dataframe(label="Dados filtrados por linhas e variáveis com escalas convertidas"),
+        gr.Textbox(label ="Resultados Gerais do Modelo"),
+        gr.HTML(label="Resumo da Regress��o", info = "Resultados por variável"),
+        #gr.Dataframe(label="Resultados por variável"),
+        gr.Textbox(label ="Equação do Modelo"),
+        gr.Dataframe(label="Planilha Regressão Linear (Variáveis  e escalas escolhidas e sem outliers)"),
+        gr.Dataframe(label="Resíduos Padronizados > 2"),
+        gr.Dataframe(label="Outliers (retirados)"),
+        gr.Dataframe(label="Valores Ajustados x Preços Observados"),
+        gr.Plot(label="Gráfico Dispersão var 1"),
+        gr.Plot(label="Gráfico Dispersão var 2"),
+        gr.Plot(label="Gráfico Dispersão var 3"),
+        gr.Plot(label="Gráfico Dispersão var 4"),
+        gr.Plot(label="Gráfico Dispersão var 5"),
+        gr.Plot(label="Gráfico Dispersão var 6"),
+        gr.Plot(label="Gráfico Dispersão var 7"),
+        #gr.Plot(label="Valores Ajustados x Preços Observados"),
+        gr.Plot(label="Análise Gráfica do Modelo de Regressão"),
+        gr.Textbox(label ="Listagem de pontos discrepantes"),
+        gr.Textbox(label ="Listagem de pontos Influenciantes (Distância de Cook > 1)"),
+        
+    ],
+    theme=gr.themes.Monochrome(),
+    title = "<span style='color: gray; font-size: 48px;'>avalia.se</span>",
+    description=f"""
+    <p style="text-align: left;"><b><span style='color: orange; font-size: 30px;'>Módulo de Regressão Linear</span></b></p>
+    <p style="text-align: left;"></span>Aplicativo MCDDM com tratamento científico / Para ver a documentação, você pode baixar <a href='https://huggingface.co/spaces/DavidSB/avaliaFACTOR/resolve/main/dados_entrada_factor.xlsx' download='dados_entrada_factor.xlsx'>aqui</a><br><br></p>
+    """ 
+)
+
+if __name__ == "__main__":
+    interface.launch(debug=True)