Create app.py

app.py

@@ -0,0 +1,1253 @@
+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 seaborn as sns
+import sklearn
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.ensemble import ExtraTreesRegressor
+import xlsxwriter
+#%matplotlib inline
+
+#--------------------------------------------------FUNÇÕES ASSESSÓRIAS--------------------------------------------------------#
+
+# 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 PRINCIPAL DE GERAÇÃO DE MODELOS--------------------------------------------#
+    
+# função para a regressão linear
+def gera_model(planilha, name_model, 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,
+                     out):
+    
+    # ---------------------------------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()
+    
+   # Dataframe para criação de uma planilha de modelo para avaliação
+    df_avalia = pd.DataFrame()        
+    # Iterar sobre as colunas do DataFrame df_filtrado
+    for i, col in enumerate(df_dados.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_dados.columns):
+                df_avalia[col] = df_dados.iloc[:, i]
+                
+        # Adicionar a coluna de índice 0 de df_dados em df_avalia
+        df_limites_var = df_avalia
+        df_limites_var[df_dados.columns[0]] = df_dados.iloc[:, 0]
+                    
+    # ---------------------------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)]
+    # Transformando a lista em uma string separada por vírgula
+    string_colunas = ", ".join(colunas)
+    
+    #-----------------------------------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)----------------#
+    
+    # Convertendo a entrada em uma lista de inteiros
+    dados_out = [int(num.strip()) for num in out.split(",") if num.strip()]
+
+    # Filtrando o DataFrame para obter os outliers
+    df_outliers = df_dados[df_dados.iloc[:, 0].isin(dados_out)]
+    
+    # Removendo os outliers do DataFrame df_limites_var para calcular os valores mínimos e máximos de cada variável
+    df_limites_var = df_limites_var[~df_limites_var.iloc[:, 0].isin(dados_out)]
+    # Selecionar colunas excluindo a primeira coluna (índice 0)
+    limites = df_limites_var.columns[1:]
+    # Calcular o valor mínimo e máximo para cada coluna selecionada
+    minimos = df_limites_var[limites].min()
+    maximos = df_limites_var[limites].max()
+    # Criar o DataFrame df_limites_var com os valores mínimos e máximos
+    df_limites_var = pd.DataFrame({'Min': minimos, 'Max': maximos})
+    # Se desejar transpor para que as colunas sejam 'Min' e 'Max', e os índices sejam as colunas originais do df_dados
+    df_limites_var = df_limites_var.transpose()
+    
+    # Removendo os outliers do DataFrame original
+    df_filtrado = df_dados[~df_dados.iloc[:, 0].isin(dados_out)]
+
+    # Resetando o índice de ambos os DataFrames
+    df_filtrado.reset_index(drop=True, inplace=True)
+    df_outliers.reset_index(drop=True, 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--------------------------#
+    
+    
+    df_filtrado.to_excel("df_filtrado.xlsx", index=False) # isso pode ser retirado!
+    
+    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)
+
+    # Criando o gráfico de influência das variáveis
+    feat_importances = pd.Series(model.feature_importances_, index=X.columns)
+ 
+    #----------------------------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 o erro padronizado
+    erro_padronizado = round(residuos / desvio_padrao_residuos, 5)
+    # 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)
+    
+    # Comparação com a curva normal de resíduos
+    intervalos = [(-1.00, 1.00), (-1.64, 1.64), (-1.96, 1.96)]
+    # Inicializando a lista para armazenar os percentuais
+    percentuais = []
+    # Contando o número de resíduos dentro de cada intervalo
+    for intervalo in intervalos:
+        min_intervalo, max_intervalo = intervalo
+        count = np.sum((erro_padronizado >= min_intervalo) & (erro_padronizado <= max_intervalo))
+        percentual = round(count / len(erro_padronizado) * 100, 0)
+        percentuais.append(f"{percentual:.0f}%")
+    # Criando a string de saída
+    perc_resid = ", ".join(percentuais)
+    
+    # Teste Kolmogorov-Smirnov (KS)
+    ks_test = sm.stats.diagnostic.kstest_normal(residuos)
+    ks_test_formatted = tuple(round(val, 4) for val in ks_test)
+    # 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}
+    Testes de normalidade:
+    1) Comparação (curva normal): 
+        Ideal 68% - aceitável de 64% a 75%
+        Ideal 90% - aceitável de 88% a 95%
+        Ideal 95% - aceitável de 95% a 100%
+        Percentuais atingidos: {perc_resid}
+    2) Teste Kolmogorov-Smirnov (KS)
+      - Distribuição dos resíduos: {ks_test}
+    3) 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()
+   
+    #----------------------------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)
+    
+    # Exporta modelo
+    df_exporta_modelo = df_final.copy()
+    
+    df_final = df_final.drop(columns=['const'])
+    
+    # Matriz de correlações
+    # Calculando correlações
+    correlation_matrix = df_final.corr()
+    # Removendo a primeira coluna, assumindo que seja a primeira
+    correlation_matrix = correlation_matrix.iloc[1:, 1:]
+
+    #--------------------df_final (adiciona o erro_padronizado)------------------#
+
+
+    # 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 = ", ".join(map(str, 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)
+       
+    #-------------------------------Modelo para EXCEL---------------------------#
+    
+    output_file = 'modelo.xlsx'
+    output_file = output_file.replace('modelo', name_model)
+    with pd.ExcelWriter(output_file, engine='xlsxwriter') as writer:
+        # Salve o DataFrame 'DADOS INICIAIS' na planilha 'relatório'
+        df_original.to_excel(writer, sheet_name='Dados Originais', index=False)
+        # Salve o DataFrame 'DADOS NÃO UTILIZADOS' na planilha 'relatório'
+        df_outliers.to_excel(writer, sheet_name='Dados Não utilizados', index=False) 
+        # Salve o DataFrame 'PLANILHA OBS X CALC' na planilha 'relatório'
+        df_correl.to_excel(writer, sheet_name='Obs x Calc', index=False)
+        
+        # String com os resultados
+        resultados = pd.DataFrame({
+        '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],
+        '- Estatística Jarque-Bera': [jarque_bera_test],
+        '- Valor-p': [p_value],
+        '- Assimetria (Skewness)': [skewness],
+        '- Curtose (Kurtosis)': [kurtosis],
+        })
+        
+        # Transponha o DataFrame
+        resultados = resultados.T.reset_index()
+        # Defina os nomes das colunas do novo DataFrame
+        resultados.columns = ['Nome da Coluna', 'Valor']
+        resultados.to_excel(writer, sheet_name='Resultados', index=False)
+        
+        # Salve o DataFrame 'DADOS PARA REGRESSÃO' na planilha 'relatório'
+        df_exporta_modelo.to_excel(writer, sheet_name='Model', index=False)
+        
+        # Salve o DataFrame 'PLANILHA MODELO PARA AVALIAÇÃO' na planilha 'relatório'
+        df_avalia.to_excel(writer, sheet_name='avaliando', index=False)
+    
+    #----------------------------------Avaliação--------------------------------#
+    
+    try:
+        # Carregando o(s) avaliando(s)
+        df_aval = pd.read_excel(planilha.name, 'avaliando')
+        #df_aval_original = df_aval.copy()
+
+        # avaliando(s)
+        df_aval_final = df_aval.copy()
+        
+        df_aval_original = pd.DataFrame()
+        
+        # Para criar um dataframe final sem as escalas convertidas e apenas com as variáveis escolhidas
+        for i, col in enumerate(df_aval_final.columns):
+            # Verificar se a coluna atual deve ser adicionada com base na condição e se ela existe no DataFrame
+            if (i == 0 and v_1) or \
+               (i == 1 and v_2) or \
+               (i == 2 and v_3) or \
+               (i == 3 and v_4) or \
+               (i == 4 and v_5) or \
+               (i == 5 and v_6) or \
+               (i == 6 and v_7) or \
+               (i == 7 and v_8) or \
+               (i == 8 and v_9) or \
+               (i == 9 and v_10) or \
+               (i == 10 and v_11) or \
+               (i == 11 and v_12) or \
+               (i == 12 and v_13) or \
+               (i == 13 and v_14) or \
+               (i == 14 and v_15) or \
+               (i == 15 and v_16):
+
+                if i < len(df_aval_final.columns):
+                    df_aval_original[col] = df_aval_final.iloc[:, i]
+        
+        # alterar escalas (para rodar o modelo)
+        aplicar_operacao(df_aval, scv_1, 0)
+        aplicar_operacao(df_aval, scv_2, 1)
+        aplicar_operacao(df_aval, scv_3, 2)
+        aplicar_operacao(df_aval, scv_4, 3)
+        aplicar_operacao(df_aval, scv_5, 4)
+        aplicar_operacao(df_aval, scv_6, 5)
+        aplicar_operacao(df_aval, scv_7, 6)
+        aplicar_operacao(df_aval, scv_8, 7)
+        aplicar_operacao(df_aval, scv_9, 8)
+        aplicar_operacao(df_aval, scv_10, 9)
+        aplicar_operacao(df_aval, scv_11, 10)
+        aplicar_operacao(df_aval, scv_12, 11)
+        aplicar_operacao(df_aval, scv_13, 12)
+        aplicar_operacao(df_aval, scv_14, 13)
+        aplicar_operacao(df_aval, scv_15, 14)
+        aplicar_operacao(df_aval, scv_16, 15)
+
+        # Criando um dataframe apenas com as variáveis escolhidas e com as escalas convertidas.
+        X_aval = pd.DataFrame()
+        # Iterar sobre as colunas do DataFrame para fazer a predição de valor 
+        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 == 0 and v_1) or \
+               (i == 1 and v_2) or \
+               (i == 2 and v_3) or \
+               (i == 3 and v_4) or \
+               (i == 4 and v_5) or \
+               (i == 5 and v_6) or \
+               (i == 6 and v_7) or \
+               (i == 7 and v_8) or \
+               (i == 8 and v_9) or \
+               (i == 9 and v_10) or \
+               (i == 10 and v_11) or \
+               (i == 11 and v_12) or \
+               (i == 12 and v_13) or \
+               (i == 13 and v_14) or \
+               (i == 14 and v_15) or \
+               (i == 15 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 em uma planilha
+        df_aval_original.to_excel("planilha_aval.xlsx", index=False)
+
+    #-----------------------------------------------Gráficos-------------------------------------------------#
+    
+    # Criando subplots
+    fig, (ax1, ax2, ax3, ax4, ax5, ax6) = plt.subplots(6, 1, figsize=(15, 40))
+
+    # 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]), xytext=(5,5),
+                             textcoords='offset points', fontsize=20, color='darkred')
+
+    # 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)
+
+    # 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)
+
+    # Criando o gráfico de influência das variáveis
+    feat_importances.nlargest(16).plot(kind='barh', color='orange', ax=ax5)
+    ax5.set_title('Influência das Variáveis')
+    ax5.set_xlabel('Importância')
+    ax5.set_ylabel('Variáveis')
+    ax5.grid(True)
+    
+    # Plotando o gráfico de correlações
+    ax6.set_title('Matriz de Correlação')
+    # Definindo uma paleta de cores laranjas
+    palette = sns.light_palette("orange", as_cmap=True)
+    # Plotando o gráfico de correlações com a paleta de cores laranjas
+    sns.heatmap(correlation_matrix, annot=True, cmap=palette, linewidths=0.5, ax=ax6, annot_kws={"size": 12})
+
+
+    # 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
+            
+    # Transformando a lista em uma string separada por vírgula
+    string_pontos_influentes = ", ".join(map(str, pontos_influentes))
+
+    #---------------------------------------Outputs----------------------------------#
+    
+    return (
+    df_original,
+    string_colunas,
+    resultados_gerais,
+    equacao_modelo,
+    resultado_html,
+    df_final,
+    Listagem_df_maiores_que_2,
+    string_pontos_influentes,
+    df_maiores_que_2,
+    df_outliers,
+    df_correl,
+    df_limites_var,
+    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,
+    plt,
+    df_aval_original,
+    'planilha_aval.xlsx',
+    output_file,
+    'df_filtrado.xlsx',
+    
+    
+    #X_aval,
+    #X,
+    #y,
+    #'X.xlsx',
+    #'y.xlsx',  
+    )
+
+
+#-----------------------------------------FUNÇÃO PRINCIPAL DE CARREGAMENTO DE MODELOS-----------------------------------------#
+
+# função para a regressão linear
+def carrega_model(planilha):
+
+    #----------------------------Carregando modelo--------------------------------#
+    
+    df_model = pd.read_excel(planilha.name, 'Model')
+    
+    y = df_model.iloc[:, 1:2]
+    # Para converter os valores calculados posteriormente
+    cabecalho_lista = list(y.columns)
+    cabecalho_lista_transformado = ['lny' if 'ln(' in col else '1/y' if '1/(' in col else 'y²' if '(' in col and ')' in col and '²' in col else 'y' for col in cabecalho_lista]
+    scv_d = cabecalho_lista_transformado[0]
+    
+    
+    X_model = df_model.drop(df_model.columns[[0, 1]], axis=1)
+    cabecalho_lista = list(X_model.columns)
+    cabecalho_lista_transformado = ['lnx' if 'ln(' in col else '1/x' if '1/(' in col else 'x²' if '(' in col and ')' in col and '²' in col else 'x' for col in cabecalho_lista]
+    const = cabecalho_lista_transformado[0]
+    v = cabecalho_lista_transformado[1:]  # Exclui o primeiro elemento da lista
+    # Atribuindo os valores restantes a variáveis v_1, v_2, v_3, ...
+    for i, valor in enumerate(v, start=1):
+        globals()[f"scv_{i}"] = valor
+    # Imprimindo os valores armazenados
+    print("const:", const)
+    for i in range(1, len(v) + 1):
+        print(f"scv_{i}:", globals()[f"scv_{i}"])
+    
+    # Inicializando o modelo de regressão linear
+    modelo = sm.OLS(y, X_model)
+
+    # 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 o erro padronizado
+    erro_padronizado = round(residuos / desvio_padrao_residuos, 5)
+    # 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)
+    
+    # Comparação com a curva normal de resíduos
+    intervalos = [(-1.00, 1.00), (-1.64, 1.64), (-1.96, 1.96)]
+    # Inicializando a lista para armazenar os percentuais
+    percentuais = []
+    # Contando o número de resíduos dentro de cada intervalo
+    for intervalo in intervalos:
+        min_intervalo, max_intervalo = intervalo
+        count = np.sum((erro_padronizado >= min_intervalo) & (erro_padronizado <= max_intervalo))
+        percentual = round(count / len(erro_padronizado) * 100, 0)
+        percentuais.append(f"{percentual:.0f}%")
+    # Criando a string de saída
+    perc_resid = ", ".join(percentuais)
+    
+    # Teste Kolmogorov-Smirnov (KS)
+    ks_test = sm.stats.diagnostic.kstest_normal(residuos)
+    ks_test_formatted = tuple(round(val, 4) for val in ks_test)
+    # 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}
+    Testes de normalidade:
+    1) Comparação (curva normal): 
+        Ideal 68% - aceitável de 64% a 75%
+        Ideal 90% - aceitável de 88% a 95%
+        Ideal 95% - aceitável de 95% a 100%
+        Percentuais atingidos: {perc_resid}
+    2) Teste Kolmogorov-Smirnov (KS)
+      - Distribuição dos resíduos: {ks_test}
+    3) Teste de Jarque-Bera:
+      - Estatística do teste: {jarque_bera_test}
+      - Valor-p: {p_value}
+      - Assimetria (Skewness): {skewness}
+      - Curtose (Kurtosis): {kurtosis}
+    """
+    
+    # Exibindo estatísticas do modelo
+    resultado_summary = resultado.summary()
+    resultado_html = resultado.summary().tables[1].as_html()
+    
+    #-------------------------------Carregando avaliando(s)----------------------------------#    
+    
+    try:
+        # Carregando o(s) avaliando(s)
+        df_aval = pd.read_excel(planilha.name, 'avaliando')
+        
+        X_avalia = df_aval.copy()
+        X_avalia.insert(0, 'const', 1)
+          
+        num_colunas = len(X_avalia.columns)
+
+        # Iterando sobre as colunas preenchidas
+        for col_index in range(1, num_colunas + 1):
+            # Obtendo o nome do SCV correspondente a esta coluna
+            scv_nome = f"scv_{col_index}"
+
+            # Verificando se o SCV correspondente existe
+            if scv_nome in globals():
+                scv = globals()[scv_nome]
+                aplicar_operacao(X_avalia, scv, col_index)
+        
+        # Avaliando(s)
+        valores_previstos_aval = resultado.predict(X_avalia)
+        y_pred = pd.DataFrame(valores_previstos_aval, columns=['VALOR'])
+    
+        df_avalia = pd.concat([df_aval, y_pred], axis=1)
+        
+        if scv_d == 'lny':
+            df_avalia['VALOR'] = round(np.exp(df_avalia['VALOR']), 8)
+        elif scv_d == '1/y':
+            df_avalia['VALOR'] = round(1 / df_avalia['VALOR'], 8)
+        elif scv_d == 'y²':
+            df_avalia['VALOR'] = round(np.sqrt(df_avalia['VALOR']), 8)
+        else:
+            pass  # Nenhuma transformação é necessária
+
+        # Campo de arbítrio
+        df_avalia['LI_CA'] = round((df_avalia['VALOR']*0.85), 2)
+        df_avalia['LS_CA'] = round((df_avalia['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_avalia).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_avalia['LI_IC'] = limite_inferior.values
+        df_avalia['LS_IC'] = limite_superior.values
+
+        if scv_d == 'lny':
+            df_avalia['LI_IC'] = round(np.exp(df_avalia['LI_IC']), 2)
+            df_avalia['LS_IC'] = round(np.exp(df_avalia['LS_IC']), 2)
+        elif scv_d == '1/y':
+            df_avalia['LI_IC'] = round(1 / df_avalia['LI_IC'], 2)
+            df_avalia['LS_IC'] = round(1 / df_avalia['LS_IC'], 2)
+        elif scv_d == 'y²':
+            df_avalia['LI_IC'] = round(np.sqrt(df_avalia['LI_IC']), 2)
+            df_avalia['LS_IC'] = round(np.sqrt(df_avalia['LS_IC']), 2)
+        else:
+            pass  # Nenhuma transformação é necessária
+
+        df_avalia['LI_IC_%'] = round(((df_avalia['VALOR']-df_avalia['LI_IC'])/df_avalia['VALOR'])*100, 2)
+        df_avalia['LS_IC_%'] = round(((df_avalia['LS_IC']-df_avalia['VALOR'])/df_avalia['VALOR'])*100, 2)
+        df_avalia['TOTAL_IC_%'] = round(df_avalia['LI_IC_%'] + df_avalia['LS_IC_%'], 2)
+
+       # Aplicação das condições para determinar 'PRECISÃO'
+        df_avalia['PRECISÃO'] = ""  # Inicializa a coluna 'PRECISÃO'
+        df_avalia.loc[df_avalia['TOTAL_IC_%'] <= 30, 'PRECISÃO'] = "Grau III"
+        df_avalia.loc[(df_avalia['TOTAL_IC_%'] > 30) & (df_avalia['TOTAL_IC_%'] <= 40), 'PRECISÃO'] = "Grau II"
+        df_avalia.loc[(df_avalia['TOTAL_IC_%'] > 40) & (df_avalia['TOTAL_IC_%'] <= 50), 'PRECISÃO'] = "Grau I"
+        df_avalia.loc[df_avalia['TOTAL_IC_%'] > 50, 'PRECISÃO'] = "Fora dos critérios"
+        
+        # Salve o DataFrame 'result' em uma planilha
+        df_avalia.to_excel("planilha_aval.xlsx", index=False)
+    
+    except:
+        # Se a aba não existir, crie um DataFrame vazio
+        df_avalia = pd.DataFrame()
+        
+        # Salve o DataFrame em uma planilha
+        df_avalia.to_excel("planilha_aval.xlsx", index=False)
+
+    #----------------------------------------Outpus------------------------------------------#     
+    
+    return (
+    df_model,
+    #y,
+    #X_model,
+    resultados_gerais,
+    resultado_html,
+    #X_avalia, 
+    df_avalia,
+    'planilha_aval.xlsx'
+    )      
+
+#----------------------------------------------------------INTERFACES----------------------------------------------------------#
+ 
+with gr.Blocks(theme=gr.themes.Monochrome(primary_hue="yellow", secondary_hue="yellow",)) as interface:
+    gr.Markdown(f"""
+    <p style="text-align: left;">
+    <b><span style='color: grey; font-size: 35px;'>aval</span></b>
+    <b><span style='color: orange; font-size: 35px;'>ia</span></b>
+    <b><span style='color: grey; font-size: 35px;'>.se</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/avalia.se_RL_Tabs_v4/resolve/main/BD_MODELO.xlsx' download='BD_MODELO.xlsx'>aqui</a><br><br></p>
+    """)
+    with gr.Tab("Gera Modelo"):
+        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_37 = gr.Textbox(label="Nome do modelo", scale=1)
+                    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", 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.Textbox(label="Manipular dados (separados por vírgula)", type="text", info = "Após rodar o modelo a primeira vez, por meio deste campo podem ser retirados outliers, pontos influenciantes, etc")
+
+            with gr.Column():
+                out_1 = gr.Dataframe(label="Planilha de dados original", height=300)
+                out_2 = gr.Textbox(label="Colunas", scale=1)
+                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)
+                with gr.Row():
+                    out_7 = gr.Textbox(label="Dados com resíduos padronizados > 2")
+                    out_8 = gr.Textbox(label="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)
+                out_34 = gr.Dataframe(label="Máximos e Mínimos por variável", height=300)
+                button_3 = 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(show_label=False)
+                out_29 = gr.Plot(show_label=False)
+                out_30 = gr.Dataframe(label="Avaliação", height=300)
+                out_31 = gr.components.File(label="Resultado da Avaliação")
+                out_32 = gr.components.File(label="Exportar Modelo")
+                out_33 = gr.components.File(label="df_filtrado")
+
+                # 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_37, 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_3, out_4, out_5, out_6, out_7, out_8, out_9, out_10,
+        out_11, out_34, 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_32, out_33
+    ]  #[out_off_1, out_off_2, out_off_3, out_off_4, out_off_5] , out_28
+        
+    button_1.click(gera_model, inputs=inputs, outputs=outputs)
+    button_2.click(gera_model, inputs=inputs, outputs=outputs)
+    button_3.click(gera_model, inputs=inputs, outputs=outputs)
+    
+  #--------------------------------------------#        
+    with gr.Tab("Carrega Modelo / Avaliação"):
+        with gr.Row():
+            with gr.Column():
+                with gr.Row():
+                    #inp_1 = gr.File(label="Upload planilha (MODELO)", type="file", scale=1, height=100)
+                    inp_1 = gr.File(label="Upload planilha (MODELO)", type="filepath", scale=1, height=100)
+                button = gr.Button("Calcular")
+
+            with gr.Column():
+                out_1 = gr.Dataframe(label="Dados utilizados no modelo", height=300)
+                #out_2 = gr.Dataframe(label="y", height=300)
+                #out_3 = gr.Dataframe(label="X", height=300)
+                out_4 = gr.Textbox(label="Resultados Gerais do Modelo", scale=1)
+                out_5 = gr.HTML(label="Resultados por variável")
+                #out_6 = gr.Dataframe(label="X_avalia", height=300)
+                out_7 = gr.Dataframe(label="Planilha Avaliação", height=300)
+                out_8 = gr.components.File(label="Resultado da Avaliação")
+            
+    inputs = [inp_1]
+      
+    outputs = [out_1, out_4, out_5, out_7, out_8] # outputs de verificação out_2, out_3, out_6
+        
+    button.click(carrega_model, inputs=inputs, outputs=outputs)
+
+
+if __name__ == "__main__":
+    interface.launch(debug=True)