# ---
# jupyter:
#   jupytext:
#     text_representation:
#       extension: .py
#       format_name: light
#       format_version: '1.5'
#       jupytext_version: 1.14.4
#   kernelspec:
#     display_name: Python 3
#     language: python
#     name: python3
# ---

# +
import pandas as pd
import os
import matplotlib.pyplot as plt

from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score, classification_report
import math
import numpy as np

from sklearn.preprocessing import StandardScaler
#from yellowbrick.regressor import ResidualsPlot
# -

# ##  Carrega dados

# +
df = pd.read_csv("data/apartamentos_completo.csv")

df = df.drop(['Unnamed: 0'],axis=1)
df.reset_index(inplace=True,drop=True)
print(df.shape)
df.head()
# -

df.dtypes

# ### Dropa imoveis que não tem latitude, longitude e área útil

df.dropna(subset=['lat', 'long','area_util','bairro'],inplace=True)
df.shape

# ### Quantidade de valores nulos por coluna

df.isna().sum().plot.bar()

df.isna().sum()

# ### Remove outliers do preço de venda

print(df.shape)
df.valor_venda.describe()

# ### 6 bilhões parece muito para um imóvel
# Vamos remover aqueles que custam a partir de 12 milhões

df = df.loc[df.valor_venda < 5000000]
print(df.shape)
df.valor_venda.describe()

# ### Remove outliers da area util

df.area_util = df.area_util.str.replace('m²','')
df.area_util = pd.to_numeric(df.area_util)

print(df.shape)
df.area_util.describe()

# ## 143mil m2  parece muito para um apartamento
# Vamos remover aqueles que sao maiores que 1000 m2

df = df.loc[(df.area_util < 1000) & (df.area_util > 18)]
print(df.shape)
df.area_util.describe()

df.idade_anuncio = df.idade_anuncio.str.replace("\r\n Publicado desde ontem\r\n","1")
df.idade_anuncio = df.idade_anuncio.str.replace("\r\n Publicado hoje\r\n","0")
df.idade_anuncio.value_counts()

# ### Checa distribuição dos Bairros

df.bairro = df.bairro.str.replace(",  ","")
df.bairro.value_counts()

bairros_goiania = ['Setor Bueno, Goiânia','Setor Marista, Goiânia','Jardim Goiás, Goiânia','Setor Oeste, Goiânia',
                  'Parque Amazônia, Goiânia','Jardim América, Goiânia']
df = df[~df['bairro'].isin(bairros_goiania)]
df.bairro.value_counts()

df.bairro.value_counts()[:25].plot.bar()

# ### Remove bairros com menos imóveis (pega so 25 +)

df.bairro.value_counts()[25:]

bairros_reject = df.bairro.value_counts()[25:].index.values
bairros_reject

df = df[~df['bairro'].isin(bairros_reject)]
print(df.shape)
df.head()

df.bairro.value_counts()

df.quartos = df.quartos.fillna(df.quartos.median())

#df_regression = df[['bairro', 'area_util', 'quartos','valor_venda','lat','long',]]
#df_regression = df[['area_util', 'quartos','valor_venda','lat','long','idade_anuncio']]
df_regression = df[['area_util', 'quartos','valor_venda','lat','long']]
print(df_regression.shape)
df_regression.head()

df_regression.isna().sum()

df_regression.head()

# +
#one_hot = pd.get_dummies(df_regression['bairro'], prefix="bairro")
#df_regression = df_regression.join(one_hot)

#df_regression = df_regression.drop(['bairro'], axis=1)

#df_regression.shape
#df_regression.head()
# -

df_regression = df_regression.apply(pd.to_numeric)
#, errors='coerce'
df_regression.dtypes

# +
#zscore
#mean = df_regression.mean(axis=0)
#std = df_regression.std(axis=0)

# zscore normalization
#df_regression = ( df_regression - mean ) / std
# -

X = df_regression.drop(['valor_venda'],axis=1)
y = df_regression['valor_venda']
X.shape, y.shape

# +
#X_columns = X.columns.values
#X = pd.DataFrame(StandardScaler().fit_transform(X),columns=X_columns)
# -

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
X_train.shape, X_test.shape, y_train.shape, y_test.shape

reg = RandomForestRegressor(n_estimators=100) 
reg

reg.fit(X_train, y_train)
train_predict = reg.predict(X_train)
test_predict = reg.predict(X_test)

# +
print("Mean squared error: %.2f"
      % mean_squared_error(y_test, test_predict))

rmse = math.sqrt(mean_squared_error(y_test, test_predict))
print("Root Mean squared error: %.2f" % rmse)

print('R2 score: %.2f' % r2_score(y_test, test_predict))

# +
 plt.rcParams['figure.figsize'] = [10, 5]
importances = reg.feature_importances_
std = np.std([tree.feature_importances_ for tree in reg.estimators_],
             axis=0)
indices = np.argsort(importances)[::-1]

#Print the feature ranking
print("Feature ranking:")

for f in range(X_train.shape[1]):

    print("%d. feature %s (%f)" % (f + 1, X_train.columns[indices[f]], importances[indices[f]]))

# Plot the feature importances of the forest
plt.figure()
plt.title("Feature importances")
plt.bar(range(X_train.shape[1]), importances[indices],
       color="r", yerr=std[indices], align="center")
plt.xticks(range(X_train.shape[1]), X_train.columns[indices],rotation=90)
plt.xlim([-1, X_train.shape[1]])
plt.show()

# +
#reg2 = RandomForestRegressor(n_estimators=100) 

#visualizer = ResidualsPlot(reg2)
#visualizer.fit(X_train, y_train)  # Fit the training data to the model
#visualizer.score(X_test, y_test)  # Evaluate the model on the test data
#visualizer.poof()                 # Draw/show/poof the data
# -

# ### TODO: scatterplot valor_venda x area util

# +

ax1 = df.plot.scatter(x='area_util',
                       y='valor_venda',
                       c='DarkBlue')
# -

df_zoom = df.loc[df.area_util < 2001]
ax2 = df_zoom.plot.scatter(x='area_util',
                       y='valor_venda',
                       c='DarkBlue')

df_zoom = df.loc[df.area_util < 751]
ax2 = df_zoom.plot.scatter(x='area_util',
                       y='valor_venda',
                       c='DarkBlue')

df_zoom = df.loc[df.area_util < 301]
ax2 = df_zoom.plot.scatter(x='area_util',
                       y='valor_venda',
                       c='DarkBlue')

df_zoom = df.loc[(df.area_util < 300) & (df.valor_venda < 4000000)]
print(df_zoom.shape)
ax2 = df_zoom.plot.scatter(x='area_util',
                       y='valor_venda',
                       c='DarkBlue')

df_zoom = df.loc[(df.area_util < 100) & (df.valor_venda < 1000000)]
print(df_zoom.shape)
ax2 = df_zoom.plot.scatter(x='area_util',
                       y='valor_venda',
                       c='DarkBlue')

# +

lat = -15.752353
long = -47.8830672
area = 87
quartos = 3.0

apto_411_n = [[area,quartos,lat,long]]

previsao = reg.predict(apto_411_n)[0]

correcao = previsao * 0.21
print("previsao de preço: ", previsao -  correcao)

# +

lat = -15.738213539123535
long = -47.897647857666015
area = 89
quartos = 3.0

apto_316_n = [[area,quartos,lat,long]]

previsao = reg.predict(apto_316_n)[0]

correcao = previsao * 0.21
print("previsao de preço: ", previsao -  correcao)
# -



StarcoderdataJupyterScriptsDedupFiltered