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 """ At the command line, only need to run once to install the package via pip: $ pip install google-generativeai """ import google.generativeai as genai genai.configure(api_key="AIzaSyCm57IpC9_TTL7U3m8wvje9_3qtfxAASgI") # Set up the model generation_config = { "temperature": 0.9, "top_p": 1, "top_k": 1, "max_output_tokens": 2048, } safety_settings = [ { "category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE" }, { "category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE" }, { "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE" }, { "category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE" }, ] def generate_content_for_stat(model, stat_value, stat_name): """ Generates content for a given statistic value and its name. :param model: The generative model instance. :param stat_value: The value of the statistic, rounded to 8 decimal places. :param stat_name: The name of the statistic (e.g., "Jarque Bera", "Valor-p", "Assimetria", "Curtose"). :return: The generated text content. """ prompt = f"O que significa o valor de {stat_value} para o {stat_name}?" prompt_parts = ["input: f\"{}\"".format(prompt), "output: "] response = model.generate_content(prompt_parts) return response.text # 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) model = genai.GenerativeModel(model_name="gemini-pro", generation_config=generation_config, safety_settings=safety_settings) jarque_bera_test_text = generate_content_for_stat(model, round(jarque_bera_test, 8), "teste de Jarque Bera") p_value_text = generate_content_for_stat(model, round(p_value, 8), "Valor-p") skewness_text = generate_content_for_stat(model, round(skewness, 8), "Assimetria") kurtosis_text = generate_content_for_stat(model, round(kurtosis, 8), "Curtose") # 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} """ # Comentários sobre os resultados gerais comentarios = ( f"""#

Comentários:

- Jarque-Bera: {jarque_bera_test_text}
- Valor-p: {p_value_text}
- Assimetria (Skewness): {skewness_text}
- Curtose (Kurtosis): {kurtosis_text} """) # 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, comentarios, 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"""

aval ia .se

Regressão Linear

Aplicativo MCDDM com tratamento científico / Você pode fazer um download de uma planilha de exemplo aqui

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