Spaces:
Sleeping
Sleeping
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------------------------------# | |
list | |
# 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() | |
df_avalia = pd.DataFrame() | |
# Iterar sobre as colunas do DataFrame df_filtrado | |
df_avalia[df_original.columns[0]] = df_original.iloc[:, 0] | |
# Iterar sobre os índices das colunas do DataFrame df_original | |
for i in range(3, len(df_original.columns)): | |
# Verificar se a coluna atual deve ser adicionada com base na condição e se ela existe no DataFrame | |
if ((i + 1) <= len(df_original.columns)) and \ | |
((i + 1) in [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]): | |
col = df_original.columns[i] | |
df_avalia[col] = df_original[col] | |
# ---------------------------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 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--------------------------# | |
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) | |
#feat_importances.nlargest(16).plot(kind='barh', color = 'orange') | |
#plt.title('Influência das Variáveis') | |
#plt.xlabel('Importância') | |
#plt.ylabel('Variáveis') | |
#plt.gca().set_facecolor('#f0f0f5') | |
#plt.tight_layout() | |
#plt.grid(True) | |
# Salvar o gráfico como imagem | |
#plt.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 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() | |
# 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) | |
# Exporta modelo | |
df_exporta_modelo = df_final.copy() | |
df_final = df_final.drop(columns=['const']) | |
#--------------------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='Avalia', 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) | |
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 em uma planilha | |
df_aval_original.to_excel("planilha_aval.xlsx", index=False) | |
#-----------------------------------------------Gráficos-------------------------------------------------# | |
# Criando subplots | |
fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5, 1, figsize=(15, 20)) | |
# 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) | |
# 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) | |
# 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, | |
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 | |
#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') | |
df_original = df_model.copy() | |
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) | |
# 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 Estatística F | |
estatistica_F = round(resultado.fvalue, 8) | |
# Obtendo Nível de Significância do Modelo | |
nivel_significancia = round(resultado.f_pvalue, 8) | |
# Calculando R² | |
r_squared = round(resultado.rsquared, 8) | |
# Calculando R² ajustado | |
r_squared_adjusted = round(resultado.rsquared_adj, 8) | |
# Obtendo Número de Observações | |
num_observacoes = int(round(resultado.nobs, 0)) | |
# Calculando Coeficiente de Correlação | |
coef_correlacao = round(np.sqrt(r_squared), 8) | |
# Calculando o teste de Jarque-Bera para os resíduos | |
jarque_bera_test, p_value, skewness, kurtosis = jarque_bera(residuos) | |
# Formatando os resultados com 4 casas decimais | |
jarque_bera_test = round(jarque_bera_test, 8) | |
p_value = round(p_value, 8) | |
skewness = round(skewness, 8) | |
kurtosis = round(kurtosis, 8) | |
# Extrair os coeficientes da regressão | |
coeficientes = resultado.params | |
# Calcular a distância de Cook | |
distancia_cook = resultado.get_influence().cooks_distance[0] | |
# String com os resultados | |
resultados_gerais = f""" | |
Desvio Padrão: {desvio_padrao_residuos} | |
Estatística F: {estatistica_F} | |
Nível de Significância do Modelo: {nivel_significancia} | |
R²: {r_squared} | |
R² ajustado: {r_squared_adjusted} | |
Correlação: {coef_correlacao} | |
Número de observações: {num_observacoes} | |
Teste de Jarque-Bera: | |
- Estatística do teste: {jarque_bera_test} | |
- Valor-p: {p_value} | |
- Assimetria (Skewness): {skewness} | |
- Curtose (Kurtosis): {kurtosis} | |
""" | |
#------------------Criando uma lista com as escalas das variáveis-----------------------# | |
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}"]) | |
#-------------------------------Carregando avaliando(s)----------------------------------# | |
try: | |
# Carregando o(s) avaliando(s) | |
df_avalia = pd.read_excel(planilha.name, 'Avalia') | |
df_aval_original = df_avalia.copy() | |
X_avalia = df_avalia.drop(df_avalia.columns[[0]], axis=1) | |
X_avalia.insert(0, 'const', 1) | |
# Lista de scv's | |
scvs = [globals().get(f"scv_{i}") for i in range(1, 17)] | |
# Aplicando a operação para cada scv | |
for i, scv in enumerate(scvs, start=1): | |
if scv is not None: | |
aplicar_operacao(X_avalia, scv, i) | |
# Avaliando(s) | |
valores_previstos_aval = resultado.predict(X_avalia) | |
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_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_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': | |
f_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) | |
#----------------------------------------Outpus------------------------------------------# | |
return ( | |
df_original, | |
#y, | |
#X_model, | |
resultados_gerais, | |
#X_avalia, | |
df_aval_original, | |
'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/resolve/main/Teste.xlsx' download='Teste.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="Listagem de dados com resíduos padronizados > 2") | |
out_8 = gr.Textbox(label="Listagem de pontos Influenciantes (Distância de Cook > 1)") | |
out_9 = gr.Dataframe(label="Resíduos Padronizados > 2", height=300) | |
out_10 = gr.Dataframe(label="Outliers (retirados)", height=300) | |
out_11 = gr.Dataframe(label="Valores Ajustados x Preços Observados", height=300) | |
button_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") | |
# 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_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_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"): | |
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) | |
#inp_2 = gr.File(label="Upload planilha (AVALIANDO)", type="file", scale=1, height=100) | |
button = gr.Button("Calcular") | |
with gr.Column(): | |
out_1 = gr.Dataframe(label="Planilha de dados original", 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.Dataframe(label="X_avalia", height=300) | |
out_6 = gr.Dataframe(label="df_avalia_original", height=300) | |
out_7 = gr.components.File(label="Resultado da Avaliação") | |
inputs = [inp_1] #, inp_2] | |
outputs = [out_1, out_4, out_6, out_7] #, out_2, out_3, out_5 | |
button.click(carrega_model, inputs=inputs, outputs=outputs) | |
if __name__ == "__main__": | |
interface.launch(debug=True) |