app.py

import pandas as pd
import gradio as gr
from gradio import components
from gradio import Interface
import numpy as np
import statsmodels
import statsmodels.api as sm
from statsmodels.stats.stattools import jarque_bera
import plotly.express as px
import plotly.graph_objects as go
import matplotlib.pyplot as plt
import matplotlib.pyplot as plt_1
import seaborn as sns
import sklearn
from sklearn.preprocessing import MinMaxScaler
from sklearn.ensemble import ExtraTreesRegressor
#%matplotlib inline 

# 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]), 8)
    elif scv == '1/x':
        df.iloc[:, col_index] = round(1 / df.iloc[:, col_index], 8)
    elif scv == 'x²':
        df.iloc[:, col_index] = round(df.iloc[:, col_index] ** 2, 8)
    elif scv == 'y':
        pass
    elif scv == 'lny':
        df.iloc[:, col_index] = round(np.log(df.iloc[:, col_index]), 8)
    elif scv == '1/y':
        df.iloc[:, col_index] = round(1 / df.iloc[:, col_index], 8)
    elif scv == 'y²':
        df.iloc[:, col_index] = round(df.iloc[:, col_index] ** 2, 8)
         
# função para renomear as colunas com as escalas:        
def renomeia_colunas(df_dados, posicao_coluna, scv):
    if posicao_coluna < len(df_dados.columns):
        old_column_name = df_dados.columns[posicao_coluna]
        
        new_column_name = old_column_name  # Inicializa com o mesmo nome da coluna original
        if scv == 'x':
            pass
        elif scv == 'lnx':
            new_column_name = 'ln(' + old_column_name + ')'
        elif scv == '1/x':
            new_column_name = '1/(' + old_column_name + ')'
        elif scv == 'x²':
            new_column_name = '(' + old_column_name + ')²'   
        if scv == 'y':
            pass
        elif scv == 'lny':
            new_column_name = 'ln(' + old_column_name + ')'
        elif scv == '1/y':
            new_column_name = '1/(' + old_column_name + ')'
        elif scv == 'y²':
            new_column_name = '(' + old_column_name + ')²'

        df_dados.rename(columns={old_column_name: new_column_name}, inplace=True)

# 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", height=300)
    # 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=5))
    # 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_d, scv_d, 
                     v_1, scv_1, v_2, scv_2, 
                     v_3, scv_3, v_4, scv_4, 
                     v_5, scv_5, v_6, scv_6, 
                     v_7, scv_7, v_8, scv_8,
                     v_9, scv_9, v_10, scv_10,
                     v_11, scv_11, v_12, scv_12,
                     v_13, scv_13, v_14, scv_14,
                     v_15, scv_15, v_16, scv_16,
                     linhas):
    
    # ---------------------------------Planilha------------------------------#
    
    # Carregando os dados
    df_dados = pd.read_excel(planilha.name)
    df_dados = df_dados.round(4)
    # Convertendo os cabeçalhos para strings
    df_dados.columns = [str(col) for col in df_dados.columns]
                         
    df_dados[df_dados.columns[1]] = df_dados[df_dados.columns[1]].astype(float)
    df_dados[df_dados.columns[2]] = df_dados[df_dados.columns[2]].astype(float)
    df_original = df_dados.copy()

    # ---------------------------Nome das variáveis--------------------------#
    
    # Obtenha os nomes das colunas, excluindo a primeira ou a segunda
    
    if v_d == "Valor total":
        nomes_colunas = df_original.drop(columns=[df_original.columns[0], df_original.columns[2]]).columns
    else:
        nomes_colunas = df_original.drop(columns=[df_original.columns[0], df_original.columns[1]]).columns

    # Crie a lista de strings com os cabeçalhos formatados
    colunas = [f'Var dependente = {nomes_colunas[0]}'] + [f'Var {i} = {coluna}' for i, coluna in enumerate(nomes_colunas[1:], start=1)]

    #-----------------------------------Escalas------------------------------#
    # dados
    if v_d == "Valor total":
        aplicar_operacao(df_dados, scv_d, 1)
    else:
        aplicar_operacao(df_dados, scv_d, 2)
    aplicar_operacao(df_dados, scv_1, 3)
    aplicar_operacao(df_dados, scv_2, 4)
    aplicar_operacao(df_dados, scv_3, 5)
    aplicar_operacao(df_dados, scv_4, 6)
    aplicar_operacao(df_dados, scv_5, 7)
    aplicar_operacao(df_dados, scv_6, 8)
    aplicar_operacao(df_dados, scv_7, 9)
    aplicar_operacao(df_dados, scv_8, 10)
    aplicar_operacao(df_dados, scv_9, 11)
    aplicar_operacao(df_dados, scv_10, 12)
    aplicar_operacao(df_dados, scv_11, 13)
    aplicar_operacao(df_dados, scv_12, 14)
    aplicar_operacao(df_dados, scv_13, 15)
    aplicar_operacao(df_dados, scv_14, 16)
    aplicar_operacao(df_dados, scv_15, 17)
    aplicar_operacao(df_dados, scv_16, 18)

    #----------------------------Renomear colunas----------------------------#

    #dados
    if v_d == "Valor total":
        renomeia_colunas(df_dados, 1, scv_d)
    else:
        renomeia_colunas(df_dados, 2, scv_d)
    renomeia_colunas(df_dados, 3, scv_1)
    renomeia_colunas(df_dados, 4, scv_2)
    renomeia_colunas(df_dados, 5, scv_3)
    renomeia_colunas(df_dados, 6, scv_4)
    renomeia_colunas(df_dados, 7, scv_5)
    renomeia_colunas(df_dados, 8, scv_6)
    renomeia_colunas(df_dados, 9, scv_7)
    renomeia_colunas(df_dados, 10, scv_8)
    renomeia_colunas(df_dados, 11, scv_9)
    renomeia_colunas(df_dados, 12, scv_10)
    renomeia_colunas(df_dados, 13, scv_11)
    renomeia_colunas(df_dados, 14, scv_12)
    renomeia_colunas(df_dados, 15, scv_13)
    renomeia_colunas(df_dados, 16, scv_14)
    renomeia_colunas(df_dados, 17, scv_15)
    renomeia_colunas(df_dados, 18, scv_16)

    #----------------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)
    
    # Contagem de linhas no DataFrame resultante
    num_outliers = df_outliers.shape[0]
    
    #----------------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 == 3 and v_1) or \
           (i == 4 and v_2) or \
           (i == 5 and v_3) or \
           (i == 6 and v_4) or \
           (i == 7 and v_5) or \
           (i == 8 and v_6) or \
           (i == 9 and v_7) or \
           (i == 10 and v_8) or \
           (i == 11 and v_9) or \
           (i == 12 and v_10) or \
           (i == 13 and v_11) or \
           (i == 14 and v_12) or \
           (i == 15 and v_13) or \
           (i == 16 and v_14) or \
           (i == 17 and v_15) or \
           (i == 18 and v_16):
            if i < len(df_filtrado.columns):
                X[col] = df_filtrado.iloc[:, i]
                
    #X.to_excel("X.xlsx", index=False) ---> Linha de verificação

    #---------------------------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
    fig_v8 = None
    fig_v9 = None
    fig_v10 = None
    fig_v11 = None
    fig_v12 = None
    fig_v13 = None
    fig_v14 = None
    fig_v15 = None
    fig_v16 = None

    if v_1:
        if v_d == "Valor total":
            fig_v1 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[3], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v1 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[3], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_2:
        if v_d == "Valor total":
            fig_v2 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[4], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v2 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[4], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_3:
        if v_d == "Valor total":
            fig_v3 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[5], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:    
            fig_v3 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[5], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_4:
        if v_d == "Valor total":
            fig_v4 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[6], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:   
            fig_v4 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[6], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_5:
        if v_d == "Valor total":
            fig_v5 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[7], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v5 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[7], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_6:
        if v_d == "Valor total":
            fig_v6 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[8], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v6 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[8], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_7:
        if v_d == "Valor total":
            fig_v7 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[9], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v7 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[9], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_8:
        if v_d == "Valor total":
            fig_v8 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[10], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v8 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[10], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_9:
        if v_d == "Valor total":
            fig_v9 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[11], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v9 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[11], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_10:
        if v_d == "Valor total":
            fig_v10 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[12], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v10 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[12], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_11:
        if v_d == "Valor total":
            fig_v11 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[13], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v11 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[13], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_12:
        if v_d == "Valor total":
            fig_v12 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[14], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v12 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[14], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_13:
        if v_d == "Valor total":
            fig_v13 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[15], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v13 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[15], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_14:
        if v_d == "Valor total":
            fig_v14 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[16], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v14 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[16], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_15:
        if v_d == "Valor total":
            fig_v15 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[17], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v15 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[17], df_filtrado.columns[2], df_filtrado.columns[0], "orange")
    if v_16:
        if v_d == "Valor total":
            fig_v16 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[18], df_filtrado.columns[1], df_filtrado.columns[0], "orange")
        else:
            fig_v16 = criar_grafico_dispersao(df_filtrado, df_filtrado.columns[18], df_filtrado.columns[2], df_filtrado.columns[0], "orange")

    #--------------------------Regressão Linerar------------------------------#
    
    # Variável dependente
    if v_d == "Valor total":
        y = df_filtrado.iloc[:, 1:2]
    else:
        y = df_filtrado.iloc[:, 2:3]
        
    #y.to_excel("y.xlsx", index=False) ---> Linha de verificação
    
    #---------------------ExtraTreesRegressor--------------------#
    
    scaler_x = MinMaxScaler()
    scaler_y = MinMaxScaler()

    input_scaler = scaler_x.fit(X)
    output_scaler = scaler_y.fit(y)

    x_norm = input_scaler.transform(X)
    y_norm = output_scaler.transform(np.array(y).reshape(-1, 1))

    x_norm = pd.DataFrame(x_norm, columns=X.columns)
    
    new_y = np.ravel(y_norm)

    model = ExtraTreesRegressor()
    model.fit(x_norm,new_y)

    feature_importances = model.feature_importances_

    # Criando o gráfico de influência das variáveis
    #feat_importances = pd.Series(model.feature_importances_, index=X.columns)
    #feat_importances.nlargest(16).plot(kind='barh', color = 'orange')
    #plt_1.title('Influência das Variáveis')
    #plt_1.xlabel('Importância')
    #plt_1.ylabel('Variáveis')
    #plt_1.gca().set_facecolor('#f0f0f5')
    #plt_1.tight_layout()
    #plt_1.grid(True)

    # Salvar o gráfico como imagem
    #plt_1.savefig('influencia_variaveis.png')
    
    #----------------------------Modelo----------------------------#
    
    # Adicionando uma constante às variáveis independentes (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), 8)
    desvio_padrao_residuos = round(np.std(residuos), 8)
    # Calculando Estatística F
    estatistica_F = round(resultado.fvalue, 8)
    # Obtendo Nível de Significância do Modelo
    nivel_significancia = round(resultado.f_pvalue, 8)
    # Calculando R²
    r_squared = round(resultado.rsquared, 8)
    # Calculando R² ajustado
    r_squared_adjusted = round(resultado.rsquared_adj, 8)
    # Obtendo Número de Observações
    num_observacoes = int(round(resultado.nobs, 0))
    # Calculando Coeficiente de Correlação
    coef_correlacao = round(np.sqrt(r_squared), 8)
    # 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, 8)
    p_value = round(p_value, 8)
    skewness = round(skewness, 8)
    kurtosis = round(kurtosis, 8)
    # 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}
    Correlação: {coef_correlacao}
    Número de observações: {num_observacoes}
    Número de dados não utilizados: {num_outliers}
    
    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
    if v_d == "Valor total":
        equacao_modelo =  df_filtrado.columns[1] + '='
    else:
        equacao_modelo =  df_filtrado.columns[2] + '='
    
        # 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:.8f} +"
        else:
            # Adicionar o termo à equação do modelo
            equacao_modelo += f" {coeficiente:.8f} * {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 (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, 5)
    # 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_maiores_que_2['Erro Abs'] = abs(df_maiores_que_2['Erro Padronizado'])
    
    # Listagem de pontos com resíduos > 2  
    Listagem_df_maiores_que_2 = df_maiores_que_2.iloc[:, 0].tolist()

    #------------df_correl (Valores Ajustados x Preços Observados)---------------#
    
    # Obtendo os valores previstos
    # Dados
    valores_previstos = resultado.predict(X)
    
    # Adicionando os valores previstos como uma nova coluna ao df_final
    df_final['Valores Ajustados'] = round(valores_previstos, 8)
    # Criando uma dataframe para os Valores Ajustados x Preços Observados
    if v_d == "Valor total":
        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'})
    else:
        df_correl = df_final[[df_filtrado.columns[0], df_filtrado.columns[2], 'Valores Ajustados']]
        df_correl = df_correl.rename(columns={df_filtrado.columns[2]: 'Preços Observados'})
    
    df_correl_grafico = df_correl.copy()
    # Desfazendo a conversão da escala
    if scv_d == 'lny':
        df_correl['Valores Ajustados'] = round(np.exp(df_correl['Valores Ajustados']), 8)
        df_correl['Preços Observados'] = round(np.exp(df_correl['Preços Observados']), 8)
    elif scv_d == '1/y':
        df_correl['Valores Ajustados'] = round(1 / df_correl['Valores Ajustados'], 8)
        df_correl['Preços Observados'] = round(1 / df_correl['Preços Observados'], 8)
    elif scv_d == 'y²':
        df_correl['Valores Ajustados'] = round(np.sqrt(df_correl['Valores Ajustados']), 8)
        df_correl['Preços Observados'] = round(np.sqrt(df_correl['Preços Observados']), 8)
    else:
        pass  # Nenhuma transformação é necessária
    
    df_correl['Diferença %'] = round(((df_correl['Valores Ajustados']/df_correl['Preços Observados'])-1)*100, 8)
       
    #----------------------------------Avaliação--------------------------------#
    
    try:
        # Carregando o(s) avaliando(s)
        df_aval = pd.read_excel(planilha.name, 'avaliando')
        df_aval_original = df_aval.copy()

        # avaliando(s)
        if v_d == "Valor total":
            aplicar_operacao(df_aval, scv_d, 1)
        else:
            aplicar_operacao(df_aval, scv_d, 2)
        aplicar_operacao(df_aval, scv_1, 3)
        aplicar_operacao(df_aval, scv_2, 4)
        aplicar_operacao(df_aval, scv_3, 5)
        aplicar_operacao(df_aval, scv_4, 6)
        aplicar_operacao(df_aval, scv_5, 7)
        aplicar_operacao(df_aval, scv_6, 8)
        aplicar_operacao(df_aval, scv_7, 9)
        aplicar_operacao(df_aval, scv_8, 10)
        aplicar_operacao(df_aval, scv_9, 11)
        aplicar_operacao(df_aval, scv_10, 12)
        aplicar_operacao(df_aval, scv_11, 13)
        aplicar_operacao(df_aval, scv_12, 14)
        aplicar_operacao(df_aval, scv_13, 15)
        aplicar_operacao(df_aval, scv_14, 16)
        aplicar_operacao(df_aval, scv_15, 17)
        aplicar_operacao(df_aval, scv_16, 18)

        X_aval = pd.DataFrame()

        # Iterar sobre as colunas do DataFrame df_filtrado
        for i, col in enumerate(df_aval.columns):
            # Verificar se a coluna atual deve ser adicionada com base na condição e se ela existe no DataFrame
            if (i == 3 and v_1) or \
               (i == 4 and v_2) or \
               (i == 5 and v_3) or \
               (i == 6 and v_4) or \
               (i == 7 and v_5) or \
               (i == 8 and v_6) or \
               (i == 9 and v_7) or \
               (i == 10 and v_8) or \
               (i == 11 and v_9) or \
               (i == 12 and v_10) or \
               (i == 13 and v_11) or \
               (i == 14 and v_12) or \
               (i == 15 and v_13) or \
               (i == 16 and v_14) or \
               (i == 17 and v_15) or \
               (i == 18 and v_16):
                if i < len(df_aval.columns):
                    X_aval[col] = df_aval.iloc[:, i]

        X_aval.insert(0, 'const', 1)

        # Avaliando(s)
        valores_previstos_aval = resultado.predict(X_aval)
        df_aval_original['VALOR'] = round(valores_previstos_aval, 8)

        if scv_d == 'lny':
            df_aval_original['VALOR'] = round(np.exp(df_aval_original['VALOR']), 8)
        elif scv_d == '1/y':
            df_aval_original['VALOR'] = round(1 / df_aval_original['VALOR'], 8)
        elif scv_d == 'y²':
            df_aval_original['VALOR'] = round(np.sqrt(df_aval_original['VALOR']), 8)
        else:
            pass  # Nenhuma transformação é necessária

        # Campo de arbítrio
        df_aval_original['LI_CA'] = round((df_aval_original['VALOR']*0.85), 2)
        df_aval_original['LS_CA'] = round((df_aval_original['VALOR']*1.15), 2)

        # Intervalo de Confiança de 80%
        # Calcular os intervalos de confiança para a média prevista
        intervalo_confianca = resultado.get_prediction(X_aval).summary_frame(alpha=0.2)
        # Extrair os limites inferior e superior do intervalo de confiança
        limite_inferior = intervalo_confianca['mean_ci_lower']
        limite_superior = intervalo_confianca['mean_ci_upper']
        # Adicionar as colunas ao DataFrame df_aval_original
        df_aval_original['LI_IC'] = limite_inferior.values
        df_aval_original['LS_IC'] = limite_superior.values

        if scv_d == 'lny':
            df_aval_original['LI_IC'] = round(np.exp(df_aval_original['LI_IC']), 2)
            df_aval_original['LS_IC'] = round(np.exp(df_aval_original['LS_IC']), 2)
        elif scv_d == '1/y':
            df_aval_original['LI_IC'] = round(1 / df_aval_original['LI_IC'], 2)
            df_aval_original['LS_IC'] = round(1 / df_aval_original['LS_IC'], 2)
        elif scv_d == 'y²':
            df_aval_original['LI_IC'] = round(np.sqrt(df_aval_original['LI_IC']), 2)
            df_aval_original['LS_IC'] = round(np.sqrt(df_aval_original['LS_IC']), 2)
        else:
            pass  # Nenhuma transformação é necessária

        df_aval_original['LI_IC_%'] = round(((df_aval_original['VALOR']-df_aval_original['LI_IC'])/df_aval_original['VALOR'])*100, 2)
        df_aval_original['LS_IC_%'] = round(((df_aval_original['LS_IC']-df_aval_original['VALOR'])/df_aval_original['VALOR'])*100, 2)
        df_aval_original['TOTAL_IC_%'] = round(df_aval_original['LI_IC_%'] + df_aval_original['LS_IC_%'], 2)

       # Aplicação das condições para determinar 'PRECISÃO'
        df_aval_original['PRECISÃO'] = ""  # Inicializa a coluna 'PRECISÃO'
        df_aval_original.loc[df_aval_original['TOTAL_IC_%'] <= 30, 'PRECISÃO'] = "Grau III"
        df_aval_original.loc[(df_aval_original['TOTAL_IC_%'] > 30) & (df_aval_original['TOTAL_IC_%'] <= 40), 'PRECISÃO'] = "Grau II"
        df_aval_original.loc[(df_aval_original['TOTAL_IC_%'] > 40) & (df_aval_original['TOTAL_IC_%'] <= 50), 'PRECISÃO'] = "Grau I"
        df_aval_original.loc[df_aval_original['TOTAL_IC_%'] > 50, 'PRECISÃO'] = "Fora dos critérios"

        # Retirando as colunas valor total e valor unitário
        df_aval_original = df_aval_original.drop(df_aval_original.columns[[1, 2]], axis=1)
        # Salve o DataFrame 'result' em uma planilha
        df_aval_original.to_excel("planilha_aval.xlsx", index=False)
    
    except:
        # Se a aba não existir, crie um DataFrame vazio
        df_aval_original = pd.DataFrame()
        
        # Salve o DataFrame 'result' em uma planilha
        df_aval_original.to_excel("planilha_aval.xlsx", index=False)

    #-----------------------------------------------Gráficos-------------------------------------------------#
    
    # Criando subplots
    fig, (ax1, ax2, ax3, ax4) = plt.subplots(4, 1, figsize=(10, 16))

    # Gráfico 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]))

    # Gráfico Valores Ajustados vs Preços Observados
    # Extrair os valores dos dados
    x_values = df_correl_grafico['Preços Observados']
    y_values = df_correl_grafico['Valores Ajustados']
    # Calcular a linha de tendência (regressão linear)
    slope, intercept = np.polyfit(x_values, y_values, 1)

    # Plotar o gráfico de dispersão no eixo ax4
    ax4.scatter(x_values, y_values, color='black')
    # Plotar a linha de tendência no eixo ax4
    ax4.plot(x_values, slope * x_values + intercept, color='orange', linestyle='--', linewidth=2)
    # Adicionar título e rótulos dos eixos em ax4
    ax4.set_title('Valores Ajustados vs Preços Observados')
    ax4.set_xlabel('Preços Observados')
    ax4.set_ylabel('Valores Ajustados')
    ax4.grid(True)

    # Ajustando a posição dos subplots
    plt.tight_layout()

    # Exibindo os subplots
    plt.show()

    #----------------------------------------------Pontos Influenciantes-------------------------------------------------#
    
    # 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,
    colunas,
    feature_importances,
    resultados_gerais,
    equacao_modelo,
    resultado_html,
    df_final,
    Listagem_df_maiores_que_2,
    pontos_influentes,
    df_maiores_que_2,
    df_outliers,
    df_correl,
    fig_v1,
    fig_v2,
    fig_v3,
    fig_v4,
    fig_v5,
    fig_v6,
    fig_v7,
    fig_v8,
    fig_v9,
    fig_v10,
    fig_v11,
    fig_v12,
    fig_v13,
    fig_v14,
    fig_v15,
    fig_v16,
    #'influencia_variaveis.png',
    plt,
    df_aval_original,
    'planilha_aval.xlsx',
    
    #X_aval,
    #X,
    #y,
    #'X.xlsx',
    #'y.xlsx',  
    )

    #--------------------------------------Interface---------------------------------#
    
numeros = [str(i) for i in range(0, 501)]
    
with gr.Blocks(theme=gr.themes.Default(primary_hue="yellow", secondary_hue="yellow",)) as interface:
    gr.Markdown(f"""
    <p style="text-align: left; font-family: 'Quicksand', sans-serif; font-weight: bold;">
    <b><span style='color: grey; font-size: 48px;'>aval</span></b>
    <b><span style='color: orange; font-size: 48px;'>ia</span></b>
    <b><span style='color: grey; font-size: 48px;'>.se</span></b>
    </p>
    <p style="text-align: left;"><b><span style='color: grey; font-size: 30px;'>Regressão Linear</span></b></p>
    <p style="text-align: left;"></span>Aplicativo MCDDM com tratamento científico / Você pode fazer um download de uma planilha de exemplo <a href='https://huggingface.co/spaces/DavidSB/RL/resolve/main/sample_data.xlsx' download='sample_data.xlsx'>aqui</a><br><br></p>
    """)
    
    with gr.Row():
        with gr.Column():
            with gr.Row():
                #inp_1 = gr.File(label="Upload planilha", type="file", scale=2, height=100)
                inp_1 = gr.File(label="Upload planilha", type="filepath", scale=2, height=100)
            with gr.Row():
                inp_2 = gr.Dropdown(['Valor total', 'Valor unitário',], label="VARIÁVEL DEPENDENTE", value='Valor unitário')
                inp_3 = gr.Dropdown(['y', 'lny', '1/y', 'y²'], label="Escala VARIÁVEL DEPENDENTE", value='y')
            button_1 = gr.Button("Calcular") 
            with gr.Row():
                inp_4 = gr.Checkbox(value=True, label="Var 1", scale=1)
                inp_5 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)
                inp_6 = gr.Checkbox(value=True, label="Var 2", scale=1)
                inp_7 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1) 
            with gr.Row():
                inp_8 = gr.Checkbox(value=False, label="Var 3", scale=1)
                inp_9 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)
                inp_10 = gr.Checkbox(value=False, label="Var 4", scale=1)
                inp_11 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)
            with gr.Row():
                inp_12 = gr.Checkbox(value=False, label="Var 5", scale=1)
                inp_13 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)   
                inp_14 = gr.Checkbox(value=False, label="Var 6", scale=1)
                inp_15 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)      
            with gr.Row():
                inp_16 = gr.Checkbox(value=False, label="Var 7", scale=1)
                inp_17 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)
                inp_18 = gr.Checkbox(value=False, label="Var 8", scale=1)
                inp_19 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)
            with gr.Row():
                inp_20 = gr.Checkbox(value=False, label="Var 9", scale=1)
                inp_21 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1) 
                inp_22 = gr.Checkbox(value=False, label="Var 10", scale=1)
                inp_23 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)
            with gr.Row():
                inp_24 = gr.Checkbox(value=False, label="Var 11", scale=1)
                inp_25 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)
                inp_26 = gr.Checkbox(value=False, label="Var 12", scale=1)
                inp_27 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)
            with gr.Row():
                inp_28 = gr.Checkbox(value=False, label="Var 13", scale=1)
                inp_29 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)
                inp_30 = gr.Checkbox(value=False, label="Var 14", scale=1)
                inp_31 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)
            with gr.Row():
                inp_32 = gr.Checkbox(value=False, label="Var 15", scale=1)
                inp_33 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)
                inp_34 = gr.Checkbox(value=False, label="Var 16", scale=1)
                inp_35 = gr.Dropdown(['x', 'lnx', '1/x', 'x²'], show_label=False, value='x', scale=1)
            button_2 = gr.Button("Calcular") 
            inp_36 = gr.CheckboxGroup(numeros, value=numeros[1:501], label="Selecionar dados", type="index")
            button_3 = gr.Button("Calcular")

        with gr.Column():
            out_1 = gr.Dataframe(label="Planilha de dados original", height=300)
            out_2 = gr.Textbox(label="Colunas", scale=1)
            out_32 = gr.Textbox(label="Importância das Variáveis (ExtraTreesRegressor()) ", scale=1)
            with gr.Row():
                out_3 = gr.Textbox(label="Resultados Gerais do Modelo", scale=1)
                out_4 = gr.Textbox(label="Equação do Modelo")
            out_5 = gr.HTML(label="Resultados por variável")
            out_6 = gr.Dataframe(label="Planilha Regressão Linear (Variáveis e escalas escolhidas e sem outliers)", height=300)
            out_7 = gr.Textbox(label="Listagem de dados com resíduos padronizados > 2")
            out_8 = gr.Textbox(label="Listagem de pontos Influenciantes (Distância de Cook > 1)")
            out_9 = gr.Dataframe(label="Resíduos Padronizados > 2", height=300)
            out_10 = gr.Dataframe(label="Outliers (retirados)", height=300)
            out_11 = gr.Dataframe(label="Valores Ajustados x Preços Observados", height=300)
            button_4 = gr.Button("Calcular")
            out_12 = gr.Plot(label="Gráfico Dispersão var 1")
            out_13 = gr.Plot(label="Gráfico Dispersão var 2")
            out_14 = gr.Plot(label="Gráfico Dispersão var 3")
            out_15 = gr.Plot(label="Gráfico Dispersão var 4")
            out_16 = gr.Plot(label="Gráfico Dispersão var 5")
            out_17 = gr.Plot(label="Gráfico Dispersão var 6")
            out_18 = gr.Plot(label="Gráfico Dispersão var 7")
            out_19 = gr.Plot(label="Gráfico Dispersão var 8")
            out_20 = gr.Plot(label="Gráfico Dispersão var 9")
            out_21 = gr.Plot(label="Gráfico Dispersão var 10")
            out_22 = gr.Plot(label="Gráfico Dispersão var 11")
            out_23 = gr.Plot(label="Gráfico Dispersão var 12")
            out_24 = gr.Plot(label="Gráfico Dispersão var 13")
            out_25 = gr.Plot(label="Gráfico Dispersão var 14")
            out_26 = gr.Plot(label="Gráfico Dispersão var 15")
            out_27 = gr.Plot(label="Gráfico Dispersão var 16")
            #out_28 = gr.Image(label='Gráfico de Influência das Variáveis')
            out_29 = gr.Plot(label="Análise Gráfica do Modelo de Regressão")
            out_30 = gr.Dataframe(label="Avaliação", height=300)
            out_31 = gr.components.File(label="Resultado da Avaliação")

            # outputs de verificação
            #out_off_1 = gr.Dataframe(label="X_aval", height=300)
            #out_off_2 = gr.Dataframe(label="X", height=300)
            #out_off_3 = gr.Dataframe(label="y", height=300)
            #out_off_4 = gr.components.File(label="X")
            #out_off_5 = gr.components.File(label="y")
            
    inputs = [
        inp_1, inp_2, inp_3, inp_4, inp_5, inp_6, inp_7, inp_8, inp_9, inp_10,
        inp_11, inp_12, inp_13, inp_14, inp_15, inp_16, inp_17, inp_18, inp_19, inp_20,
        inp_21, inp_22, inp_23, inp_24, inp_25, inp_26, inp_27, inp_28, inp_29, inp_30,
        inp_31, inp_32, inp_33, inp_34, inp_35, inp_36
    ]
      
    outputs = [
        out_1, out_2, out_32, out_3, out_4, out_5, out_6, out_7, out_8, out_9, out_10,
        out_11, out_12, out_13, out_14, out_15, out_16, out_17, out_18, out_19, out_20,
        out_21, out_22, out_23, out_24, out_25, out_26, out_27, out_29, out_30,
        out_31
    ]  #[out_off_1, out_off_2, out_off_3, out_off_4, out_off_5] , out_28
        
    button_1.click(avaliacao_imovel, inputs=inputs, outputs=outputs)
    button_2.click(avaliacao_imovel, inputs=inputs, outputs=outputs)
    button_3.click(avaliacao_imovel, inputs=inputs, outputs=outputs)
    button_4.click(avaliacao_imovel, inputs=inputs, outputs=outputs)

if __name__ == "__main__":
    interface.launch(debug=True)