
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px

from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split
from sklearn.model_selection import RandomizedSearchCV

from sklearn.linear_model import Ridge
from sklearn.linear_model import Lasso
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.svm import SVR
from lightgbm import LGBMRegressor

from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import r2_score

from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import LabelEncoder

from pprint import pprint

%matplotlib inline
plt.style.use('fivethirtyeight')
pd.set_option('display.max_columns', 100)

import warnings
warnings.filterwarnings("ignore")


# importando o conjunto de dados
df = pd.read_csv("../dados/listings.csv", index_col="id")

# visualizando as primeiras 5 linhas
df.head()


# imprimindo as dimensões
print(f'Quantidade de linhas: {df.shape[0]}')
print(f'Quantidade de colunas: {df.shape[1]}')

Quantidade de linhas: 26615
Quantidade de colunas: 15


# criando um dataframe com dados nulos, tipo de dados e valores unicos 
pd.DataFrame({'valores_nulos':np.round(df.isnull().mean(), 2), 
              'tipo_dados': df.dtypes, 
              'valores_unicos': df.nunique()})


# convertendo variáveis
df['host_id'] = df.host_id.astype('category')
df['last_review'] = pd.to_datetime(df.last_review)


# definindo área de plotagem
plt.figure(figsize=(12,5))

# plotando gráfico
sns.heatmap(df.isnull(), cbar=False)
plt.title('Composição do dataframe')
plt.show()


# plotando o gráfico de densidade
# definindo as colunas numéricas
columns_list = ['price', 'minimum_nights', 'number_of_reviews', 
                'reviews_per_month', 'calculated_host_listings_count', 'availability_365']

# criando objeto para número de linhas e colunas
nrows = 2
ncols = 3

# definindo área de plotagem
fig, ax = plt.subplots(nrows=nrows, ncols=ncols, figsize=(20,8))
fig.subplots_adjust(hspace=1, wspace=1)

# criando loop para plotagem
idx = 0
for col in columns_list:
    idx += 1
    plt.subplot(nrows, ncols, idx)
    sns.kdeplot(df[col], shade=True)
    plt.title(col, fontsize=10)
plt.tight_layout()


# verificando as principais estatísticas numéricas
df[columns_list].describe()


# verificando as principais estatísticas categóricas
df.describe(include='O')


# definindo área de plotagem
fig, ax = plt.subplots(6, 1, figsize=(10,6))

# criando loop para plotagem
idx_ = 0
for i in columns_list:
    idx_ += 1
    plt.subplot(6, 1, idx_)
    df[i].plot(kind='box', vert=False)
plt.tight_layout()


# reduzindo a quantidade de amostras da variável 'price'
df_mod = df[df['price'] < 600]

# reduzindo a quantidade de amostras da variável 'minimum_nights'
df_mod = df_mod[df_mod['minimum_nights'] < 8]

# reduzindo a quantidade de amostras da variável 'number_of_reviews'
df_mod = df_mod[df_mod['number_of_reviews'] < 10]

# reduzindo a quantidade de amostras da variável 'calculated_host_listings_count'
df_mod = df_mod[df_mod['calculated_host_listings_count'] < 70]


# df_mod[columns_list].describe()


# Q1 = df[columns_list].quantile(0.25)
# Q3 = df[columns_list].quantile(0.75)
# IQR = Q3 - Q1
# print(IQR)

# df_num = df[columns_list][~((df[columns_list] < (Q1 - 1.5 * IQR)) | (df[columns_list] > (Q3 + 1.5 * IQR))).any(axis=1)]


# definindo área de plotagem
fig, ax = plt.subplots(6, 1, figsize=(10,6))

# criando loop para plotagem
idx_ = 0
for i in columns_list:
    idx_ += 1
    plt.subplot(6, 1, idx_)
    df_mod[i].plot(kind='box', vert=False)
plt.tight_layout()


df_mod.shape

(13210, 15)


# criando um novo objeto somente para dados numéricos
df_num = df_mod[columns_list]

# removendo os outliers do dataframe principal
df_new = df.loc[df_num.index.tolist()]

# checando a nova dimensão do dataset
df_new.shape

(13210, 15)


# removendo a coluna sem dados
df_new.drop('neighbourhood_group', axis=1, inplace=True)


# plotando o mapa
fig = px.scatter_mapbox(df_new, lat="latitude", lon="longitude", hover_name="name", color_discrete_sequence=["red"], 
                        zoom=10, height=500)
fig.update_layout(mapbox_style="open-street-map")
fig.update_layout(margin={"r":0,"t":0,"l":0,"b":0})
fig.show()


# definindo a área de plotagem
plt.figure(figsize=(10, 8))

# plotando o gráfico
sns.heatmap(df_new.corr(), vmin=-1, vmax=1, annot=True, cmap='vlag')
plt.title('Heatmap com as correlações')
plt.show()


print(f'A média geral de preços é: R${df_new.price.mean():.2f}')

A média geral de preços é: R$253.02


# visualizando a média de preços por região
médias_por_região = df_new.groupby('neighbourhood')['price'].mean().sort_values(ascending=False)
médias_por_região

neighbourhood
Osvaldo Cruz              400.000000
Paciência                 362.400000
Jacaré                    360.000000
Leblon                    352.775061
Cavalcanti                350.000000
                             ...    
Ricardo de Albuquerque     73.000000
Parada de Lucas            68.333333
Ribeira                    64.000000
Senador Camará             63.600000
Vigário Geral              59.000000
Name: price, Length: 142, dtype: float64


# agrupando por tipo mais alugados
df_new.groupby('room_type').agg({'room_type': 'count', 'price': 'mean'}).sort_values(by='price', ascending=False)


# definindo a área de plotagem
fig, ax = plt.subplots(figsize = (12,10))

# plotando o gráfico
ax = sns.scatterplot(data=df_new, y="latitude", x="longitude", hue='room_type')
ax.set_title('Mapeamento por tipo de estabelecimento')
plt.show()


df_dummies = pd.get_dummies(df_new['room_type'])
df_new_dummies = pd.concat([df_new['price'], df_dummies], axis=1)


# definindo a área de plotagem
plt.figure(figsize=(8, 6))

# plotando o gráfico
sns.heatmap(df_new_dummies.corr(), vmin=-1, vmax=1, annot=True, cmap='vlag')
plt.title('Heatmap com as correlações')
plt.show()


# definindo a área de plotagem
plt.figure(figsize=(15,10))

# plotando o gráfico
df_new.groupby('last_review')['name'].count().plot()
plt.title('Visualização ao longo do tempo')
plt.show()


# definindo a área de plotagem
plt.figure(figsize=(15,10))

# plotando o gráfico
df_new.groupby('last_review')['price'].mean().plot()
plt.title('Visualização ao longo do tempo')
plt.show()


# definindo a seed para rodar sempre os mesmos valores aleatórios
seed = 1

# separando um conjunto de dados somente para teste
df_test = df_new.sample(frac=0.1, random_state=seed)

# conjunto de dados treino e validação do modelo
df_train_val = df_new.drop(df_test.index.tolist())


print(f'Conjunto de dados para teste: {df_test.shape}')
print()
print(f'Conjunto de dados para treino e validação: {df_train_val.shape}')

Conjunto de dados para teste: (1321, 14)

Conjunto de dados para treino e validação: (11889, 14)


# criando uma lista para as variáveis de entrada
feature_list = ['host_id', 'latitude', 'longitude', 'room_type', 'minimum_nights', 'number_of_reviews', 
                'reviews_per_month', 'calculated_host_listings_count', 'availability_365']


# separando o X e y
X = df_train_val[feature_list]
y = df_train_val.price

# separando em treino e validação
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=seed)

# checando as dimensões
print(X_train.shape, X_val.shape, y_train.shape, y_val.shape)

(9511, 9) (2378, 9) (9511,) (2378,)


# cópias dos conjuntos de dados
X_train_enc = X_train.copy()
X_val_enc = X_val.copy()


# instanciando o algoritmo
le = LabelEncoder()

# treinando com os dados de treino
le.fit(X_train['room_type'])

# realizando as transformações
X_train_enc['room_type'] = le.transform(X_train['room_type'])
X_val_enc['room_type'] = le.transform(X_val['room_type'])

# visualizando o resultado
X_train_enc.head()


# X_train_enc['reviews_per_month'] = X_train_enc['reviews_per_month'].fillna(X_train_enc.reviews_per_month.mean())
# X_val_enc['reviews_per_month'] = X_val_enc['reviews_per_month'].fillna(X_train_enc.reviews_per_month.mean())


# preenchendo os dados nulos
X_train_enc['reviews_per_month'] = X_train_enc['reviews_per_month'].fillna(0)
X_val_enc['reviews_per_month'] = X_val_enc['reviews_per_month'].fillna(0)

# visualizando o resultado
X_train_enc.head()


# instanciando o algoritmo
reg = LinearRegression()

# treinando com os dados que separamos
reg.fit(X_train_enc, y_train)

# realizando as previsões tanto nos dados de treino quanto no de validação
y_pred_train = reg.predict(X_train_enc)
y_pred_val = reg.predict(X_val_enc)

print(f'Previsão nos dados de TREINO:')
print('-----------------------------------------------------')
print(f'Mean Squared Error: {mean_squared_error(y_train, y_pred_train)}')
print(f'Mean Absolute Error: {mean_absolute_error(y_train, y_pred_train)}')
print(f'R2 score: {r2_score(y_train, y_pred_train)}\n')

print(f'Previsão nos dados de VALIDAÇÃO:')
print('-----------------------------------------------------')
print(f'Mean Squared Error: {mean_squared_error(y_val, y_pred_val)}')
print(f'Mean Absolute Error: {mean_absolute_error(y_train, y_pred_train)}')
print(f'R2 score: {r2_score(y_val, y_pred_val)}')

Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 14819.67487641476
Mean Absolute Error: 98.59964243201084
R2 score: 0.2180411679585168

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 14404.359124812361
Mean Absolute Error: 98.59964243201084
R2 score: 0.2230869229876289


# instanciando os modelos
dtr = DecisionTreeRegressor()
rfr = RandomForestRegressor(n_estimators=1000)
svr = SVR()
LGBM = LGBMRegressor(n_estimators=1000)
ridge = Ridge(alpha=0.1)
lasso = Lasso(alpha=0.1)
gbr = GradientBoostingRegressor(random_state=seed)
etr = ExtraTreesRegressor(n_estimators=1000, random_state=0)

# criando uma lista de tuplas com o nome e modelo treinado
models = [('DECISION TREE', dtr),
          ('RANDOM FOREST', rfr),
          ('LGBM', LGBM),
          ('SVR', svr),
          ('RIDGE', ridge),
          ('LASSO', lasso),
          ('GRADIENT BOOSTING', gbr),
          ('EXTRA TREES', etr)]

# rodando o loop para obter os resultados
for name, model in models:
    model.fit(X_train_enc, y_train)
    y_pred_train = model.predict(X_train_enc)
    y_pred_val = model.predict(X_val_enc)
    
    print(f'{name}')
    print(f'Previsão nos dados de TREINO:')
    print('-----------------------------------------------------')
    print(f'Mean Squared Error: {mean_squared_error(y_train, y_pred_train)}')
    print(f'Mean Absolute Error: {mean_absolute_error(y_train, y_pred_train)}')
    print(f'R2 score: {r2_score(y_train, y_pred_train)}\n')
    
    print(f'Previsão nos dados de VALIDAÇÃO:')
    print('-----------------------------------------------------')
    print(f'Mean Squared Error: {mean_squared_error(y_val, y_pred_val)}')
    print(f'Mean Absolute Error: {mean_absolute_error(y_val, y_pred_val)}')
    print(f'R2 score: {r2_score(y_val, y_pred_val)}')
    
    print()
    print()

DECISION TREE
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 0.09930606665965724
Mean Absolute Error: 0.005993060666596573
R2 score: 0.9999947601241899

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 26116.913372582003
Mean Absolute Error: 122.00925147182507
R2 score: -0.40864104779271404


RANDOM FOREST
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 1800.213836415492
Mean Absolute Error: 33.51188945106168
R2 score: 0.9050118763948936

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 13160.326616029108
Mean Absolute Error: 91.52778640714486
R2 score: 0.2901850226620083


LGBM
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 3616.3582775409677
Mean Absolute Error: 45.02322149073394
R2 score: 0.80918317584349

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 14722.875669900033
Mean Absolute Error: 96.05600250219088
R2 score: 0.20590742426927577


SVR
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 19290.483341655086
Mean Absolute Error: 111.62023707493236
R2 score: -0.017860644659808855

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 18777.02849525946
Mean Absolute Error: 109.24228945778292
R2 score: -0.012757239596456582


RIDGE
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 14819.724459324427
Mean Absolute Error: 98.60497226101666
R2 score: 0.21803855172068054

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 14403.650233789693
Mean Absolute Error: 97.21722227822578
R2 score: 0.22312515771233388


LASSO
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 14827.994789963914
Mean Absolute Error: 98.71073082800399
R2 score: 0.21760216845712177

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 14403.045027810394
Mean Absolute Error: 97.24333733074832
R2 score: 0.22315780008368324


GRADIENT BOOSTING
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 12474.252681280748
Mean Absolute Error: 89.46085881995478
R2 score: 0.34179716231369517

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 13226.231079782781
Mean Absolute Error: 92.35964714271402
R2 score: 0.2866304015032288


EXTRA TREES
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 0.10689368604773423
Mean Absolute Error: 0.009850909473241567
R2 score: 0.999994359764125

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 13585.775436440706
Mean Absolute Error: 92.47108242220354
R2 score: 0.2672380279839952


# lista das variáveis
features = feature_list

# variáveis mais importantes pela Random Forest
importances = rfr.feature_importances_

# capturando os indices
indices = np.argsort(importances)

# plotando o gráfico
plt.barh(range(len(indices)), importances[indices], color='b', align='center')
plt.title('Feature Importances - Random Forest')
plt.yticks(range(len(indices)), [features[i] for i in indices])
plt.xlabel('Relative Importance')
plt.show()


# lista das variáveis
features = feature_list

# variáveis mais importantes pela Random Forest
importances = gbr.feature_importances_

# capturando os indices
indices = np.argsort(importances)

# plotando o gráfico
plt.barh(range(len(indices)), importances[indices], color='b', align='center')
plt.title('Feature Importances - Gradient Boosting')
plt.yticks(range(len(indices)), [features[i] for i in indices])
plt.xlabel('Relative Importance')
plt.show()


from boruta import BorutaPy

boruta = BorutaPy(
   estimator = rfr, 
   n_estimators = 'auto',
   max_iter = 100 # number of trials to perform
)
### fit Boruta (it accepts np.array, not pd.DataFrame)
boruta.fit(np.array(X_train_enc), np.array(y_train))
### print results
green_area = X.columns[boruta.support_].to_list()
blue_area = X.columns[boruta.support_weak_].to_list()
print('features in the green area:', green_area) # the features that are here are considered as predictive, so they are kept
print('features in the blue area:', blue_area) # Boruta is indecisive about the features that are in this area;

features in the green area: ['host_id', 'latitude', 'longitude', 'room_type', 'reviews_per_month']
features in the blue area: []


boruta = BorutaPy(
   estimator = gbr, 
   n_estimators = 'auto',
   max_iter = 100 # number of trials to perform
)
### fit Boruta (it accepts np.array, not pd.DataFrame)
boruta.fit(np.array(X_train_enc), np.array(y_train))
### print results
green_area = X.columns[boruta.support_].to_list()
blue_area = X.columns[boruta.support_weak_].to_list()
print('features in the green area:', green_area) # the features that are here are considered as predictive, so they are kept
print('features in the blue area:', blue_area) # Boruta is indecisive about the features that are in this area;

features in the green area: ['host_id', 'latitude', 'longitude', 'room_type', 'reviews_per_month', 'calculated_host_listings_count', 'availability_365']
features in the blue area: ['minimum_nights']


# criando uma lista para as variáveis de entrada
feature_list = ['host_id', 'latitude', 'longitude', 'room_type', 'reviews_per_month']

# separando o X e y
X = df_train_val[feature_list]
y = df_train_val.price



# separando em treino e validação
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=seed)

# # checando as dimensões
# print(X_train.shape, X_val.shape, y_train.shape, y_val.shape)

# cópias dos conjuntos de dados
X_train_enc = X_train.copy()
X_val_enc = X_val.copy()


# instanciando o algoritmo
le = LabelEncoder()

# treinando com os dados de treino
le.fit(X_train['room_type'])

# realizando as transformações
X_train_enc['room_type'] = le.transform(X_train['room_type'])
X_val_enc['room_type'] = le.transform(X_val['room_type'])



# preenchendo os dados nulos
X_train_enc['reviews_per_month'] = X_train_enc['reviews_per_month'].fillna(0)
X_val_enc['reviews_per_month'] = X_val_enc['reviews_per_month'].fillna(0)

# visualizando o resultado
X_train_enc.head()


# instanciando os modelos
rfr = RandomForestRegressor(n_estimators=1000)
gbr = GradientBoostingRegressor(random_state=seed)

# criando uma lista de tuplas com o nome e modelo treinado
models = [('RANDOM FOREST', rfr),
          ('GRADIENT BOOSTING', gbr)]

# rodando o loop para obter os resultados
for name, model in models:
    model.fit(X_train_enc, y_train)
    y_pred_train = model.predict(X_train_enc)
    y_pred_val = model.predict(X_val_enc)
    
    print(f'{name}')
    print(f'Previsão nos dados de TREINO:')
    print('-----------------------------------------------------')
    print(f'Mean Squared Error: {mean_squared_error(y_train, y_pred_train)}')
    print(f'Mean Absolute Error: {mean_absolute_error(y_train, y_pred_train)}')
    print(f'R2 score: {r2_score(y_train, y_pred_train)}\n')
    
    print(f'Previsão nos dados de VALIDAÇÃO:')
    print('-----------------------------------------------------')
    print(f'Mean Squared Error: {mean_squared_error(y_val, y_pred_val)}')
    print(f'Mean Absolute Error: {mean_absolute_error(y_val, y_pred_val)}')
    print(f'R2 score: {r2_score(y_val, y_pred_val)}')
    
    print()
    print()

RANDOM FOREST
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 1899.7724113833406
Mean Absolute Error: 34.34217594918895
R2 score: 0.8997586770061896

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 13734.898749123635
Mean Absolute Error: 93.24124528091173
R2 score: 0.2591949175125823


GRADIENT BOOSTING
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 12865.16203398279
Mean Absolute Error: 90.96550459690985
R2 score: 0.3211708649473841

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 13599.108298675372
Mean Absolute Error: 93.82341955791867
R2 score: 0.2665189071307619


# criando uma lista para as variáveis de entrada
feature_list = ['host_id', 'latitude', 'longitude', 'room_type', 'reviews_per_month']

# separando o X e y
X = df_train_val[feature_list]
y = df_train_val.price


# separando em treino e validação
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=seed)

# # checando as dimensões
# print(X_train.shape, X_val.shape, y_train.shape, y_val.shape)

# cópias dos conjuntos de dados
X_train_enc = X_train.copy()
X_val_enc = X_val.copy()


# instanciando o algoritmo
le = LabelEncoder()

# treinando com os dados de treino
le.fit(X_train['room_type'])

# realizando as transformações
X_train_enc['room_type'] = le.transform(X_train['room_type'])
X_val_enc['room_type'] = le.transform(X_val['room_type'])



# preenchendo os dados nulos
X_train_enc['reviews_per_month'] = X_train_enc['reviews_per_month'].fillna(X_train_enc.reviews_per_month.mean())
X_val_enc['reviews_per_month'] = X_val_enc['reviews_per_month'].fillna(X_train_enc.reviews_per_month.mean())



scaler = StandardScaler()
scaler.fit(X_train_enc)

X_train_enc = scaler.transform(X_train_enc)
X_val_enc = scaler.transform(X_val_enc)

# y_log = np.log1p(y)


# visualizando o resultado
pd.DataFrame(X_train_enc, columns=feature_list)


# instanciando os modelos
rfr = RandomForestRegressor(n_estimators=1000)
gbr = GradientBoostingRegressor(random_state=seed)

# criando uma lista de tuplas com o nome e modelo treinado
models = [('RANDOM FOREST', rfr),
          ('GRADIENT BOOSTING', gbr)]

# rodando o loop para obter os resultados
for name, model in models:
    model.fit(X_train_enc, y_train)
    y_pred_train = model.predict(X_train_enc)
    y_pred_val = model.predict(X_val_enc)
    
    print(f'{name}')
    print(f'Previsão nos dados de TREINO:')
    print('-----------------------------------------------------')
    print(f'Mean Squared Error: {mean_squared_error(y_train, y_pred_train)}')
    print(f'Mean Absolute Error: {mean_absolute_error(y_train, y_pred_train)}')
    print(f'R2 score: {r2_score(y_train, y_pred_train)}\n')
    
    print(f'Previsão nos dados de VALIDAÇÃO:')
    print('-----------------------------------------------------')
    print(f'Mean Squared Error: {mean_squared_error(y_val, y_pred_val)}')
    print(f'Mean Absolute Error: {mean_absolute_error(y_val, y_pred_val)}')
    print(f'R2 score: {r2_score(y_val, y_pred_val)}')
    
    print()
    print()

RANDOM FOREST
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 1908.7631631741406
Mean Absolute Error: 34.40932582131649
R2 score: 0.8992842807844008

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 13701.754212243062
Mean Absolute Error: 93.15246620237416
R2 score: 0.2609826002488227


GRADIENT BOOSTING
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 13001.004970035261
Mean Absolute Error: 91.63992179956477
R2 score: 0.3140031244603285

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 13613.572991945266
Mean Absolute Error: 94.09075999091648
R2 score: 0.2657387398731297


# criando uma lista para as variáveis de entrada
feature_list = ['host_id', 'latitude', 'longitude', 'room_type', 'minimum_nights', 'number_of_reviews', 
                'reviews_per_month', 'calculated_host_listings_count', 'availability_365']

# separando o X e y
X = df_train_val[feature_list]
y = df_train_val.price



# separando em treino e validação
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=seed)

# # checando as dimensões
# print(X_train.shape, X_val.shape, y_train.shape, y_val.shape)

# cópias dos conjuntos de dados
X_train_enc = X_train.copy()
X_val_enc = X_val.copy()


# instanciando o algoritmo
le = LabelEncoder()

# treinando com os dados de treino
le.fit(X_train['room_type'])

# realizando as transformações
X_train_enc['room_type'] = le.transform(X_train['room_type'])
X_val_enc['room_type'] = le.transform(X_val['room_type'])



# preenchendo os dados nulos
X_train_enc['reviews_per_month'] = X_train_enc['reviews_per_month'].fillna(X_train_enc.reviews_per_month.mean())
X_val_enc['reviews_per_month'] = X_val_enc['reviews_per_month'].fillna(X_train_enc.reviews_per_month.mean())



scaler = StandardScaler()
scaler.fit(X_train_enc)

X_train_enc = scaler.transform(X_train_enc)
X_val_enc = scaler.transform(X_val_enc)

y_train_log = np.log1p(y_train)
y_val_log = np.log1p(y_val)

# visualizando o resultado
pd.DataFrame(X_train_enc, columns=feature_list)


# instanciando os modelos
rfr = RandomForestRegressor(n_estimators=1000)
gbr = GradientBoostingRegressor(random_state=seed)

# criando uma lista de tuplas com o nome e modelo treinado
models = [('RANDOM FOREST', rfr),
          ('GRADIENT BOOSTING', gbr)]

# rodando o loop para obter os resultados
for name, model in models:
    model.fit(X_train_enc, y_train_log)
    y_pred_train = model.predict(X_train_enc)
    y_pred_val = model.predict(X_val_enc)
    
    print(f'{name}')
    print(f'Previsão nos dados de TREINO:')
    print('-----------------------------------------------------')
    print(f'Mean Squared Error: {mean_squared_error(y_train_log, y_pred_train)}')
    print(f'Mean Absolute Error: {mean_absolute_error(y_train_log, y_pred_train)}')
    print(f'R2 score: {r2_score(y_train_log, y_pred_train)}\n')
    
    print(f'Previsão nos dados de VALIDAÇÃO:')
    print('-----------------------------------------------------')
    print(f'Mean Squared Error: {mean_squared_error(y_val_log, y_pred_val)}')
    print(f'Mean Absolute Error: {mean_absolute_error(y_val_log, y_pred_val)}')
    print(f'R2 score: {r2_score(y_val_log, y_pred_val)}')
    
    print()
    print()

RANDOM FOREST
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 0.03175201550737007
Mean Absolute Error: 0.14031220488230445
R2 score: 0.9173805517606395

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 0.22932207934225063
Mean Absolute Error: 0.37983031234047554
R2 score: 0.3752814664156625


GRADIENT BOOSTING
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 0.2284675141392957
Mean Absolute Error: 0.382229487204455
R2 score: 0.4055224634661204

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 0.24253539297411233
Mean Absolute Error: 0.393027608856783
R2 score: 0.3392857963102688


# criando uma lista para as variáveis de entrada
feature_list = ['host_id', 'latitude', 'longitude', 'room_type', 'minimum_nights', 'number_of_reviews', 
                'reviews_per_month', 'calculated_host_listings_count', 'availability_365']

# separando o X e y
X = df_train_val[feature_list]
y = df_train_val.price



# separando em treino e validação
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=seed)

# # checando as dimensões
print(X_train.shape, X_val.shape, y_train.shape, y_val.shape)

(9511, 9) (2378, 9) (9511,) (2378,)


# cópias dos conjuntos de dados
X_train_enc = X_train.copy()
X_val_enc = X_val.copy()


# # Encode feature 'amenities' and concat the data
# df_roomType =X_train_enc.room_type.str.get_dummies(sep=",")
# X_train_enc = pd.concat([X_train_enc, df_roomType], axis=1).drop('room_type', axis=1)

# dfval_roomType =X_val_enc.room_type.str.get_dummies(sep=",")
# X_val_enc = pd.concat([X_val_enc, dfval_roomType], axis=1).drop('room_type', axis=1)

# instanciando o algoritmo
le = LabelEncoder()

# treinando com os dados de treino
le.fit(X_train['room_type'])

# realizando as transformações
X_train_enc['room_type'] = le.transform(X_train['room_type'])
X_val_enc['room_type'] = le.transform(X_val['room_type'])


# preenchendo os dados nulos
# X_train_enc['reviews_per_month'] = X_train_enc['reviews_per_month'].fillna(X_train_enc.reviews_per_month.mean())
# X_val_enc['reviews_per_month'] = X_val_enc['reviews_per_month'].fillna(X_train_enc.reviews_per_month.mean())

X_train_enc['reviews_per_month'] = X_train_enc['reviews_per_month'].fillna(0)
X_val_enc['reviews_per_month'] = X_val_enc['reviews_per_month'].fillna(0)


scaler = StandardScaler()
scaler.fit(X_train_enc)

X_train_enc = scaler.transform(X_train_enc)
X_val_enc = scaler.transform(X_val_enc)

y_train_log = np.log1p(y_train)
y_val_log = np.log1p(y_val)

# visualizando o resultado
X_train_enc

array([[ 0.34640477, -1.33731485, -1.23662165, ..., -0.19412377,
        -0.39659098, -1.52846324],
       [-0.19388271, -0.62808361,  0.31875278, ..., -0.43671631,
        -0.39659098,  0.36959772],
       [ 1.81477875,  0.54077012,  0.58107544, ..., -0.43671631,
        -0.39659098,  0.99995007],
       ...,
       [-0.84947412, -0.18076765,  0.70331492, ..., -0.33563609,
        -0.17670193,  1.0139579 ],
       [-0.36092047,  1.37788235,  0.55000281, ..., -0.43671631,
        -0.17670193,  1.0139579 ],
       [-0.94881009,  1.64167036,  0.18328435, ..., -0.43671631,
        -0.39659098,  0.99294616]])


# instanciando os modelos
rfr = RandomForestRegressor(n_estimators=1000)
gbr = GradientBoostingRegressor(random_state=seed)

# criando uma lista de tuplas com o nome e modelo treinado
models = [('RANDOM FOREST', rfr),
          ('GRADIENT BOOSTING', gbr)]

# rodando o loop para obter os resultados
for name, model in models:
    model.fit(X_train_enc, y_train_log)
    y_pred_train = model.predict(X_train_enc)
    y_pred_val = model.predict(X_val_enc)
    
    print(f'{name}')
    print(f'Previsão nos dados de TREINO:')
    print('-----------------------------------------------------')
    print(f'Mean Squared Error: {mean_squared_error(y_train_log, y_pred_train)}')
    print(f'Mean Absolute Error: {mean_absolute_error(y_train_log, y_pred_train)}')
    print(f'R2 score: {r2_score(y_train_log, y_pred_train)}\n')
    
    print(f'Previsão nos dados de VALIDAÇÃO:')
    print('-----------------------------------------------------')
    print(f'Mean Squared Error: {mean_squared_error(y_val_log, y_pred_val)}')
    print(f'Mean Absolute Error: {mean_absolute_error(y_val_log, y_pred_val)}')
    print(f'R2 score: {r2_score(y_val_log, y_pred_val)}')
    
    print()
    print()

RANDOM FOREST
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 0.03157922334455209
Mean Absolute Error: 0.14013145948154393
R2 score: 0.9178301607988057

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 0.22879685599278685
Mean Absolute Error: 0.37874115550344084
R2 score: 0.3767122783183907


GRADIENT BOOSTING
Previsão nos dados de TREINO:
-----------------------------------------------------
Mean Squared Error: 0.22684167483486747
Mean Absolute Error: 0.3809180488113259
R2 score: 0.40975293337838614

Previsão nos dados de VALIDAÇÃO:
-----------------------------------------------------
Mean Squared Error: 0.24183784806212508
Mean Absolute Error: 0.39224677875386327
R2 score: 0.34118604610643233


# número de árvores para random forest
n_estimators = [int(x) for x in np.linspace(start = 200, stop = 2000, num = 10)]

# número de variáveis para considerar em cada divisão
max_features = ['auto', 'sqrt']

# número máximo de níveis na árvore
max_depth = [int(x) for x in np.linspace(10, 110, num = 11)]
max_depth.append(None)

# número mínimo de amostras requeridas na divisão de um nó
min_samples_split = [2, 5, 10]

# número mínimo de amostras requeridas em cada nó da folha
min_samples_leaf = [1, 2, 4]

# métodos de seleção da amostra para treino em cada árvore
bootstrap = [True, False]

# criando um grid aleatório
random_grid = {'n_estimators': n_estimators,
               'max_features': max_features,
               'max_depth': max_depth,
               'min_samples_split': min_samples_split,
               'min_samples_leaf': min_samples_leaf,
               'bootstrap': bootstrap,
               'ccp_alpha':[0.0, 0.1, 0.2]}

# imprimindo os valores
pprint(random_grid)

{'bootstrap': [True, False],
 'ccp_alpha': [0.0, 0.1, 0.2],
 'max_depth': [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, None],
 'max_features': ['auto', 'sqrt'],
 'min_samples_leaf': [1, 2, 4],
 'min_samples_split': [2, 5, 10],
 'n_estimators': [200, 400, 600, 800, 1000, 1200, 1400, 1600, 1800, 2000]}


# instanciando o algoritmo para tunning
rf = RandomForestRegressor()

# Random search dos parâmetros, usando 3 fold cross validation, 
# busca em 100 diferentes combinações, e uso de todas as variáveis
rf_random = RandomizedSearchCV(estimator = rf, param_distributions = random_grid, n_iter = 100, cv = 3, verbose=2, random_state=seed, n_jobs = -1)

# treinando o modelo com RandomSearch
rf_random.fit(X_train_enc, y_train_log)

Fitting 3 folds for each of 100 candidates, totalling 300 fits

[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.
[Parallel(n_jobs=-1)]: Done  25 tasks      | elapsed:  3.5min
[Parallel(n_jobs=-1)]: Done 146 tasks      | elapsed: 22.5min
[Parallel(n_jobs=-1)]: Done 300 out of 300 | elapsed: 44.9min finished

RandomizedSearchCV(cv=3, estimator=RandomForestRegressor(), n_iter=100,
                   n_jobs=-1,
                   param_distributions={'bootstrap': [True, False],
                                        'ccp_alpha': [0.0, 0.1, 0.2],
                                        'max_depth': [10, 20, 30, 40, 50, 60,
                                                      70, 80, 90, 100, 110,
                                                      None],
                                        'max_features': ['auto', 'sqrt'],
                                        'min_samples_leaf': [1, 2, 4],
                                        'min_samples_split': [2, 5, 10],
                                        'n_estimators': [200, 400, 600, 800,
                                                         1000, 1200, 1400, 1600,
                                                         1800, 2000]},
                   random_state=1, verbose=2)


# verificando os melhores hiperparâmetros encontrados
rf_random.best_params_

{'n_estimators': 1800,
 'min_samples_split': 5,
 'min_samples_leaf': 1,
 'max_features': 'sqrt',
 'max_depth': 40,
 'ccp_alpha': 0.0,
 'bootstrap': True}


# instanciando com os melhores hiperparâmetros
best_random  = rf_random.best_estimator_


# treinando com os melhores hiperparâmetros
best_random.fit(X_train_enc, y_train_log)

RandomForestRegressor(max_depth=40, max_features='sqrt', min_samples_split=5,
                      n_estimators=1800)


# realizando as previsões
y_pred_train = best_random.predict(X_train_enc)
y_pred_val = best_random.predict(X_val_enc)

print(f'Previsão nos dados de treino:')
print('-----------------------------------------------------')
print(f'Mean Squared Error: {mean_squared_error(y_train_log, y_pred_train)}')
print(f'Mean Absolute Error: {mean_absolute_error(y_train_log, y_pred_train)}')
print(f'R2 score: {r2_score(y_train_log, y_pred_train)}\n')

print(f'Previsão nos dados de Validação:')
print('-----------------------------------------------------')
print(f'Mean Squared Error: {mean_squared_error(y_val_log, y_pred_val)}')
print(f'Mean Absolute Error: {mean_absolute_error(y_val_log, y_pred_val)}')
print(f'R2 score: {r2_score(y_val_log, y_pred_val)}')

Previsão nos dados de treino:
-----------------------------------------------------
Mean Squared Error: 0.056329524690438657
Mean Absolute Error: 0.18562398299382518
R2 score: 0.8534293280239411

Previsão nos dados de Validação:
-----------------------------------------------------
Mean Squared Error: 0.22737415261098484
Mean Absolute Error: 0.3800532082570786
R2 score: 0.38058800268367676


# instanciando a área de plotagem
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 3))

# plotando os gráficos
sns.regplot(x=y_train_log, y=y_pred_train, ax=ax1)

ax1.grid(axis='y')
ax1.set_xlabel('Dados atuais')
ax1.set_ylabel('Dados previstos')
ax1.set_title('Previsão nos dados de TREINO')
plt.setp(ax1.get_xticklabels(), rotation=45);

sns.regplot(x=y_val_log, y=y_pred_val, ax=ax2)

ax2.grid(axis='y')
ax2.set_xlabel('Dados atuais')
ax2.set_ylabel('Dados previstos')
ax2.set_title('Previsão nos dados de VALIDAÇÃO')
plt.tight_layout()


# {'n_estimators': 1800,
#  'min_samples_split': 5,
#  'min_samples_leaf': 1,
#  'max_features': 'sqrt',
#  'max_depth': 40,
#  'ccp_alpha': 0.0,
#  'bootstrap': True}


# criando o grid para refinar os hiperparâmetros
param_grid = {'n_estimators': [1600, 1800, 1900],
              'min_samples_split': [4, 5, 6],
              'min_samples_leaf': [1, 2],
              'max_features': ['sqrt'],
              'max_depth': [30, 40, 50],
              'bootstrap': [True]}

# instanciando o algoritmo
rf = RandomForestRegressor()

# utilizando o GridSearch
grid_search = GridSearchCV(estimator = rf, param_grid = param_grid, 
                          cv = 3, n_jobs = -1, verbose = 2)

# treinando com GridSearch
grid_search.fit(X_train_enc, y_train_log)

Fitting 3 folds for each of 54 candidates, totalling 162 fits

[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.
[Parallel(n_jobs=-1)]: Done  25 tasks      | elapsed:  3.0min
[Parallel(n_jobs=-1)]: Done 146 tasks      | elapsed: 14.6min
[Parallel(n_jobs=-1)]: Done 162 out of 162 | elapsed: 16.1min finished

GridSearchCV(cv=3, estimator=RandomForestRegressor(), n_jobs=-1,
             param_grid={'bootstrap': [True], 'max_depth': [30, 40, 50],
                         'max_features': ['sqrt'], 'min_samples_leaf': [1, 2],
                         'min_samples_split': [4, 5, 6],
                         'n_estimators': [1600, 1800, 1900]},
             verbose=2)


# verificando os melhores hiperparâmetros encontrados
grid_search.best_params_

{'bootstrap': True,
 'max_depth': 50,
 'max_features': 'sqrt',
 'min_samples_leaf': 1,
 'min_samples_split': 4,
 'n_estimators': 1600}


# instanciando com os melhores hiperparâmetros
best_random_grid  = grid_search.best_estimator_


# treinando com os melhores hiperparâmetros
best_random_grid.fit(X_train_enc, y_train_log)

RandomForestRegressor(max_depth=50, max_features='sqrt', min_samples_split=4,
                      n_estimators=1600)


# realizando as previsões
y_pred_train = best_random_grid.predict(X_train_enc)
y_pred_val = best_random_grid.predict(X_val_enc)

print(f'Previsão nos dados de treino:')
print('-----------------------------------------------------')
print(f'Mean Squared Error: {mean_squared_error(y_train_log, y_pred_train)}')
print(f'Mean Absolute Error: {mean_absolute_error(y_train_log, y_pred_train)}')
print(f'R2 score: {r2_score(y_train_log, y_pred_train)}\n')

print(f'Previsão nos dados de Validação:')
print('-----------------------------------------------------')
print(f'Mean Squared Error: {mean_squared_error(y_val_log, y_pred_val)}')
print(f'Mean Absolute Error: {mean_absolute_error(y_val_log, y_pred_val)}')
print(f'R2 score: {r2_score(y_val_log, y_pred_val)}')

Previsão nos dados de treino:
-----------------------------------------------------
Mean Squared Error: 0.047176729622570475
Mean Absolute Error: 0.1697310067062503
R2 score: 0.8772451036927229

Previsão nos dados de Validação:
-----------------------------------------------------
Mean Squared Error: 0.22627808757881224
Mean Absolute Error: 0.379149000795876
R2 score: 0.3835738998182916


# instanciando a área de plotagem
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 3))

# plotando os gráficos
sns.regplot(x=y_train_log, y=y_pred_train, ax=ax1)

ax1.grid(axis='y')
ax1.set_xlabel('Dados atuais')
ax1.set_ylabel('Dados previstos')
ax1.set_title('Previsão nos dados de TREINO')
plt.setp(ax1.get_xticklabels(), rotation=45);

sns.regplot(x=y_val_log, y=y_pred_val, ax=ax2)

ax2.grid(axis='y')
ax2.set_xlabel('Dados atuais')
ax2.set_ylabel('Dados previstos')
ax2.set_title('Previsão nos dados de VALIDAÇÃO')
plt.tight_layout()


# criando uma lista para as variáveis de entrada
feature_list = ['host_id', 'latitude', 'longitude', 'room_type', 'minimum_nights', 'number_of_reviews', 
                'reviews_per_month', 'calculated_host_listings_count', 'availability_365']


# dividindo os dados em X e y
X = df_train_val[feature_list]
y = df_train_val.price

# criando uma cópia para modificação
X_enc = X.copy()


# intanciando o LabelEncoder
le = LabelEncoder()

# treinando o encoder com todos os dados
le.fit(X['room_type'])

# encoding dos dados
X_enc['room_type'] = le.transform(X['room_type'])

# preenchendo o valores faltantes com 0
X_enc['reviews_per_month'] = X_enc['reviews_per_month'].fillna(0)


# instando o StanderdScaler
scaler = StandardScaler()

# treinando com todos os dados de treino
scaler.fit(X_enc)

# transformando os dados de treino
X_enc = scaler.transform(X_enc)

# normalizando a variável resposta
y_log = np.log1p(y)


# treinando o modelo com todos os dados de X e y
best_random_grid.fit(X_enc, y_log)

RandomForestRegressor(max_depth=50, max_features='sqrt', min_samples_split=4,
                      n_estimators=1600)


# verificando as primeiras 5 linhas do conjunto de testes
df_test.head()


# separando os dados em X e y no conjunto de teste
X_test = df_test[feature_list]
y_test = df_test.price

# criando uma cópia do dataset
X_test_enc = X_test.copy()

# realizando as transformações
X_test_enc['room_type'] = le.transform(X_test_enc['room_type'])

# preenchendo os dados ausentes com 0
X_test_enc['reviews_per_month'] = X_test_enc['reviews_per_month'].fillna(0)


# realizando as transformações
X_test_enc = scaler.transform(X_test_enc)


# normalizando a variável resposta
y_test_log = np.log1p(y_test)


# realizando as previsões
y_pred_train_total = best_random_grid.predict(X_enc)
y_pred_test = best_random_grid.predict(X_test_enc)

print(f'Previsão nos dados de treino total:')
print('-----------------------------------------------------')
print(f'Mean Squared Error: {mean_squared_error(y_log, y_pred_train_total)}')
print(f'Mean Absolute Error: {mean_absolute_error(y_log, y_pred_train_total)}')
print(f'R2 score: {r2_score(y_log, y_pred_train_total)}\n')

print(f'Previsão nos dados de Teste:')
print('-----------------------------------------------------')
print(f'Mean Squared Error: {mean_squared_error(y_test_log, y_pred_test)}')
print(f'Mean Absolute Error: {mean_absolute_error(y_test_log, y_pred_test)}')
print(f'R2 score: {r2_score(y_test_log, y_pred_test)}')

Previsão nos dados de treino total:
-----------------------------------------------------
Mean Squared Error: 0.04627544695210093
Mean Absolute Error: 0.16862386583942493
R2 score: 0.8785110926877852

Previsão nos dados de Teste:
-----------------------------------------------------
Mean Squared Error: 0.2199302824060129
Mean Absolute Error: 0.38104048502370497
R2 score: 0.41041561263625315


# definindo a área de plotagem
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 3))

# plotando os gráficos
sns.regplot(x=y_log, y=y_pred_train_total, ax=ax1)

ax1.grid(axis='y')
ax1.set_xlabel('Dados atuais')
ax1.set_ylabel('Dados previstos')
ax1.set_title('Previsão nos dados de TREINO')
plt.setp(ax1.get_xticklabels(), rotation=45);

sns.regplot(x=y_test_log, y=y_pred_test, ax=ax2)

ax2.grid(axis='y')
ax2.set_xlabel('Dados atuais')
ax2.set_ylabel('Dados previstos')
ax2.set_title('Previsão nos dados de TESTE')
plt.tight_layout()


# desnormalizando os dados previstos
np.expm1(y_pred_test)

array([258.958392  , 276.19344631, 237.17828711, ..., 226.92581208,
       373.45346721, 330.07111458])


# inserindo no conjuntod de dados de treino
df_test['predict'] = np.expm1(y_pred_test)


# verificando as primeiras 5 linhas da variável alvo e o valor previsto
df_test[['price', 'predict']].head()

	name	host_id	host_name	neighbourhood_group	neighbourhood	latitude	longitude	room_type	price	minimum_nights	number_of_reviews	last_review	reviews_per_month	calculated_host_listings_count	availability_365
id
17878	Very Nice 2Br in Copacabana w. balcony, fast WiFi	68997	Matthias	NaN	Copacabana	-22.96592	-43.17896	Entire home/apt	221	5	260	2021-02-08	2.01	1	304
24480	Nice and cozy near Ipanema Beach	99249	Goya	NaN	Ipanema	-22.98570	-43.20193	Entire home/apt	307	3	85	2018-02-14	0.67	1	10
25026	Beautiful Modern Decorated Studio in Copa	3746246	Ghizlane	NaN	Copacabana	-22.97712	-43.19045	Entire home/apt	160	7	238	2020-02-15	1.82	11	328
35636	Cosy flat close to Ipanema beach	153232	Patricia	NaN	Ipanema	-22.98816	-43.19359	Entire home/apt	273	2	181	2020-03-15	2.02	1	207
35764	COPACABANA SEA BREEZE - RIO - 20 X Superhost	153691	Patricia Miranda & Paulo	NaN	Copacabana	-22.98127	-43.19046	Entire home/apt	135	3	353	2021-02-10	2.79	1	101

	price	minimum_nights	number_of_reviews	reviews_per_month	calculated_host_listings_count	availability_365
count	26615.000000	26615.000000	26615.000000	16657.000000	26615.000000	26615.000000
mean	742.589254	4.725268	12.146308	0.629190	9.665414	219.438174
std	5368.868834	19.102522	29.722813	0.876064	35.942124	141.525405
min	0.000000	1.000000	0.000000	0.010000	1.000000	0.000000
25%	157.000000	1.000000	0.000000	0.090000	1.000000	88.000000
50%	280.000000	2.000000	2.000000	0.270000	1.000000	254.000000
75%	550.000000	4.000000	9.000000	0.850000	3.000000	363.000000
max	625216.000000	1000.000000	446.000000	29.530000	295.000000	365.000000

	name	host_name	neighbourhood	room_type
count	26586	26591	26615	26615
unique	25807	5145	151	4
top	Apartamento em Copacabana	Daniel	Copacabana	Entire home/apt
freq	34	312	7712	19285

	room_type	price
room_type
Entire home/apt	8058	292.953835
Private room	4606	196.796570
Hotel room	51	174.882353
Shared room	495	134.064646

	host_id	latitude	longitude	room_type	minimum_nights	number_of_reviews	reviews_per_month	calculated_host_listings_count	availability_365
id
22431596	159111483	-23.01033	-43.36819	0	2	4	0.12	1	2
30037231	95785079	-22.98382	-43.21652	0	4	0	NaN	1	273
41886580	331217718	-22.94013	-43.19094	0	2	0	NaN	1	363
47869957	258390952	-22.98240	-43.19380	0	2	1	1.00	1	180
47981244	305072898	-22.96499	-43.17447	0	2	0	NaN	4	178

Projeto: Previsão do preço da estadia¶

Desafio¶

Sobre o dataset¶

Sumário e principais resultados¶

Algoritmo Final Selecionado¶

Métricas de Avaliação¶

Index¶

Conclusões e Resultados¶

1. Imports¶

1.1. Bibliotecas¶

1.2. Conjunto de dados¶

1.3. Dicionário das variáveis¶

2. Análise Exploratória dos dados¶

2.1. Descrição dos dados¶

2.2. Respondendo à perguntas¶

Qual a média de preços de aluguel, no geral, e a média por região?¶

Quais as regiões mais caras?¶

Quais os tipos de quartos mais alugados?¶

Qual a variação de demanda ao longo do tempo?¶

Qual a variação do preço ao longo do tempo?¶

3. Machine Learning¶

3.1. Preparação dos dados¶

3.2. Definindo a baseline¶

3.3. Tranformação dos dados¶

3.4. Escolhendo o modelo¶

3.5. Variação no treino dos modelos¶

3.5.1. 1º Tunning do modelo selecionado¶

3.5.2. 2º Tunning do modelo selecionado¶

4. Treinamento com todos os dados¶

4.1. Previsão nos dados de teste¶

5. Conclusão¶

	valores_nulos	tipo_dados	valores_unicos
name	0.00	object	25807
host_id	0.00	int64	17324
host_name	0.00	object	5145
neighbourhood_group	1.00	float64	0
neighbourhood	0.00	object	151
latitude	0.00	float64	9873
longitude	0.00	float64	12257
room_type	0.00	object	4
price	0.00	int64	1694
minimum_nights	0.00	int64	67
number_of_reviews	0.00	int64	268
last_review	0.37	object	1469
reviews_per_month	0.37	float64	492
calculated_host_listings_count	0.00	int64	49
availability_365	0.00	int64	366

	host_id	latitude	longitude	room_type	reviews_per_month
0	0.346405	-1.337315	-1.236622	-0.789081	-0.507305
1	-0.193883	-0.628084	0.318753	-0.789081	0.000000
2	1.814779	0.540770	0.581075	-0.789081	0.000000
3	1.193436	-0.590094	0.551746	-0.789081	1.392077
4	1.591717	-0.124318	0.749975	-0.789081	0.000000
...	...	...	...	...	...
9506	-0.895237	-0.053957	0.845039	-0.789081	2.643943
9507	-0.538988	0.049311	0.498420	1.133786	0.000000
9508	-0.849474	-0.180768	0.703315	1.133786	-0.658393
9509	-0.360920	1.377882	0.550003	1.133786	0.000000
9510	-0.948810	1.641670	0.183284	-0.789081	0.000000

	name	host_id	host_name	neighbourhood	latitude	longitude	room_type	price	minimum_nights	number_of_reviews	last_review	reviews_per_month	calculated_host_listings_count	availability_365
id
46988142	Apto 3qts / 6 pessoas no Bosque da Barra da Ti...	5754974	Carlos Eduardo	Barra da Tijuca	-22.99321	-43.40320	Entire home/apt	313	3	2	2021-02-08	2.00	1	40
46638396	Loft próximo ao mar em resort em São Conrado. Gym	340964981	João	São Conrado	-22.99498	-43.27212	Entire home/apt	125	1	3	2021-02-14	1.08	1	179
36756540	Ben localizado apartamento de 90mq in Copacab...	16018428	Renzo	Copacabana	-22.96208	-43.17648	Entire home/apt	250	7	0	NaT	NaN	4	173
11585554	Gávea- Excelente quarto e sala	27229964	Beatriz	Gávea	-22.97710	-43.22977	Entire home/apt	350	1	0	NaT	NaN	15	0
46578541	Aproveite o Rio na melhor localidade da cidade!	349173829	Caio	Ipanema	-22.98481	-43.21362	Entire home/apt	220	2	0	NaT	NaN	1	364

	price	predict
id
46988142	313	258.958392
46638396	125	276.193446
36756540	250	237.178287
11585554	350	301.844550
46578541	220	373.714178