Spaces:
Sleeping
Sleeping
| # importando bibliotecas necessárias | |
| import pandas as pd | |
| import numpy as np | |
| import gradio as gr | |
| from gradio import components | |
| from gradio import Interface | |
| import xlsxwriter | |
| def renderizar_dataframe(df): | |
| try: | |
| # Renderize o DataFrame como uma tabela HTML com rolagem horizontal | |
| df_html = df.to_html(classes='table table-striped', | |
| table_id='planilha', | |
| escape=False) # Não escapar caracteres especiais | |
| # Use uma div com estilo CSS para permitir a rolagem horizontal | |
| tabela_com_rolagem = f'<div style="overflow-x:auto;">{df_html}</div>' | |
| # Retorna a tabela com rolagem como HTML | |
| return tabela_com_rolagem | |
| except Exception as e: | |
| return f"Erro ao processar o DataFrame: {str(e)}" | |
| # Função de avaliação do imóvel | |
| def avaliacao_imovel(planilha, num_linhas_desejadas=10): | |
| # Lendo a aba 'avaliando' da planilha | |
| df_avaliando = pd.read_excel(planilha.name, 'avaliando') | |
| # Lendo a aba 'dados' da planilha, limitando o número de linhas | |
| df_dados = pd.read_excel(planilha.name, 'dados').iloc[:int(num_linhas_desejadas)] | |
| #-----------------# | |
| # fator de atratividade local (fal) | |
| df_transp = df_dados.copy() | |
| df_transp = df_transp[['Atratividade local']] | |
| df_transp['fal'] = round(df_avaliando['Atratividade local'][0] / df_transp['Atratividade local'], 2) | |
| df_transp = df_transp[['fal']] | |
| #-----------------# | |
| # fator de correção da área construída (fac) | |
| df_area_const = df_dados.copy() | |
| df_area_const = df_area_const[['Área Construída']] | |
| df_area_const['razao'] = (df_area_const['Área Construída'] / df_avaliando['Área Construída'][0]) | |
| df_area_const['dif'] = abs(df_area_const['Área Construída'] - df_avaliando['Área Construída'][0]) | |
| # 30% da área do terreno do avaliando | |
| x_ac = 0.3 * df_avaliando['Área Construída'][0] | |
| # coeficiente n conforme a diferença entre a área do avaliando e dos dados | |
| df_area_const['n'] = df_area_const['dif'].apply(lambda dif: 0.250 if dif <= x_ac else 0.125) | |
| df_area_const['fac'] = round((df_area_const['razao']) ** (df_area_const['n']), 2) | |
| df_area_const = df_area_const[['fac']] | |
| #-----------------# | |
| # fator de correção da área do terreno (fat) | |
| df_area_terreno = df_dados.copy() | |
| df_area_terreno = df_area_terreno[['Área Terreno']] | |
| df_area_terreno['razao'] = (df_area_terreno['Área Terreno'] / df_avaliando['Área Terreno'][0]) | |
| df_area_terreno['dif'] = abs(df_area_terreno['Área Terreno'] - df_avaliando['Área Terreno'][0]) | |
| # 30% da área do terreno do avaliando | |
| x_at = 0.3 * df_avaliando['Área Terreno'][0] | |
| # coeficiente n conforme a diferença entre a área do avaliando e dos dados | |
| df_area_terreno['n'] = df_area_terreno['dif'].apply(lambda dif: 0.250 if dif <= x_at else 0.125) | |
| df_area_terreno['fat'] = round((df_area_terreno['razao']) ** (df_area_terreno['n']), 2) | |
| df_area_terreno = df_area_terreno[['fat']] | |
| #-----------------# | |
| # fator idade aparente e conservação (fic) | |
| # dicionário padrão construtivo | |
| dict_ic = { | |
| 'id<5_novo': 1.00, | |
| 'id<5_bom': 0.95, | |
| 'id<5_reparos simples': 0.80, | |
| 'id<5_reparos importantes': 0.45, | |
| 'id entre 6 e 10_novo': 0.95, | |
| 'id entre 6 e 10_bom': 0.90, | |
| 'id entre 6 e 10_reparos simples': 0.75, | |
| 'id entre 6 e 10_reparos importantes': 0.40, | |
| 'id entre 11 e 30_novo': 0.85, | |
| 'id entre 11 e 30_bom': 0.80, | |
| 'id entre 11 e 30_reparos simples': 0.65, | |
| 'id entre 11 e 30_reparos importantes': 0.35, | |
| 'id entre 31 e 50_novo': 0.55, | |
| 'id entre 31 e 50_bom': 0.50, | |
| 'id entre 31 e 50_reparos simples': 0.45, | |
| 'id entre 31 e 50_reparos importantes': 0.25, | |
| 'id>50_novo': 0.30, | |
| 'id>50_bom': 0.20, | |
| 'id>50_reparos simples': 0.15, | |
| 'id>50_reparos importantes': 0.10 | |
| } | |
| # cria dataframe apenas com as colunas necessárias a partir do dataframe dos dados | |
| df_idade_cons = df_dados.copy() | |
| df_idade_cons = df_idade_cons[['Idade aparente e conservação']] | |
| # cria dataframe apenas com as colunas necessárias a partir do dataframe do avaliando | |
| df_idade_cons_aval = df_avaliando.copy() | |
| df_idade_cons_aval = df_idade_cons_aval[['Idade aparente e conservação']] | |
| # Função para mapear os valores de idade aparente e conservação para cod_id_cons usando o dicionário | |
| def mapear_cod_id_cons(id_cons): | |
| return dict_ic.get(id_cons, 0) | |
| # Aplicando a função para criar a coluna cod_topo em df_dados e df_avaliando | |
| df_idade_cons['coef_ic'] = df_idade_cons['Idade aparente e conservação'].apply(mapear_cod_id_cons) | |
| df_idade_cons_aval['coef_ic'] = df_idade_cons_aval['Idade aparente e conservação'].apply(mapear_cod_id_cons) | |
| df_idade_cons['fic'] = round(df_idade_cons_aval['coef_ic'][0] / df_idade_cons['coef_ic'],2) | |
| df_idade_cons = df_idade_cons[['fic']] | |
| #-----------------# | |
| # fator padrão construtivo (fpd) | |
| # dicionário padrão construtivo | |
| dict_pad = { | |
| 'baixo_residencial': 1.00, | |
| 'médio/baixo_residencial': 1.15, | |
| 'médio_residencial': 1.30, | |
| 'médio/alto_residencial': 1.45, | |
| 'alto_residencial': 1.65, | |
| 'baixo_comercial': 1.00, | |
| 'médio/baixo_comercial': 1.08, | |
| 'médio_comercial': 1.15, | |
| 'médio/alto_comercial': 1.25, | |
| 'alto_comercial': 1.40 | |
| } | |
| # cria dataframe apenas com as colunas necessárias a partir do dataframe dos dados | |
| df_padrao = df_dados.copy() | |
| df_padrao = df_padrao[['Padrão construtivo']] | |
| # cria dataframe apenas com as colunas necessárias a partir do dataframe do avaliando | |
| df_padrao_aval = df_avaliando.copy() | |
| df_padrao_aval = df_padrao_aval[['Padrão construtivo']] | |
| # Função para mapear os valores de padrão construtivo para cod_pad usando o dicionário | |
| def mapear_cod_pad(padrao): | |
| return dict_pad.get(padrao, 0) # 0 como valor padrão caso a topografia não esteja no dicionário | |
| # Aplicando a função para criar a coluna cod_topo em df_dados e df_avaliando | |
| df_padrao['coef_pd'] = df_padrao['Padrão construtivo'].apply(mapear_cod_pad) | |
| df_padrao_aval['coef_pd'] = df_padrao_aval['Padrão construtivo'].apply(mapear_cod_pad) | |
| df_padrao['fpd'] = round(df_padrao_aval['coef_pd'][0]/df_padrao['coef_pd'],2) | |
| df_padrao = df_padrao[['fpd']] | |
| #-----------------# | |
| # fator vagas de estacionamento (fvg) | |
| df_vaga = df_dados[['Vagas']].copy() | |
| df_vaga_aval = df_avaliando[['Vagas']].copy() | |
| # Calcular a diferença entre as colunas 'Vagas' nos dois DataFrames | |
| df_vaga['dif'] = df_vaga['Vagas'] - df_vaga_aval['Vagas'][0] | |
| # Definir a função para o cálculo da coluna 'fvg' | |
| def calculate_fcg(dif, vagas): | |
| if dif == 0: | |
| return 1 | |
| else: | |
| return 1 - 0.067 * dif | |
| # Aplicar a função para calcular a coluna 'fcg' | |
| df_vaga['fvg'] = round(df_vaga.apply(lambda row: calculate_fcg(row['dif'], row['Vagas']), axis=1), 2) | |
| df_vaga = df_vaga[['fvg']] | |
| #-----------------# | |
| # fator extra (à critério do avaliador) (fex) | |
| df_exc = df_dados.copy() | |
| df_exc = df_exc[['Coeficiente extra']] | |
| df_exc['fex'] = round(df_avaliando['Coeficiente extra'][0] / df_exc['Coeficiente extra'], 2) | |
| df_exc = df_exc[['fex']] | |
| #-----------------# | |
| # concatemando o dataframe principal com as dataframes dos fatores | |
| result = pd.concat([df_dados, df_transp, df_area_const, df_area_terreno, df_idade_cons, df_padrao, df_vaga, df_exc], axis=1) | |
| result['Valor_desc'] = round(result['Valor']*(result['fof']), 2) | |
| result['Vunit'] = round((result['Valor_desc']/result['Área Construída']), 2) | |
| result = result[['Atratividade local', 'Área Construída', 'Área Terreno', | |
| 'Idade aparente e conservação', 'Padrão construtivo', 'Vagas', | |
| 'Coeficiente extra', 'Valor', 'fof','Valor_desc', 'Vunit','fal', 'fac', 'fat', 'fic', | |
| 'fpd', 'fvg', 'fex']] | |
| result['Vunit_hom'] = round(result['Vunit'] * result['fal'] * \ | |
| result['fac'] * \ | |
| result['fat'] * \ | |
| result['fic'] * \ | |
| result['fpd'] * \ | |
| result['fvg'] * \ | |
| result['fex'], 2) | |
| # RESULTADOS ESTATÍSTICOS INICIAIS | |
| num = len(result) | |
| media = round(result['Vunit_hom'].mean(), 2) | |
| valor_hom_máximo = round(result['Vunit_hom'].max(), 2) | |
| valor_hom_mínimo = round(result['Vunit_hom'].min(), 2) | |
| limite_superior = round(media * 1.3 ,2) | |
| limite_inferior = round(media * 0.7 ,2) | |
| desvio_padrao = round(result['Vunit_hom'].std(), 2) | |
| coef_variacao = round((desvio_padrao / media)*100, 2) | |
| # CRITÉRIO DE CHAUVENET | |
| dict_vc = { | |
| 2: 1.15,3: 1.38,4: 1.54,5: 1.65,6: 1.73,7: 1.80,8: 1.85,9: 1.91,10: 1.96,11: 1.99, | |
| 12: 2.03,13: 2.06,14: 2.10,15: 2.13,16: 2.16,17: 2.18,18: 2.20,19: 2.21,20: 2.24, | |
| 21: 2.26,22: 2.28,23: 2.30,24: 2.31,25: 2.33,26: 2.35,27: 2.36,28: 2.37,29: 2.38, | |
| 30: 2.93 | |
| } | |
| vc = dict_vc[num] | |
| vc | |
| result['z-score'] = abs((result['Vunit_hom'] - media) / desvio_padrao) | |
| result['Status'] = np.where(result['z-score'] > vc, 'rejeitado', 'aceito') | |
| # para gerar uma tabela na interface | |
| result_render = renderizar_dataframe(result) | |
| # DADOS REMOVIDOS | |
| outliers = result[result['Status'] == 'rejeitado'] | |
| # REMOÇÃO DE OUTLIERS PELO CRITÉRIO DE CHAUVENET | |
| result = result[result['Status'] != 'rejeitado'] | |
| # RESULTADOS ESTATÍSTICOS FINAIS | |
| num = len(result) | |
| dados_outliers = len(outliers) | |
| media = round(result['Vunit_hom'].mean(), 2) | |
| valor_hom_máximo = round(result['Vunit_hom'].max(), 2) | |
| valor_hom_mínimo = round(result['Vunit_hom'].min(), 2) | |
| limite_superior = round(media * 1.3 ,2) | |
| limite_inferior = round(media * 0.7 ,2) | |
| desvio_padrao = round(result['Vunit_hom'].std(), 2) | |
| coef_variacao = round((desvio_padrao / media)*100, 2) | |
| # Crie uma string formatada com os RESULTADOS ESTATÍSTICOS FINAIS | |
| resultados_formatados = f""" | |
| Número de dados: {num} dados | |
| Valor Crítico (Chauvenet): {vc} | |
| Outliers: {dados_outliers} dado(s) | |
| Média saneada: {media} R$/m² | |
| Valor máximo: {valor_hom_máximo} R$/m² | |
| Valor mínimo: {valor_hom_mínimo} R$/m² | |
| Lim superior (Média*1,3): {limite_superior} R$/m² | |
| Lim inferior (Média*0,7): {limite_inferior} R$/m² | |
| Desvio padrão: {desvio_padrao} R$/m² | |
| Coeficiente variação: {coef_variacao} % | |
| """ | |
| # INTEREVALO DE CONFIANÇA DE 80% | |
| # importando a tabela de t de student | |
| df_t = pd.read_excel('TABELAS.xlsx','t') | |
| # número de dados | |
| n = result.shape[0]-1 | |
| # "t" de student | |
| gl = df_t[df_t['gl (n-1)'] == n] | |
| tc = gl.iloc[0, 3] | |
| # limites infeiror e superior do IC de 80% e amplitude | |
| li_IC = round(media - tc * ((desvio_padrao/(num-1)**0.5)), 2) | |
| ls_IC = round(media + tc * ((desvio_padrao/(num-1)**0.5)), 2) | |
| A = round(ls_IC - li_IC, 2) | |
| A_perc = round((A / media)*100, 2) | |
| def calcular_grau(a): | |
| if a <= 30: | |
| return "Grau III" | |
| elif a <= 40: | |
| return "Grau II" | |
| elif a <= 50: | |
| return "Grau I" | |
| else: | |
| return "Fora dos critérios" | |
| precisao = calcular_grau(A_perc) | |
| # Crie uma string formatada com o INTEREVALO DE CONFIANÇA DE 80% | |
| intervalo_confiança = f""" | |
| t student: {tc} | |
| Média saneada: {media} R$/m² | |
| limite infeiror IC_80%: {li_IC} R$/m² | |
| limite superior IC_80%: {ls_IC} R$/m² | |
| Aplitude: {A} R$/m² | |
| Aplitude percentual: {A_perc} % | |
| Grau de Precisão: {precisao} | |
| """ | |
| # VALOR CALCULADO A PARTIR DOS VALORES HOMOGENEIZADOS UTILIZANDO O CRITÉRIO DE CLASSAS D0 ABUNAHMAN | |
| # dividindo a amplitude em 3 classes | |
| C = round((A / 3), 2) | |
| # calculando os intervalos das 3 classes | |
| C1 = round(result[(result['Vunit_hom'] >= li_IC) & (result['Vunit_hom'] <= li_IC + C)]['Vunit_hom'].count(), 2) | |
| C2 = round(result[(result['Vunit_hom'] >= li_IC + C) & (result['Vunit_hom'] <= ls_IC - C)]['Vunit_hom'].count(), 2) | |
| C3 = round(result[(result['Vunit_hom'] >= ls_IC - C) & (result['Vunit_hom'] <= ls_IC)]['Vunit_hom'].count(), 2) | |
| # crinado listas com os valores encontrados nos intervalos | |
| list_C1 = result[(result['Vunit_hom'] >= li_IC) & (result['Vunit_hom'] <= li_IC + C)]['Vunit_hom'].tolist() | |
| list_C2 = result[(result['Vunit_hom'] >= li_IC + C) & (result['Vunit_hom'] <= ls_IC - C)]['Vunit_hom'].tolist() | |
| list_C3 = result[(result['Vunit_hom'] >= ls_IC - C) & (result['Vunit_hom'] <= ls_IC)]['Vunit_hom'].tolist() | |
| pC1 = round(sum(C1 * elemento for elemento in list_C1), 2) | |
| pC2 = round(sum(C2 * elemento for elemento in list_C2), 2) | |
| pC3 = round(sum(C3 * elemento for elemento in list_C3), 2) | |
| divisor = ((C1 * C1) if C1 != 0 else 0) +((C2 * C2) if C2 != 0 else 0) + ((C3 * C3) if C3 != 0 else 0) | |
| media_pond = round((pC1 + pC2 + pC3) / divisor, 2) | |
| # VALORES CALCULADOS | |
| Valor_imóvel = round(media * df_avaliando['Área Construída'], 2).item() | |
| Valor_imóvel_2 = round((media_pond) * df_avaliando['Área Construída'], 2).item() | |
| # Crie uma string formatada com os VALORES CALCULADOS | |
| valores_finais = f""" | |
| Área avaliando: {df_avaliando['Área Construída'].item()} m² | |
| Valor (média simples): R$ {Valor_imóvel} | |
| Vu (média simples): R$ {media} | |
| Valor (critério classes): R$ {Valor_imóvel_2} | |
| Vu (critério classes): R$ {media_pond} | |
| """ | |
| #-----------------# | |
| # OUTPUTS | |
| # Crie um objeto ExcelWriter para escrever no arquivo Excel | |
| output_file = 'relatório.xlsx' | |
| with pd.ExcelWriter(output_file, engine='xlsxwriter') as writer: | |
| # Salve o DataFrame 'avaliando' na planilha 'relatório' | |
| df_avaliando.to_excel(writer, sheet_name='avaliando', index=False) | |
| #-----------------# | |
| # Salve o DataFrame 'result' na planilha 'relatório' | |
| df_dados.to_excel(writer, sheet_name='dados', index=False) | |
| #-----------------# | |
| # Salve o DataFrame 'dado_hom' na planilha 'relatório' | |
| result.to_excel(writer, sheet_name='dados_hom', index=False) | |
| #-----------------# | |
| # Salve o DataFrame 'outliers' na planilha 'relatório' | |
| outliers.to_excel(writer, sheet_name='outliers', index=False) | |
| #-----------------# | |
| # Crie um novo DataFrame com os resultados estatísticos | |
| result_estatisticos = pd.DataFrame({ | |
| 'Número de dados': [num], | |
| 'Média': [media], | |
| 'Valor homogeneizado máximo': [valor_hom_máximo], | |
| 'Valor homogeneizado mínimo': [valor_hom_mínimo], | |
| 'Limite superior (Média x 1,3)': [limite_superior], | |
| 'Limite inferior (Média x 0,7)': [limite_inferior], | |
| 'Desvio padrão': [desvio_padrao], | |
| 'Coeficiente_variacao (%)': [coef_variacao] | |
| }) | |
| # Transponha o DataFrame | |
| result_estatisticos = result_estatisticos.T.reset_index() | |
| # Defina os nomes das colunas do novo DataFrame | |
| result_estatisticos.columns = ['Nome da Coluna', 'Valor'] | |
| result_estatisticos.to_excel(writer, sheet_name='resultados', index=False) | |
| #-----------------# | |
| # Crie um novo DataFrame com os resultados do IC | |
| result_ic = pd.DataFrame({ | |
| 'Número de dados': [n], | |
| 't student': [tc], | |
| 'Limite superior do IC de 80%': [ls_IC], | |
| 'Limite inferior do IC de 80%': [li_IC], | |
| 'Amplitude': [A], | |
| 'Amplitude%':[A_perc], | |
| 'Grau de Precisão': [precisao] | |
| }) | |
| # Transponha o DataFrame | |
| result_ic = result_ic.T.reset_index() | |
| # Defina os nomes das colunas do novo DataFrame | |
| result_ic.columns = ['Nome da Coluna', 'Valor'] | |
| result_ic.to_excel(writer, sheet_name='IC', index=False) | |
| #-----------------# | |
| # Crie um novo DataFrame com os resultados do cálculo das classes de Abunahman | |
| result_classes = pd.DataFrame({ | |
| 'C = Amplitude / 3': [round(C, 2)], | |
| 'li_IC = limite inferior do IC': [round(li_IC, 2)], | |
| 'li_IC + C = limite inferior do IC + C': [round(li_IC + C, 2)], | |
| 'ls_IC - C = limite superior do IC + C': [round(ls_IC - C, 2)], | |
| 'ls_IC = limite superior do IC': [round(ls_IC, 2)], | |
| 'C1 = quantidade de dados na classe 1': [C1], | |
| 'C2 = quantidade de dados na classe 2': [C2], | |
| 'C3 = quantidade de dados na classe 3': [C3], | |
| 'list_C1 = listagem de dados na classe 1': [list_C1], | |
| 'list_C2 = listagem de dados na classe 2': [list_C2], | |
| 'list_C3 = listagem de dados na classe 3': [list_C3], | |
| 'Soma da multiplicação dos valor pelos pesos - classe 1': [pC1], | |
| 'Soma da multiplicação dos valor pelos pesos - classe 2': [pC2], | |
| 'Soma da multiplicação dos valor pelos pesos - classe 3': [pC3], | |
| 'Divisor da somas das classes': [divisor], | |
| 'Média ponderada': [media_pond] | |
| }) | |
| # Transponha o DataFrame | |
| result_classes = result_classes.T.reset_index() | |
| # Defina os nomes das colunas do novo DataFrame | |
| result_classes.columns = ['Nome da Coluna', 'Valor'] | |
| result_classes.to_excel(writer, sheet_name='classes', index=False) | |
| #-----------------# | |
| # Crie um novo DataFrame com os resultados do valor do imóvel | |
| result_valores = pd.DataFrame({ | |
| 'Valor total critério de ABUNAHMAN' : [Valor_imóvel_2], | |
| 'Valor total média simples' : [Valor_imóvel] | |
| }) | |
| # Transponha o DataFrame | |
| result_valores = result_valores.T.reset_index() | |
| # Defina os nomes das colunas do novo DataFrame | |
| result_valores.columns = ['Nome da Coluna', 'Valor'] | |
| result_valores.to_excel(writer, sheet_name='valor', index=False) | |
| #-----------------# | |
| # Salve o DataFrame 'result' em uma planilha | |
| result.to_excel('relatório.xlsx', index=False) | |
| #-----------------# | |
| # Retorna tanto a planilha quanto os resultados formatados | |
| return 'relatório.xlsx', result_render, resultados_formatados, intervalo_confiança, valores_finais | |
| # Interface do Gradio com input como arquivo XLS ou XLSX | |
| interface = gr.Interface( | |
| fn=avaliacao_imovel, | |
| inputs=[ | |
| gr.components.File(label="Upload planilha", type="file"), | |
| gr.inputs.Number(label="Número de linhas desejadas", default=10), | |
| ], | |
| outputs=[ | |
| gr.components.File(label="Download planilha"), | |
| gr.outputs.HTML(label="Resultado Renderizado"), | |
| gr.components.Textbox(label="Resultados estatísticos"), | |
| gr.components.Textbox(label="Intervalo de confiança de 80%"), | |
| gr.components.Textbox(label="Valores Calculados"), | |
| ], | |
| live=True, | |
| capture_session=True, | |
| theme=gr.themes.Soft(), | |
| title="avaliaFACTOR", | |
| description="Aplicativo MCDDM com tratamento por fatores / Faça o upload de uma planilha XLS ou XLSX com os dados / Para um exemplo de estrutura de planilha, você pode baixar <a href='https://huggingface.co/spaces/DavidSB/avaliaFACTOR/resolve/main/dados_entrada_factor.xlsx' download='dados_entrada_factor.xlsx'>aqui</a>.") | |
| # Executar o aplicativo Gradio | |
| if __name__ == "__main__": | |
| interface.launch(debug=True) | |