<jupyter_start><jupyter_text>1. Estatísticas descritivas  1.1 Exploração dos dados e correções<jupyter_code># Dados de 2020, retirados do site Kaggle

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import statsmodels.api as sm
import statistics
from scipy import stats

df = pd.read_csv('Dados/Kaggle/brazil_houses_to_rent_v2.csv')
df.head()
#Vrificando a dimensão do data frame

df.shape
# Renomear as colunas para melhorar a compreensão e facilitar slicing

df = df.rename(columns = {'city':'cidade','rooms':'quartos','bathroom':'banheiros','parking spaces':'vagas_estacionamento',\
                          'floor':'andar','furniture':'mobiliado','hoa (R$)':'condominio', 'rent amount (R$)': 'aluguel',\
                          'property tax (R$)':'IPTU','fire insurance (R$)': 'seguro_incendio', 'total (R$)':'valor_total'})
df.head()
df.info()

# Sem objetos nulos
df.describe()

# Média da área tem um desvio padrao maior do que a média, vamos verificar a distribuição dos ...
# Analisando a distribuição por cidade e verificando se nao há duplicatas no estilo 'São Paulo' e 'são paulo'

df.cidade.value_counts(normalize=True)
# Coluna 'andar'

df.andar.value_counts()

# Considerando que imóveis sem sinalização de andar, iremos considerar que o sinal '-' é para casas.
# Visualizando as diferenças entre os imóveis com e sem andar assinalado

print('Sem andar')
print(df[df.andar == '-'].mean())
print('\n')
print('Com andar')
print(df[df.andar != '-'].mean())

df_casa = df[df.andar == '-']
df = df[df.andar != '-']

# É provável que os imóveis sem andar assinalado, por terem uma área média maior, serem casas térreas.\
# Vamos separar os imóveis que sabemos serem apartamentos, dos outros imóveis
# Tranformando os valores da coluna 'andar' de objetos para números inteiros

df.andar.astype('int64')
# Trocando os valores, de palavras para números, das colunas 'animal' e 'mobiliado', para trabalhar os dados

df.replace({'animal':{'acept': 1, 'not acept': 0}, 'mobiliado':{'furnished': 1, 'not furnished': 0}}, inplace=True)

df.head()
# Agregando as colunas por cidade

df.groupby(by='cidade').sum()<jupyter_output><empty_output><jupyter_text>1.2 Aluguel<jupyter_code># Calculando a faixa de preço que contém 80% dos apartamentos

    
oitenta_pct = int(round(len(df.aluguel)*0.80, 0))

maxi = max(df.aluguel.sort_values()[: oitenta_pct])

print ('80% dos apartamentos tem um aluguel na faixa de', min(df.aluguel), 'a', maxi, 'reais')

print("\n")
print(df.aluguel.describe())
# Visualização da disbruição de aluguéis dos apartamentos em um histograma 

plt.hist(df.aluguel, bins=50)
plt.axvline(df.aluguel.median(), color='k', linestyle='dashed', linewidth=1, label='50%')
plt.axvline(maxi, color='r', linestyle='dashed', linewidth=1, label='80%')
plt.legend(loc='upper right')
plt.xlabel('Valor aluguel')
plt.ylabel('Nº de imóveis')
plt.title('Distribuição dos aluguéis')
plt.xlim(right=16000)
plt.show()


print('Mediana: ', df.aluguel.median())
# Claramnte a distribuição não é normal, se aproximando mais de uma distribuição exponencial
# Visualizando as diferenças de médias de aluguel por cidade

cidades_df = df.groupby(by='cidade').agg({'aluguel': [np.mean, np.median, np.std, len]}).sort_values(by=[('aluguel',   'mean')], ascending=False)
cidades_df

# São Paulo possui o aluguel mais caro e Campinas possui o mas barato. Podemos porém, afirmar que o Rio é mais caro que BH?
# Criando uma lista de Ordenando as cidades por valor de aluguel

cidades_por_aluguel = cidades_df.index
cidades_por_aluguel
# Distribuição dos aluguéis por cidade

ax = sns.boxplot(x='cidade', y='aluguel', data=df, order=cidades_por_aluguel)
ax.set(title='Distribuição dos aluguéis por cidade')<jupyter_output><empty_output><jupyter_text>1.3 Área<jupyter_code># Calcular a faixa de área que contém 80% dos imóveis

oitenta_pct_area = int(round(len(df.area)*0.80, 0))

maxi_area = max(df.area.sort_values()[: oitenta_pct_area])

print ('80% dos apartamentos tem a área na faixa de', min(df.area), 'a', maxi_area, 'metros')

print('\n')
print(df.area.describe())
# Distribuição da área dos apartamentos em um histograma 

plt.hist(df.area, bins=100)
plt.xlabel('Área')
plt.ylabel('Nº de imóveis')
plt.title('Distribuição das áreas')
plt.show()

# Algo está errado
# Distribuição da área dos apartamentos por cidade

sns.boxplot(x='cidade', y='area', data=df)

# Outliers estão prejudicando a visualização
# Conhecendo outliers

df[df.area > 10000]
# Criar data frame df_viz, apenas para visualização, sem os outliers
df_viz = df[df.area < 10000]

# Visualização das área em histograma

plt.hist(df_viz.area, bins=100)
plt.axvline(df_viz.area.median(), color='k', linestyle='dashed', linewidth=1, label='50%')
plt.axvline(maxi_area, color='r', linestyle='dashed', linewidth=1, label='80%')
plt.legend(loc='upper right')
plt.xlabel('Área')
plt.ylabel('Nº de imóveis')
plt.title('Distribuição das área')
plt.xlim(right=700)
plt.show()
# Visualizando as diferenças de médias de aluguel por cidade

cidades_area_df = df.groupby(by='cidade').agg({'area': [np.mean, np.median, np.std,\
                                                        len]}).sort_values(by=[('area',   'mean')], ascending=False)
cidades_area_df
# Distribuição da área dos apartamntos por cidade, agora em log

cidades_por_area = cidades_area_df.index
cidades_por_area

g = sns.boxplot(x='cidade', y='area', data=df, order=cidades_por_area)
g.set_yscale("log")
g.set(title='Área por cidade')<jupyter_output><empty_output><jupyter_text>1.4 Cômodos<jupyter_code># Visualização do imóveis por número de quartos

df.quartos.value_counts().sort_index().plot(kind='bar')
plt.xlabel('Nº de quartos')
plt.ylabel('Nº de imóveis')
plt.title('Nº de quartos por imóvel')

print(df.quartos.value_counts(normalize=True))
# Visualização do imóveis por número de banheiros

df.banheiros.value_counts().sort_index().plot(kind='bar')
plt.xlabel('Nº de banheiros')
plt.ylabel('Nº de imóveis')
plt.title('Nº de banheiros por imóvel')

print(df.banheiros.value_counts(normalize=True)) 
# Visualização da disbruição das vagas de estacionamento por imóvel 

plt.hist(df.vagas_estacionamento, bins=16)
plt.xlabel('Nº de vagas')
plt.ylabel('Nº de imóveis')
plt.title('Nº de vagas por imóvel')

print(df.vagas_estacionamento.value_counts(normalize=True))<jupyter_output>1    0.399830
0    0.248451
2    0.192929
3    0.083708
4    0.056494
5    0.012392
6    0.004738
8    0.000850
7    0.000607
Name: vagas_estacionamento, dtype: float64<jupyter_text>1.5 Adicionando variável (metro quadrado)<jupyter_code># Criando coluna de aluguel por metro quadrado

df['aluguel_m2'] = df.aluguel/df.area
df.head()
# Calcular a faixa de área que contém 80% dos imóveis

oitenta_pct_m2 = int(round(len(df.aluguel_m2)*0.80, 0))

maxi_m2 = max(df.aluguel_m2.sort_values()[: oitenta_pct_m2])

print ('80% dos apartamentos tem o aluguel por metro quadrado na faixa de',\
       round(min(df.aluguel_m2),2), 'a', round(maxi_m2,2), 'metros')

df.aluguel_m2.describe()
oitenta_pct_m2 = int(round(len(df.aluguel_m2)*0.80, 0))

maxi_m2 = max(df.aluguel_m2.sort_values()[: oitenta_pct_m2])

plt.hist(df.aluguel_m2, bins=100)
plt.axvline(df.aluguel_m2.median(), color='k', linestyle='dashed', linewidth=1, label='50%')
plt.axvline(maxi_m2, color='r', linestyle='dashed', linewidth=1, label='80%')
plt.legend(loc='upper right')
plt.xlabel('Valor aluguel por metro quadrado')
plt.ylabel('Nº de imóveis')
plt.title('Distribuição dos aluguéis por metro quadrado')
plt.xlim(right=200)

print('Valor mediano: ', df.aluguel_m2.median())
# Visualizando as diferenças de aluguel por m2 por cidade

cidades_m2_df = df.groupby(by='cidade').agg({'aluguel_m2': [np.mean, np.median, np.std,\
                                                        len]}).sort_values(by=[('aluguel_m2',   'mean')], ascending=False)

cidades_m2_df

# Porto Alegre é possui um alugul por metro uadrado maior do que o de Belo Horizonte, porém, essa diferença é significativa?
# Custo do metro quadrado por cidade

ax = sns.boxplot(x='cidade', y='aluguel_m2', data=df, order = cidades_m2_df.index)
ax.set(title='Distribuição do aluguel por m2 por cidade')<jupyter_output><empty_output><jupyter_text>2. Testes  2.1 Teste qui-quadrado de qualidade do ajuste da amostra<jupyter_code># Vamos verificar se a frequencia observada das cidades é significativa, quando comparada com a frequencia esperada

# Para definir a frequencia esperada, foi utilizado o número de domicílios por cidade, da Censo de 2010

domicilios_cidade = pd.read_excel('Dados/tabela3152.xlsx')
domicilios_cidade.head(10)
domicilios_cidade.columns
# Retirado colunas que não são úteis

domicilios_cidade.drop(columns=['Unnamed: 1'], index=[0,1,2,3], inplace=True)
domicilios_cidade.head()
# Renomeando as colunas

domicilios_cidade.rename(columns = {'Tabela 3152 - Domicílios particulares permanentes, por tipo do domicílio e número de moradores - Resultados Preliminares do Universo'\
                                    : 'cidade', 'Unnamed: 2': 'unidades'}, inplace = True)
domicilios_cidade.reset_index(inplace=True, drop=True)
domicilios_cidade.head()
# Filtrando apenas para as cidades que queremos

domicilios_cidade_selecionado = domicilios_cidade[domicilios_cidade.cidade.isin(['São Paulo (SP)', 'Rio de Janeiro (RJ)', \
                                                                               'Belo Horizonte (MG)', 'Porto Alegre (RS)',\
                                                                               'Campinas (SP)'])]

domicilios_cidade_selecionado.replace({'cidade':{'São Paulo (SP)': 'São Paulo',\
                                                  'Rio de Janeiro (RJ)': 'Rio de Janeiro',\
                                                 'Belo Horizonte (MG)': 'Belo Horizonte',\
                                                  'Porto Alegre (RS)':'Porto Alegre',\
                                                 'Campinas (SP)': 'Campinas'}},inplace=True)

domicilios_cidade_selecionado
# Adicionando uma coluna 'Frequencia'

domicilios_cidade_selecionado['frequencia'] = domicilios_cidade_selecionado.unidades/(domicilios_cidade_selecionado.unidades.sum())
domicilios_cidade_selecionado.head()
# Dada essa frequencia encontrada, qual seria o número de imoveis por cidade esperado
# Ordenando por número de unidades

domicilios_cidade_selecionado['unidades_esperado'] = domicilios_cidade_selecionado.frequencia * df.cidade.count()

domicilios_cidade_selecionado.sort_values(by='unidades', ascending=False, inplace=True)
domicilios_cidade_selecionado
# Obtendo o número de imóveis por cidade 

freq_cidade_obs = df.cidade.value_counts()
freq_cidade_obs
# Transformando a série gerada com o 'values_count' em data frame

freq_cidade_obs = pd.DataFrame({'cidade': freq_cidade_obs.index, 'unidades_obs': freq_cidade_obs.values})
freq_cidade_obs
# Unindo os data frames 'domicilios_cidade_selecionado', que possui os dados do Censo, com 'freq_cidade_obs' dados do Kaggle

df_freq_cidades = pd.merge(domicilios_cidade_selecionado, freq_cidade_obs, on='cidade')
df_freq_cidades
# Rodando um teste qui-quadrado de qualidade do ajuste (Goodness-Of-Fit) 

stats.chisquare(f_obs = df_freq_cidades.unidades_obs, f_exp = df_freq_cidades.unidades_esperado)


# Hipotese nula rejeitada, as distribuiçõs não possuem a mesma frequência
df_freq_cidades_viz = df_freq_cidades.drop(columns=['unidades', 'frequencia'])
df_freq_cidades_viz.set_index('cidade', inplace=True)
df_freq_cidades_viz.plot(kind="bar")
plt.title('Comparação entre unidades esperadas x observadas')
plt.ylabel('Nº de unidades')
plt.show()<jupyter_output><empty_output><jupyter_text>2.2 Teste de duas amostras (média e mediana)  2.2.1 Aluguel do Rio de Janeiro x Belo Horizonte<jupyter_code># Testando a normalidade da distribuiução dos aluguéis

stats.normaltest(df.aluguel)

# P Valor igual a zero. Rejeitando a hipótese de que a distribuição é normal
# Visualizando a diferença de médias

rj_aluguel = df.loc[df.cidade == 'Rio de Janeiro', 'aluguel']
bh_aluguel = df.loc[df.cidade == 'Belo Horizonte', 'aluguel']

plt.hist(rj_aluguel, alpha=0.5, label = 'RJ', bins = 50, color='red')
plt.hist(bh_aluguel, alpha=0.5, label = 'BH', bins = 50, color='blue')
plt.axvline(rj_aluguel.mean(), color='red', linestyle='dashed', linewidth=1, label='Média RJ')
plt.axvline(bh_aluguel.mean(), color='blue', linestyle='dashed', linewidth=1, label='Média BH')
plt.xlabel('Valor aluguel')
plt.ylabel('Nº de imóveis')
plt.title('Distribuição dos aluguéis (RJ x BH)')
plt.legend(loc='upper right')
plt.show()
# Visualizando a diferença de medianas

ax = sns.boxplot(x='cidade', y='aluguel', data=df[(df.cidade == 'Belo Horizonte') | (df.cidade == 'Rio de Janeiro')])
ax.set(title='Aluguel de Rio de Janeiro x Belo Horizonte')
# Teste de hipótse para a média das duas amostras

print(sm.stats.ztest(rj_aluguel, bh_aluguel))

print((rj_aluguel.mean() - bh_aluguel.mean())/bh_aluguel.mean())


# Os imóveis do Rio de Janeiro são, em média, 8% mais caros do os de Belo Horizonte.
# Teste de hipótese para a mediana

print(stats.median_test(bh_aluguel, rj_aluguel))

print((rj_aluguel.median() - bh_aluguel.median())/bh_aluguel.median())
# Visualizando as diferenças do tamanho dos apartamentos

df.groupby(by='cidade').agg({'area': [np.mean, np.std, max, len]})<jupyter_output><empty_output><jupyter_text>2.2.2 Área dos apartamentos São Paulo x Belo Horizonte<jupyter_code># Visualizando a área dos apartamentos em São Paulo e Belo Horizonte

ax = sns.boxplot(x='cidade', y='area', data=df[(df.cidade == 'São Paulo') | (df.cidade == 'Belo Horizonte')])
ax.set_yscale("log")
ax.set(title='Aluguel de São Paulo x Belo Horizonte')
# Visualizando. Retirando os dados do data frame 

sp_area = df_viz.loc[df.cidade == 'São Paulo', 'area']
bh_area = df_viz.loc[df.cidade == 'Belo Horizonte', 'area']

plt.hist(sp_area, alpha=0.5, label = 'SP', bins = 100, color='red')
plt.hist(bh_area, alpha=0.5, label = 'BH', bins = 100, color='blue')
plt.axvline(sp_area.mean(), color='red', linestyle='dashed', linewidth=1, label='Média SP')
plt.axvline(bh_area.mean(), color='blue', linestyle='dashed', linewidth=1, label='Média BH')
plt.xlim(right=700)
plt.xlabel('Área')
plt.ylabel('Nº de imóveis')
plt.title('Distribuição dos aluguéis (SP x BH)')
plt.legend(loc='upper right')
plt.show()
# Teste de hipótse para a média das duas amostras, sem os outliers

sp_area = df_viz.loc[df_viz.cidade == 'São Paulo', 'area']
bh_area = df_viz.loc[df_viz.cidade == 'Belo Horizonte', 'area']

print(sm.stats.ztest(sp_area, bh_area))

print((sp_area.mean() - bh_area.mean())/bh_area.mean())


# A diferença de médias não é significante
# Teste de hipótse para a média das duas amostras, com os outliers

sp_area = df.loc[df.cidade == 'São Paulo', 'area']
bh_area = df.loc[df.cidade == 'Belo Horizonte', 'area']

print(sm.stats.ztest(sp_area, bh_area))

print((sp_area.mean() - bh_area.mean())/bh_area.mean())


# Vemos que o nesse caso a diferença de médias aumenta bastante. Porém, a um p-valor de 0.05, o hipótese nula, de que as médias são iguais, não foi rejeitada. 
# Teste de hipótese para a mediana

print(stats.median_test(sp_area, bh_area))

print((sp_area.median() - bh_area.median())/bh_area.median())

# As medianas são rigorosamnte as mesmas<jupyter_output>(0.018826725254990403, 0.890864400248042, 90.0, array([[2109,  455],
       [2164,  461]], dtype=int64))
0.0<jupyter_text>2.2.3 Aluguel por metro quadrado do Porto Alegre x Belo Horizonte<jupyter_code># Visualizando. Retirando os dados do data frame 

poa_aluguel_m2 = df.loc[df.cidade == 'Porto Alegre', 'aluguel_m2']
bh_aluguel_m2 = df.loc[df.cidade == 'Belo Horizonte', 'aluguel_m2']

plt.hist(poa_aluguel_m2, alpha=0.5, label = 'POA', bins = 100, color='red')
plt.hist(bh_aluguel_m2, alpha=0.5, label = 'BH', bins = 100, color='blue')
plt.axvline(poa_aluguel_m2.mean(), color='red', linestyle='dashed', linewidth=1, label='Média POA')
plt.axvline(bh_area.mean(), color='blue', linestyle='dashed', linewidth=1, label='Média BH')
plt.xlim(right=100)
plt.xlabel('Aluguel m2')
plt.ylabel('Nº de imóveis')
plt.title('Distribuição do aluguel por m2 (POA x BH)')
plt.legend(loc='upper right')
plt.show()
# Teste de hipótse para a média das duas amostras, com os outliers

print(sm.stats.ztest(poa_aluguel_m2, bh_aluguel_m2))

print((poa_aluguel_m2.mean() - bh_aluguel_m2.mean())/bh_aluguel_m2.mean())

# A diferença de 8,9% entre as médias é significativa. Porto Alegre possui um aluguel por metro quadrado maior
# Visualizando a difirença entr as medianas

ax = sns.boxplot(x='cidade', y='aluguel_m2', data=df[(df.cidade == 'Porto Alegre') | (df.cidade == 'Belo Horizonte')])
ax.set(title='Aluguel por m2 de Porto Alegre x Belo Horizonte')
# Teste de hipótese para a mediana

print(stats.median_test(poa_aluguel_m2, bh_aluguel_m2))

print((poa_aluguel_m2.median() - bh_aluguel_m2.median())/bh_aluguel_m2.median())

# Diferença significativa<jupyter_output>(27.9487010051229, 1.2457455835682748e-07, 21.875, array([[557, 399],
       [442, 517]], dtype=int64))
0.16088765603328706<jupyter_text>3. Modelo Preditivo<jupyter_code># Visualizando a dispersão e encontrando a correlação

ax = sns.regplot('area', 'aluguel', data=df_viz)
ax.set(title='Correlação área x aluguel')

r = np.corrcoef(df_viz.area, df_viz.aluguel)
print('R é igual a', r[1,0])

# Aparentemente há um valor próximo a 15.000, q funciona como um teto, para grande parte dos imoveis
# Encontrar a correlação área x aluguel para cada cidade

nomes_cidades = df.cidade.unique()

for i in nomes_cidades:
    data = df[df.cidade == i]
    r = np.corrcoef(data.area, data.aluguel)
    print(i, r[1,0])
    print('\n')
    
# Campinas possui a maior correlação área x aluguel e Belo Horizonte a menor
sns.scatterplot(x='area', y='aluguel', hue='cidade', data=df_viz)
# Regressao com minimos quadrados entre aluguel e área

model_quartos = sm.OLS.from_formula("aluguel ~ area", data=df_viz)
resultado_area = model_quartos.fit()
resultado_area.summary()

# Visualizando o modelo

plt.scatter(df_viz.area, df_viz.aluguel)
plt.plot(df_viz.area, df_viz.area*resultado_area.params['area'] + resultado_area.params['Intercept'], 'red')
plt.xlabel('Área')
plt.ylabel('Aluguel')
plt.title('Área x Aluguel')
plt.show()
# Visualizando a distribuição dos resíduos

plt.scatter(resultado_area.fittedvalues, resultado_area.resid)
plt.xlabel('Resultados')
plt.ylabel('Resíduos')
# Apesar dos teste Durbin-Watson nao indicar autocorrelação, vemos que o erros não são aleatórios, o que pode prejudicar o modelo
# Agora para a variável número de quartos

model_quartos = sm.OLS.from_formula("aluguel ~ quartos", data=df)
resultado_quartos = model_quartos.fit()
resultado_quartos.summary()

# Vemos que o R é de 0.235, valor considerado baixo.
# Visualizando o modelo

plt.scatter(df.quartos, df.aluguel)
plt.plot(df.quartos, df.quartos*resultado_quartos.params['quartos'] + resultado_quartos.params['Intercept'], 'red')
plt.xlabel('Nº de quartos')
plt.ylabel('Aluguel')
plt.title('Nº de quartos x Aluguel')
plt.show()
# Buscando a correlação entre as duas variáveis independentes

df[["area", "quartos"]].corr()

# Vemos que há uma correlação forte entre as duas variáveis, que mostra que há multicolinearidade
# Agora para a variável número de quartos

model_estac = sm.OLS.from_formula("aluguel ~ vagas_estacionamento", data=df)
resultado_estac = model_estac.fit()
resultado_estac.summary()

df.shape
model = sm.OLS.from_formula("aluguel ~ area + quartos + banheiros + vagas_estacionamento", data=df[df.cidade == 'São Paulo'])
resultado = model.fit()
resultado.summary()
df.aluguel.mean()
resultado.params['area']
# Regressao com minimos quadrados entre aluguel e área

model_quartos = sm.OLS.from_formula("aluguel ~ area", data=df[df.cidade == 'São Paulo'])
resultado_area = model_quartos.fit()
resultado_area.summary()

from sklearn.model_selection import train_test_split 
from sklearn.linear_model import LinearRegression
from sklearn import metrics
%matplotlib inline
#Vamos construir o modelo para São Paulo

df_sp = df[df.cidade == 'São Paulo']

X = df_sp[['area', 'quartos', 'banheiros', 'vagas_estacionamento', 'andar', 'animal', 'mobiliado']].values

y = df_sp['aluguel']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)
modelo = LinearRegression()
modelo.fit(X_train, y_train)
y_pred = modelo.predict(X_test)
print('Mean Absolute Error:', metrics.mean_absolute_error(y_test, y_pred))  
print('Mean Squared Error:', metrics.mean_squared_error(y_test, y_pred))  
print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(y_test, y_pred)))
df_model = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred, 'Error': ((y_test-y_pred)/y_test*100)})
df_model.head(25)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13102619562605142, 'fraction_numerical': 0.02182167748137467, 'mean_word_length': 5.166567871962063, 'pattern_counts': {'":': 0, '<': 39, '<?xml version=': 0, '>': 39, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 19, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '10', 'dir': 'jupyter-structured-clean-dedup', 'id': '212879', 'license': 'MIT', 'n_tokens_mistral': 8544, 'n_tokens_neox': 8029, 'n_words': 1881, 'path': 'brazilian_houses_to_rent.ipynb', 'repo_name': 'gabrielgomes0311/brazilian_houses_to_rent', 'size': '20805'}