Apostila Aula 3 - Intensivão de Python

10/02/2021 Ciência de Dados

Ciência de Dados

O que é?

É você usar os dados/informações do negócio para extrair informações valiosas e ajudar na
tomada de decisão.
De forma simples e o que é usado em muitas empresas -> É você resolver um desafio da
empresa/do negócio usando os dados disponíveis
O certo seria: Ciência de Dados tá preocupado em resolver os desafios do negócio e saber o
que fazer no futuro, fazer alguma previsão que vai ajudar a tomar o rumo da empresa e o
Business Intelligence tá em descrever como as coisas funcionaram/funcionaram até aqui

Diferença de Ciência de Dados e Machine Learning

Machine Learning faz parte da Ciência de Dados, é um modelo disponível para ajudar a prever
alguma coisa.

Onde podemos aplicar Ciência de Dados

Em qualquer empresa basicamente, afinal, todas as empresas tem dados disponíveis.
Mas na prática, podemos aplicar em todo lugar porque o objetivo é resolver um desafio do
negócio usando dados. Então em qualquer empresa que você consiga usar os dados
disponíveis para resolver um desafio da empresa, você pode aplicar Ciência de Dados

Como funciona um Projeto de Ciência de Dados na prática

São várias etapas importantes, de forma bem completa:

1. Entendimento do Desafio que você quer resolver
2. Entendimento da Empresa/Área
3. Extração/Obtenção de Dados
4. Ajustes de Dados (Limpeza de Dados)
5. Análise Exploratória
6. Modelagem + Algoritmos
7. Interpretação dos Resultados
8. Deploy/Produção

Onde o Python entra no meio disso tudo?

O Python é a ferramenta que vai te permitir fazer isso tudo, vamos ver agora na prática

In [ ]:

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Ciência de Dados.ipynb?download=false 1/1

8 ETA

1. Entendimento do Desafio 3. Extração/Obt
2. Entendimento da 4. Ajustes de Da
Empresa/Área
Dad
5. Análise E

APAS DE UM PROJETO

Python

tenção de Dados 6. Modelagem + Algoritmos

ados (Limpeza de 7. Interpretação do resultado
dos)

Exploratória 8. Deploy/Produção

10/02/2021 Gabarito - Solução Airbnb Rio

Projeto Airbnb Rio - Ferramenta de Previsão
de Preço de Imóvel para pessoas comuns

Contexto

No Airbnb, qualquer pessoa que tenha um quarto ou um imóvel de qualquer tipo (apartamento,
casa, chalé, pousada, etc.) pode ofertar o seu imóvel para ser alugado por diária.

Você cria o seu perfil de host (pessoa que disponibiliza um imóvel para aluguel por diária) e cria o
anúncio do seu imóvel.

Nesse anúncio, o host deve descrever as características do imóvel da forma mais completa possível,
de forma a ajudar os locadores/viajantes a escolherem o melhor imóvel para eles (e de forma a
tornar o seu anúncio mais atrativo)

Existem dezenas de personalizações possíveis no seu anúncio, desde quantidade mínima de diária,
preço, quantidade de quartos, até regras de cancelamento, taxa extra para hóspedes extras,
exigência de verificação de identidade do locador, etc.

Nosso objetivo

Construir um modelo de previsão de preço que permita uma pessoa comum que possui um imóvel
possa saber quanto deve cobrar pela diária do seu imóvel.

Ou ainda, para o locador comum, dado o imóvel que ele está buscando, ajudar a saber se aquele
imóvel está com preço atrativo (abaixo da média para imóveis com as mesmas características) ou
não.

O que temos disponível, inspirações e créditos

As bases de dados foram retiradas do site kaggle: https://www.kaggle.com/allanbruno/airbnb-rio-
de-janeiro

Elas estão disponíveis para download abaixo da aula (se você puxar os dados direto do Kaggle pode
ser que encontre resultados diferentes dos meus, afinal as bases de dados podem ter sido
atualizadas).

Caso queira uma outra solução, podemos olhar como referência a solução do usuário Allan Bruno
do kaggle no Notebook: https://www.kaggle.com/allanbruno/helping-regular-people-price-listings-
on-airbnb

Você vai perceber semelhanças entre a solução que vamos desenvolver aqui e a dele, mas também
algumas diferenças significativas no processo de construção do projeto.

As bases de dados são os preços dos imóveis obtidos e suas respectivas características em cada
mês.

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 1/33

10/02/2021 Gabarito - Solução Airbnb Rio

Os preços são dados em reais (R$)
Temos bases de abril de 2018 a maio de 2020, com exceção de junho de 2018 que não possui
base de dados

Expectativas Iniciais

Acredito que a sazonalidade pode ser um fator importante, visto que meses como dezembro
costumam ser bem caros no RJ
A localização do imóvel deve fazer muita diferença no preço, já que no Rio de Janeiro a
localização pode mudar completamente as características do lugar (segurança, beleza natural,
pontos turísticos)
Adicionais/Comodidades podem ter um impacto significativo, visto que temos muitos prédios e
casas antigos no Rio de Janeiro

Vamos descobrir o quanto esses fatores impactam e se temos outros fatores não tão intuitivos que
são extremamente importantes.

Importar Bibliotecas e Bases de Dados

Se o bloco abaixo der erro no seu computador, pesquise pelo programa "prompt Anaconda" e
execute os seguintes códigos de instalação:

pip install seaborn
pip install plotly

In [2]: import pandas as pd
import pathlib
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import plotly.express as px
from sklearn.metrics import r2_score, mean_squared_error
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor
from sklearn.model_selection import train_test_split

Agora vamos importar as bases de dados

Para isso, vamos criar um dicionário com os 3 primeiros caracteres com os nomes dos meses e o
número correspondente daquele mês.

Para cada arquivo da base de dados a gente vai importar o arquivo e criar uma coluna na base de
dados com o mês e o ano de cada informação

In [4]: meses = {'jan': 1, 'fev':2, 'mar':3, 'abr': 4, 'mai':5, 'jun': 6, 'jul': 7, 'ago': 8, '
caminho_bases = pathlib.Path('dataset')

base_airbnb = pd.DataFrame()

for arquivo in caminho_bases.iterdir():
nome_mes = arquivo.name[:3]

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 2/33

10/02/2021 Gabarito - Solução Airbnb Rio

mes = meses[nome_mes]

ano = arquivo.name[-8:]
ano = int(ano.replace('.csv', ''))

df = pd.read_csv(caminho_bases / arquivo.name, low_memory=False)
df['ano'] = ano
df['mes'] = mes
base_airbnb = base_airbnb.append(df)

display(base_airbnb)

id listing_url scrape_id last_scraped name

0 14063 https://www.airbnb.com/rooms/14063 20180414160018 2018-04-14 Living in a
Postcard

Very Nice 2Br -
1 17878 https://www.airbnb.com/rooms/17878 20180414160018 2018-04-14 Copacabana -

WiFi

Nice and cozy
2 24480 https://www.airbnb.com/rooms/24480 20180414160018 2018-04-14 near Ipanema

Beach

Beautiful

3 25026 https://www.airbnb.com/rooms/25026 20180414160018 2018-04-14 Modern
Decorated

Studio in Copa

NICE & COZY

4 31560 https://www.airbnb.com/rooms/31560 20180414160018 2018-04-14 1BDR -
IPANEMA

BEACH

... ... ... ... ... ...

TRANSAMERICA

34324 38844730 https://www.airbnb.com/rooms/38844730 20190923212307 2019-09-24 BARRA DA

TIJUCA R IV

34325 38846408 https://www.airbnb.com/rooms/38846408 20190923212307 2019-09-24 Alugo para o
Rock in Rio

34326 38846703 https://www.airbnb.com/rooms/38846703 20190923212307 2019-09-24 Apt COMPLETO
em

COPACABANA
c/TOTAL

SEGURANÇA

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 3/33

10/02/2021 Gabarito - Solução Airbnb Rio

id listing_url scrape_id last_scraped name

34327 38847050 https://www.airbnb.com/rooms/38847050 20190923212307 2019-09-24 Cobertura
Cinematografica

34328 38847655 https://www.airbnb.com/rooms/38847655 20190923212307 2019-09-24 Quarto em
cobertura em
frente à praia III

902210 rows × 108 columns

Agora vamos começar os tratamentos

Como temos muitas colunas, nosso modelo pode acabar ficando muito lento.
Além disso, uma análise rápida permite ver que várias colunas não são necessárias para o nosso
modelo de previsão, por isso, vamos excluir algumas colunas da nossa base
Tipos de colunas que vamos excluir:

1. IDs, Links e informações não relevantes para o modelo
2. Colunas repetidas ou extremamente parecidas com outra (que dão a mesma informação

para o modelo. Ex: Data x Ano/Mês
3. Colunas preenchidas com texto livre -> Não rodaremos nenhuma análise de palavras ou

algo do tipo
4. Colunas em que todos ou quase todos os valores são iguais
Para isso, vamos criar um arquivo em excel com os 1.000 primeiros registros e fazer uma análise
qualitativa, olhando as colunas e identificando quais são desnecessárias

In [5]: print(list(base_airbnb.columns))
base_airbnb.head(1000).to_csv('primeiros_registros.csv', sep=';')

['id', 'listing_url', 'scrape_id', 'last_scraped', 'name', 'summary', 'space', 'descript
ion', 'experiences_offered', 'neighborhood_overview', 'notes', 'transit', 'access', 'int
eraction', 'house_rules', 'thumbnail_url', 'medium_url', 'picture_url', 'xl_picture_ur
l', 'host_id', 'host_url', 'host_name', 'host_since', 'host_location', 'host_about', 'ho
st_response_time', 'host_response_rate', 'host_acceptance_rate', 'host_is_superhost', 'h
ost_thumbnail_url', 'host_picture_url', 'host_neighbourhood', 'host_listings_count', 'ho
st_total_listings_count', 'host_verifications', 'host_has_profile_pic', 'host_identity_v
erified', 'street', 'neighbourhood', 'neighbourhood_cleansed', 'neighbourhood_group_clea
nsed', 'city', 'state', 'zipcode', 'market', 'smart_location', 'country_code', 'countr
y', 'latitude', 'longitude', 'is_location_exact', 'property_type', 'room_type', 'accommo
dates', 'bathrooms', 'bedrooms', 'beds', 'bed_type', 'amenities', 'square_feet', 'pric
e', 'weekly_price', 'monthly_price', 'security_deposit', 'cleaning_fee', 'guests_include
d', 'extra_people', 'minimum_nights', 'maximum_nights', 'calendar_updated', 'has_availab
ility', 'availability_30', 'availability_60', 'availability_90', 'availability_365', 'ca
lendar_last_scraped', 'number_of_reviews', 'first_review', 'last_review', 'review_scores
_rating', 'review_scores_accuracy', 'review_scores_cleanliness', 'review_scores_checki
n', 'review_scores_communication', 'review_scores_location', 'review_scores_value', 'req
uires_license', 'license', 'jurisdiction_names', 'instant_bookable', 'is_business_travel
_ready', 'cancellation_policy', 'require_guest_profile_picture', 'require_guest_phone_ve
rification', 'calculated_host_listings_count', 'reviews_per_month', 'ano', 'mes', 'minim
um_minimum_nights', 'maximum_minimum_nights', 'minimum_maximum_nights', 'maximum_maximum
_nights', 'minimum_nights_avg_ntm', 'maximum_nights_avg_ntm', 'number_of_reviews_ltm',

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 4/33

10/02/2021 Gabarito - Solução Airbnb Rio

'calculated_host_listings_count_entire_homes', 'calculated_host_listings_count_private_r
ooms', 'calculated_host_listings_count_shared_rooms']

Depois da análise qualitativa das colunas, levando em conta os
critérios explicados acima, ficamos com as seguintes colunas:

In [6]: colunas = ['host_response_time','host_response_rate','host_is_superhost','host_listings_

base_airbnb = base_airbnb.loc[:, colunas]
print(list(base_airbnb.columns))
display(base_airbnb)

['host_response_time', 'host_response_rate', 'host_is_superhost', 'host_listings_count',
'latitude', 'longitude', 'property_type', 'room_type', 'accommodates', 'bathrooms', 'bed
rooms', 'beds', 'bed_type', 'amenities', 'price', 'security_deposit', 'cleaning_fee', 'g
uests_included', 'extra_people', 'minimum_nights', 'maximum_nights', 'number_of_review
s', 'review_scores_rating', 'review_scores_accuracy', 'review_scores_cleanliness', 'revi
ew_scores_checkin', 'review_scores_communication', 'review_scores_location', 'review_sco
res_value', 'instant_bookable', 'is_business_travel_ready', 'cancellation_policy', 'an
o', 'mes']

host_response_time host_response_rate host_is_superhost host_listings_count latitude longit

0 NaN NaN f 1.0 -22.946854 -43.182

1 within an hour 100% t 2.0 -22.965919 -43.178

2 within an hour 100% f 1.0 -22.985698 -43.201

3 within an hour 100% f 3.0 -22.977117 -43.190

4 within an hour 100% t 1.0 -22.983024 -43.214

... ... ... ... ... ...

34324 within an hour 93% f 0.0 -23.003180 -43.342

34325 NaN NaN f 0.0 -22.966640 -43.393

34326 within a few hours 74% f 32.0 -22.962080 -43.175

34327 NaN NaN f 0.0 -23.003400 -43.341

34328 a few days or more 38% f 5.0 -23.010560 -43.363

902210 rows × 34 columns

Tratar Valores Faltando 5/33

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false

10/02/2021 Gabarito - Solução Airbnb Rio

Visualizando os dados, percebemos que existe uma grande disparidade em dados faltantes. As
colunas com mais de 300.000 valores NaN foram excluídas da análise
Para as outras colunas, como temos muitos dados (mais de 900.000 linhas) vamos excluir as
linhas que contém dados NaN

In [7]: for coluna in base_airbnb:
if base_airbnb[coluna].isnull().sum() > 300000:
base_airbnb = base_airbnb.drop(coluna, axis=1)

print(base_airbnb.isnull().sum())

host_is_superhost 460
host_listings_count 460
latitude
longitude 0
property_type 0
room_type 0
accommodates 0
bathrooms 0
bedrooms 1724
beds 850
bed_type 2502
amenities 0
price 0
guests_included 0
extra_people 0
minimum_nights 0
maximum_nights 0
number_of_reviews 0
instant_bookable 0
is_business_travel_ready 0
cancellation_policy 0
ano 0
mes 0
dtype: int64 0

In [8]: base_airbnb = base_airbnb.dropna()

print(base_airbnb.shape)
print(base_airbnb.isnull().sum())

(897709, 23) 0
host_is_superhost 0
host_listings_count 0
latitude 0
longitude 0
property_type 0
room_type 0
accommodates 0
bathrooms 0
bedrooms 0
beds 0
bed_type 0
amenities 0
price 0
guests_included 0
extra_people 0
minimum_nights 0
maximum_nights 0
number_of_reviews 0
instant_bookable 0
is_business_travel_ready 0
cancellation_policy 0
ano

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 6/33

10/02/2021 Gabarito - Solução Airbnb Rio

mes 0
dtype: int64

Verificar Tipos de Dados em cada coluna

Precisamos fazer isso porque às vezes o Python está lendo como texto alguma coluna que
deveria ser um número, então precisamos corrigir

In [9]: print(base_airbnb.dtypes)
print('-'*60)
print(base_airbnb.iloc[0])

host_is_superhost object
host_listings_count float64
latitude float64
longitude float64
property_type object
room_type object
accommodates int64
bathrooms float64
bedrooms float64
beds float64
bed_type object
amenities object
price object
guests_included int64
extra_people object
minimum_nights int64
maximum_nights int64
number_of_reviews int64
instant_bookable object
is_business_travel_ready object
cancellation_policy object
ano int64
mes int64
dtype: object
------------------------------------------------------------
host_is_superhost f
host_listings_count 1
latitude -22.9469
longitude -43.1827
property_type Apartment
room_type Entire home/apt
accommodates 4
bathrooms 1
bedrooms 0
beds 2
bed_type Real Bed
amenities {TV,Internet,"Air conditioning",Kitchen,Doorma...
price $133.00
guests_included 2
extra_people $34.00
minimum_nights 60
maximum_nights 365
number_of_reviews 38
instant_bookable f
is_business_travel_ready f
cancellation_policy strict_14_with_grace_period
ano 2018
mes 4
Name: 0, dtype: object

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 7/33

10/02/2021 Gabarito - Solução Airbnb Rio

Como preço e extra people estão sendo reconhecidos como objeto (ao invés de ser um float)
temos que mudar o tipo de variável da coluna.

In [10]: #price
base_airbnb['price'] = base_airbnb['price'].str.replace('$', '')
base_airbnb['price'] = base_airbnb['price'].str.replace(',', '')
base_airbnb['price'] = base_airbnb['price'].astype(np.float32, copy=False)
#extra people
base_airbnb['extra_people'] = base_airbnb['extra_people'].str.replace('$', '')
base_airbnb['extra_people'] = base_airbnb['extra_people'].str.replace(',', '')
base_airbnb['extra_people'] = base_airbnb['extra_people'].astype(np.float32, copy=False
#verificando os tipos
print(base_airbnb.dtypes)

host_is_superhost object
host_listings_count float64
latitude float64
longitude float64
property_type
room_type object
accommodates object
bathrooms
bedrooms int64
beds float64
bed_type float64
amenities float64
price
guests_included object
extra_people object
minimum_nights float32
maximum_nights
number_of_reviews int64
instant_bookable float32
is_business_travel_ready
cancellation_policy int64
ano int64
mes int64
dtype: object object
object
object
int64
int64

Análise Exploratória e Tratar Outliers

Vamos basicamente olhar feature por feature para:

1. Ver a correlação entre as features e decidir se manteremos todas as features que temos.
2. Excluir outliers (usaremos como regra, valores abaixo de Q1 - 1.5xAmplitude e valores

acima de Q3 + 1.5x Amplitude). Amplitude = Q3 - Q1
3. Confirmar se todas as features que temos fazem realmente sentido para o nosso modelo

ou se alguma delas não vai nos ajudar e se devemos excluir
Vamos começar pelas colunas de preço (resultado final que queremos) e de extra_people
(também valor monetário). Esses são os valores numéricos contínuos.

Depois vamos analisar as colunas de valores numéricos discretos (accomodates, bedrooms,
guests_included, etc.)

Por fim, vamos avaliar as colunas de texto e definir quais categorias fazem sentido mantermos
ou não.

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 8/33

10/02/2021 Gabarito - Solução Airbnb Rio

MAS CUIDADO: não saia excluindo direto outliers, pense exatamente no que você está fazendo. Se
não tem um motivo claro para remover o outlier, talvez não seja necessário e pode ser prejudicial
para a generalização. Então tem que ter uma balança ai. Claro que você sempre pode testar e ver
qual dá o melhor resultado, mas fazer isso para todas as features vai dar muito trabalho.

Ex de análise: Se o objetivo é ajudar a precificar um imóvel que você está querendo disponibilizar,
excluir outliers em host_listings_count pode fazer sentido. Agora, se você é uma empresa com uma
série de propriedades e quer comparar com outras empresas do tipo também e se posicionar dessa
forma, talvez excluir quem tem acima de 6 propriedades tire isso do seu modelo. Pense sempre no
seu objetivo

In [11]: plt.figure(figsize=(15, 10))
sns.heatmap(base_airbnb.corr(), annot=True, cmap='Greens')
#print(base_airbnb.corr())

Out[11]: <AxesSubplot:>

Definição de Funções para Análise de Outliers

Vamos definir algumas funções para ajudar na análise de outliers das colunas

In [12]: def limites(coluna):
q1 = coluna.quantile(0.25)
q3 = coluna.quantile(0.75)
amplitude = q3 - q1
return q1 - 1.5 * amplitude, q3 + 1.5 * amplitude

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 9/33

10/02/2021 Gabarito - Solução Airbnb Rio

def excluir_outliers(df, nome_coluna):
qtde_linhas = df.shape[0]
lim_inf, lim_sup = limites(df[nome_coluna])
df = df.loc[(df[nome_coluna] >= lim_inf) & (df[nome_coluna] <= lim_sup), :]
linhas_removidas = qtde_linhas - df.shape[0]
return df, linhas_removidas

In [13]: def diagrama_caixa(coluna):
fig, (ax1, ax2) = plt.subplots(1, 2)
fig.set_size_inches(15, 5)
sns.boxplot(x=coluna, ax=ax1)
ax2.set_xlim(limites(coluna))
sns.boxplot(x=coluna, ax=ax2)

def histograma(coluna):
plt.figure(figsize=(15, 5))
sns.distplot(coluna, hist=True)

def grafico_barra(coluna):
plt.figure(figsize=(15, 5))
ax = sns.barplot(x=coluna.value_counts().index, y=coluna.value_counts())
ax.set_xlim(limites(coluna))

price

In [14]: diagrama_caixa(base_airbnb['price'])
histograma(base_airbnb['price'])
C:\Users\joaop\anaconda3\lib\site-packages\seaborn\distributions.py:2551: FutureWarning:
`distplot` is a deprecated function and will be removed in a future version. Please adap
t your code to use either `displot` (a figure-level function with similar flexibility) o
r `histplot` (an axes-level function for histograms).
warnings.warn(msg, FutureWarning)

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 10/33

10/02/2021 Gabarito - Solução Airbnb Rio

Como estamos construindo um modelo para imóveis comuns, acredito que os valores acima do
limite superior serão apenas de apartamentos de altíssimo luxo, que não é o nosso objetivo
principal. Por isso, podemos excluir esses outliers.

In [15]: base_airbnb, linhas_removidas = excluir_outliers(base_airbnb, 'price')
print('{} linhas removidas'.format(linhas_removidas))
87282 linhas removidas

In [16]: histograma(base_airbnb['price'])
print(base_airbnb.shape)

C:\Users\joaop\anaconda3\lib\site-packages\seaborn\distributions.py:2551: FutureWarning:
`distplot` is a deprecated function and will be removed in a future version. Please adap
t your code to use either `displot` (a figure-level function with similar flexibility) o
r `histplot` (an axes-level function for histograms).

warnings.warn(msg, FutureWarning)
(810427, 23)

extra_people

In [17]: diagrama_caixa(base_airbnb['extra_people'])
histograma(base_airbnb['extra_people'])
C:\Users\joaop\anaconda3\lib\site-packages\seaborn\distributions.py:2551: FutureWarning:
`distplot` is a deprecated function and will be removed in a future version. Please adap
t your code to use either `displot` (a figure-level function with similar flexibility) o
r `histplot` (an axes-level function for histograms).
warnings.warn(msg, FutureWarning)

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 11/33

10/02/2021 Gabarito - Solução Airbnb Rio

In [18]: base_airbnb, linhas_removidas = excluir_outliers(base_airbnb, 'extra_people')
print('{} linhas removidas'.format(linhas_removidas))
59194 linhas removidas

In [19]: histograma(base_airbnb['extra_people'])
print(base_airbnb.shape)

C:\Users\joaop\anaconda3\lib\site-packages\seaborn\distributions.py:2551: FutureWarning:
`distplot` is a deprecated function and will be removed in a future version. Please adap
t your code to use either `displot` (a figure-level function with similar flexibility) o
r `histplot` (an axes-level function for histograms).

warnings.warn(msg, FutureWarning)
(751233, 23)

host_listings_count 12/33

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false

10/02/2021 Gabarito - Solução Airbnb Rio

In [20]: diagrama_caixa(base_airbnb['host_listings_count'])
grafico_barra(base_airbnb['host_listings_count'])

Podemos excluir os outliers, porque para o objetivo do nosso projeto porque hosts com mais de 6
imóveis no airbnb não é o público alvo do objetivo do projeto (imagino que sejam imobiliários ou
profissionais que gerenciam imóveis no airbnb)

In [21]: base_airbnb, linhas_removidas = excluir_outliers(base_airbnb, 'host_listings_count')
print('{} linhas removidas'.format(linhas_removidas))
97723 linhas removidas

accommodates

In [22]: diagrama_caixa(base_airbnb['accommodates'])
grafico_barra(base_airbnb['accommodates'])

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 13/33

10/02/2021 Gabarito - Solução Airbnb Rio

Pelo mesmo motivo do "host_listings_count" vamos excluir os outliers dessa coluna porque
apartamentos que acomodam mais de 9 pessoas não são o nosso foco, nosso objetivo aqui é
para imóveis comuns.

Caso a gente quisesse incluir apartamentos de alto padrão a gente poderia manter essa variável
ou então construir um modelo só focado em imóvei com mais de 9 hóspedes

In [23]: base_airbnb, linhas_removidas = excluir_outliers(base_airbnb, 'accommodates')
print('{} linhas removidas'.format(linhas_removidas))

13146 linhas removidas

bathrooms

In [24]: diagrama_caixa(base_airbnb['bathrooms'])
plt.figure(figsize=(15, 5))
sns.barplot(x=base_airbnb['bathrooms'].value_counts().index, y=base_airbnb['bathrooms']

Out[24]: <AxesSubplot:ylabel='bathrooms'>

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 14/33

10/02/2021 Gabarito - Solução Airbnb Rio

Pelo mesmo motivo dos anteriores, vamos excluir os outliers nos banheiros
In [25]: base_airbnb, linhas_removidas = excluir_outliers(base_airbnb, 'bathrooms')

print('{} linhas removidas'.format(linhas_removidas))
6894 linhas removidas

bedrooms

In [26]: diagrama_caixa(base_airbnb['bedrooms'])
grafico_barra(base_airbnb['bedrooms'])

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 15/33

10/02/2021 Gabarito - Solução Airbnb Rio

Pelo mesmo motivo dos anteriores, vamos excluir outliers em quantidade de quartos
In [27]: base_airbnb, linhas_removidas = excluir_outliers(base_airbnb, 'bedrooms')

print('{} linhas removidas'.format(linhas_removidas))
5482 linhas removidas

beds

In [28]: diagrama_caixa(base_airbnb['beds'])
grafico_barra(base_airbnb['beds'])

Pelo mesmo motivo dos anteriores, vamos excluir outliers em quantidade de camas 16/33

In [29]: base_airbnb, linhas_removidas = excluir_outliers(base_airbnb, 'beds')
print('{} linhas removidas'.format(linhas_removidas))

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false

10/02/2021 Gabarito - Solução Airbnb Rio

5622 linhas removidas

guests_included

In [30]: #diagrama_caixa(base_airbnb['guests_included'])
#grafico_barra(base_airbnb['guests_included'])
print(limites(base_airbnb['guests_included']))
plt.figure(figsize=(15, 5))
sns.barplot(x=base_airbnb['guests_included'].value_counts().index, y=base_airbnb['guest

(1.0, 1.0)
Out[30]: <AxesSubplot:ylabel='guests_included'>

Vamos remover essa feature da análise. Parece que os usuários do airbnb usam muito o valor
padrão do airbnb como 1 guest included. Isso pode levar o nosso modelo a considerar uma feature
que na verdade não é essencial para a definição do preço, por isso, me parece melhor excluir a
coluna da análise

In [31]: base_airbnb = base_airbnb.drop('guests_included', axis=1)
base_airbnb.shape

Out[31]: (622366, 22)

minimum_nights

In [32]: diagrama_caixa(base_airbnb['minimum_nights'])
grafico_barra(base_airbnb['minimum_nights'])

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 17/33

10/02/2021 Gabarito - Solução Airbnb Rio

Aqui temos um motivo talvez até mais forte para excluir esses apartamentos da análise.

Estamos querendo um modelo que ajude a precificar apartamentos comuns como uma pessoa
comum gostaria de disponibilizar. No caso, apartamentos com mais de 8 noites como o
"mínimo de noites" podem ser apartamentos de temporada ou ainda apartamentos para morar,
em que o host exige pelo menos 1 mês no apartamento.

Por isso, vamos excluir os outliers dessa coluna

In [33]: base_airbnb, linhas_removidas = excluir_outliers(base_airbnb, 'minimum_nights')
print('{} linhas removidas'.format(linhas_removidas))
40383 linhas removidas

maximum_nights

In [34]: diagrama_caixa(base_airbnb['maximum_nights'])
grafico_barra(base_airbnb['maximum_nights'])

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 18/33

10/02/2021 Gabarito - Solução Airbnb Rio

Essa coluna não parece que vai ajudar na análise.

Isso porque parece que quase todos os hosts não preenchem esse campo de maximum nights,
então ele não parece que vai ser um fator relevante.

É melhor excluirmos essa coluna da análise

In [35]: base_airbnb = base_airbnb.drop('maximum_nights', axis=1)
base_airbnb.shape

Out[35]: (581983, 21)

number_of_reviews

In [36]: diagrama_caixa(base_airbnb['number_of_reviews'])
grafico_barra(base_airbnb['number_of_reviews'])

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 19/33

10/02/2021 Gabarito - Solução Airbnb Rio

Aqui poderíamos tomar algumas decisões diferentes. Eu vou tomar uma decisão baseado na
minha análise pessoal de tirar essa característica da análise, por alguns motivos:

1. Se excluirmos os outliers, vamos excluir as pessoas que tem a maior quantidade de reviews
(o que normalmente são os hosts que têm mais aluguel). Isso pode impactar muito
negativamente o nosso modelo

2. Pensando no nosso objetivo, se eu tenho um imóvel parado e quero colocar meu imóvel
lá, é claro que eu não tenho review nenhuma. Então talvez tirar essa característica da
análise pode na verdade acabar ajudando.

3. Particularmente tenho dúvida se essa característica deveria impactar ou não o preço final

In [37]: base_airbnb = base_airbnb.drop('number_of_reviews', axis=1)
base_airbnb.shape

Out[37]: (581983, 20)

Tratamento de Colunas de Valores de Texto

- property_type

In [38]: print(base_airbnb['property_type'].value_counts())

plt.figure(figsize=(15, 5))
grafico = sns.countplot('property_type', data=base_airbnb)
grafico.tick_params(axis='x', rotation=90)

Apartment 458354
House 51387
Condominium 26456
Serviced apartment 12671
Loft 12352
Guest suite 3621
Bed and breakfast 3472
Hostel 2665
Guesthouse 2155
Other 1957
Villa 1294
Townhouse 969
Aparthotel 693
Chalet 481
Earth house 468
Tiny house 457
Boutique hotel 447

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 20/33

10/02/2021 Gabarito - Solução Airbnb Rio

Hotel 376
Casa particular (Cuba) 298
Cottage 230
Bungalow 207
Dorm 185
Cabin 141
Nature lodge 124
Castle 80
Treehouse 76
Island 54
Boat 53
Hut 40
Campsite 34
Resort 31
Camper/RV 24
Yurt 23
Tent 18
Tipi 17
Barn 15
Farm stay 13
Pension (South Korea) 9
Dome house 8
Igloo 6
In-law 6
Vacation home 4
Pousada 3
Houseboat 3
Timeshare 3
Casa particular 2
Plane 1
Name: property_type, dtype: int64

C:\Users\joaop\anaconda3\lib\site-packages\seaborn\_decorators.py:36: FutureWarning: Pas
s the following variable as a keyword arg: x. From version 0.12, the only valid position
al argument will be `data`, and passing other arguments without an explicit keyword will
result in an error or misinterpretation.

warnings.warn(

Aqui a nossa ação não é "excluir outliers", mas sim agrupar valores que são muito pequenos.

Todos os tipos de propriedade que têm menos de 2.000 propriedades na base de dados, eu
vou agrupar em um grupo chamado "outros". Acho que isso vai facilitar o nosso modelo

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 21/33

10/02/2021 Gabarito - Solução Airbnb Rio

In [39]: tabela_tipos_casa = base_airbnb['property_type'].value_counts()
colunas_agrupar = []

for tipo in tabela_tipos_casa.index:
if tabela_tipos_casa[tipo] < 2000:
colunas_agrupar.append(tipo)

print(colunas_agrupar)

for tipo in colunas_agrupar:
base_airbnb.loc[base_airbnb['property_type']==tipo, 'property_type'] = 'Outros'

print(base_airbnb['property_type'].value_counts())
plt.figure(figsize=(15, 5))
grafico = sns.countplot('property_type', data=base_airbnb)
grafico.tick_params(axis='x', rotation=90)

['Other', 'Villa', 'Townhouse', 'Aparthotel', 'Chalet', 'Earth house', 'Tiny house', 'Bo
utique hotel', 'Hotel', 'Casa particular (Cuba)', 'Cottage', 'Bungalow', 'Dorm', 'Cabi
n', 'Nature lodge', 'Castle', 'Treehouse', 'Island', 'Boat', 'Hut', 'Campsite', 'Resor
t', 'Camper/RV', 'Yurt', 'Tent', 'Tipi', 'Barn', 'Farm stay', 'Pension (South Korea)',
'Dome house', 'Igloo', 'In-law', 'Vacation home', 'Pousada', 'Houseboat', 'Timeshare',
'Casa particular', 'Plane']
Apartment 458354
House 51387
Condominium 26456
Serviced apartment 12671
Loft 12352
Outros 8850
Guest suite 3621
Bed and breakfast 3472
Hostel 2665
Guesthouse 2155
Name: property_type, dtype: int64

C:\Users\joaop\anaconda3\lib\site-packages\seaborn\_decorators.py:36: FutureWarning: Pas
s the following variable as a keyword arg: x. From version 0.12, the only valid position
al argument will be `data`, and passing other arguments without an explicit keyword will
result in an error or misinterpretation.

warnings.warn(

- room_type 22/33

In [40]: print(base_airbnb['room_type'].value_counts())
plt.figure(figsize=(15, 5))

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false

10/02/2021 Gabarito - Solução Airbnb Rio

grafico = sns.countplot('room_type', data=base_airbnb)
grafico.tick_params(axis='x', rotation=90)

Entire home/apt 372443
Private room 196859
Shared room 11714
Hotel room 967
Name: room_type, dtype: int64

C:\Users\joaop\anaconda3\lib\site-packages\seaborn\_decorators.py:36: FutureWarning: Pas
s the following variable as a keyword arg: x. From version 0.12, the only valid position
al argument will be `data`, and passing other arguments without an explicit keyword will
result in an error or misinterpretation.

warnings.warn(

Em tipo de quarto, não precisamos fazer nada, ele já parece estar bem distribuído

- bed_type

In [41]: print(base_airbnb['bed_type'].value_counts())

plt.figure(figsize=(15, 5))
grafico = sns.countplot('bed_type', data=base_airbnb)
grafico.tick_params(axis='x', rotation=90)

# agrupando categorias de bed_type
tabela_bed = base_airbnb['bed_type'].value_counts()
colunas_agrupar = []

for tipo in tabela_bed.index:
if tabela_bed[tipo] < 10000:
colunas_agrupar.append(tipo)

print(colunas_agrupar)

for tipo in colunas_agrupar:
base_airbnb.loc[base_airbnb['bed_type']==tipo, 'bed_type'] = 'Outros'

print(base_airbnb['bed_type'].value_counts())
plt.figure(figsize=(15, 5))
grafico = sns.countplot('bed_type', data=base_airbnb)
grafico.tick_params(axis='x', rotation=90)

Real Bed 570643
Pull-out Sofa 8055
Futon 1634

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 23/33

10/02/2021 Gabarito - Solução Airbnb Rio

Airbed 1155
Couch 496
Name: bed_type, dtype: int64

C:\Users\joaop\anaconda3\lib\site-packages\seaborn\_decorators.py:36: FutureWarning: Pas
s the following variable as a keyword arg: x. From version 0.12, the only valid position
al argument will be `data`, and passing other arguments without an explicit keyword will
result in an error or misinterpretation.
warnings.warn(
['Pull-out Sofa', 'Futon', 'Airbed', 'Couch']
Real Bed 570643
Outros 11340
Name: bed_type, dtype: int64

C:\Users\joaop\anaconda3\lib\site-packages\seaborn\_decorators.py:36: FutureWarning: Pas
s the following variable as a keyword arg: x. From version 0.12, the only valid position
al argument will be `data`, and passing other arguments without an explicit keyword will
result in an error or misinterpretation.

warnings.warn(

Aqui a nossa ação não é "excluir outliers", mas sim agrupar valores que são muito pequenos.
Como temos 1 valor claramente MUITO maior do que todos os outros, vou criar apenas 2
grupos de camas: "Real Bed" e "outros"
Isso vai simplificar o modelo

- cancellation_policy

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 24/33

10/02/2021 Gabarito - Solução Airbnb Rio

In [42]: print(base_airbnb['cancellation_policy'].value_counts())

plt.figure(figsize=(15, 5))
grafico = sns.countplot('cancellation_policy', data=base_airbnb)
grafico.tick_params(axis='x', rotation=90)

# agrupando categorias de cancellation_pollicy
tabela_cancellation = base_airbnb['cancellation_policy'].value_counts()
colunas_agrupar = []

for tipo in tabela_cancellation.index:
if tabela_cancellation[tipo] < 10000:
colunas_agrupar.append(tipo)

print(colunas_agrupar)

for tipo in colunas_agrupar:
base_airbnb.loc[base_airbnb['cancellation_policy']==tipo, 'cancellation_policy'] =

print(base_airbnb['cancellation_policy'].value_counts())
plt.figure(figsize=(15, 5))
grafico = sns.countplot('cancellation_policy', data=base_airbnb)
grafico.tick_params(axis='x', rotation=90)

flexible 258096
strict_14_with_grace_period 200743
moderate 113281
strict 9696
super_strict_60 135
super_strict_30 32
Name: cancellation_policy, dtype: int64

C:\Users\joaop\anaconda3\lib\site-packages\seaborn\_decorators.py:36: FutureWarning: Pas
s the following variable as a keyword arg: x. From version 0.12, the only valid position
al argument will be `data`, and passing other arguments without an explicit keyword will
result in an error or misinterpretation.
warnings.warn(
['strict', 'super_strict_60', 'super_strict_30']
flexible 258096
strict_14_with_grace_period 200743
moderate 113281
strict 9863
Name: cancellation_policy, dtype: int64

C:\Users\joaop\anaconda3\lib\site-packages\seaborn\_decorators.py:36: FutureWarning: Pas
s the following variable as a keyword arg: x. From version 0.12, the only valid position
al argument will be `data`, and passing other arguments without an explicit keyword will
result in an error or misinterpretation.

warnings.warn(

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 25/33

10/02/2021 Gabarito - Solução Airbnb Rio

- amenities

Como temos uma diversidade muito grande de amenities e, às vezes, as mesmas amenities podem
ser escritas de forma diferente, vamos avaliar a quantidade de amenities como o parâmetro para o
nosso modelo.

In [43]: print(base_airbnb['amenities'].iloc[1].split(','))
print(len(base_airbnb['amenities'].iloc[1].split(',')))

base_airbnb['n_amenities'] = base_airbnb['amenities'].str.split(',').apply(len)
['{TV', '"Cable TV"', 'Internet', 'Wifi', '"Air conditioning"', 'Kitchen', 'Doorman', 'E
levator', '"Buzzer/wireless intercom"', '"Family/kid friendly"', 'Hangers', '"Hair drye
r"', 'Iron', '"Laptop friendly workspace"}']
14

In [44]: base_airbnb = base_airbnb.drop('amenities', axis=1)
base_airbnb.shape

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 26/33

10/02/2021 Gabarito - Solução Airbnb Rio

Out[44]: (581983, 20)

In [45]: diagrama_caixa(base_airbnb['n_amenities'])
grafico_barra(base_airbnb['n_amenities'])

Então, essa virou uma coluna de valor numérico e, como todas as outras colunas de valores
numéricos, eu exclui outliers com os mesmos modelos anteriores

In [46]: base_airbnb, linhas_removidas = excluir_outliers(base_airbnb, 'n_amenities')
print('{} linhas removidas'.format(linhas_removidas))
24343 linhas removidas

Visualização de Mapa das Propriedades

Vamos criar um mapa que exibe um pedaço da nossa base de dados aleatório (50.000
propriedades) para ver como as propriedades estão distribuídas pela cidade e também identificar os
locais de maior preço

In [47]: amostra = base_airbnb.sample(n=50000)
centro_mapa = {'lat':amostra.latitude.mean(), 'lon':amostra.longitude.mean()}
mapa = px.density_mapbox(amostra, lat='latitude', lon='longitude',z='price', radius=2.5

center=centro_mapa, zoom=10,
mapbox_style='stamen-terrain')
mapa.show()

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 27/33

10/02/2021 Gabarito - Solução Airbnb Rio

Encoding

Precisamor Ajustar as features para facilitar o trabalho do modelo futuro (features de categoria, true
e false, etc.)

Features de Valores True ou False, vamos substituir True por 1 e False por 0.
Features de Categoria (features em que os valores da coluna são textos) vamos utilizar o
método de encoding de variáveis dummies

In [48]: colunas_tf = ['host_is_superhost', 'instant_bookable', 'is_business_travel_ready']
base_airbnb_cod = base_airbnb.copy()
for coluna in colunas_tf:

base_airbnb_cod.loc[base_airbnb_cod[coluna]=='t', coluna] = 1
base_airbnb_cod.loc[base_airbnb_cod[coluna]=='f', coluna] = 0

In [49]: colunas_categorias = ['property_type', 'room_type', 'bed_type', 'cancellation_policy']
base_airbnb_cod = pd.get_dummies(data=base_airbnb_cod, columns=colunas_categorias)
display(base_airbnb_cod.head())

host_is_superhost host_listings_count latitude longitude accommodates bathrooms bedrooms

1 1 2.0 -22.965919 -43.178962 5 1.0 2.0
1.0 1.0
3 0 3.0 -22.977117 -43.190454 3
28/33
localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false

10/02/2021 Gabarito - Solução Airbnb Rio

host_is_superhost host_listings_count latitude longitude accommodates bathrooms bedrooms

4 1 1.0 -22.983024 -43.214270 3 1.0 1.0

5 1 1.0 -22.988165 -43.193588 3 1.5 1.0

6 1 1.0 -22.981269 -43.190457 2 1.0 1.0

5 rows × 36 columns

Modelo de Previsão

Métricas de Avaliação

Vamos usar aqui o R² que vai nos dizer o quão bem o nosso modelo consegue explicar o preço. Isso
seria um ótimo parâmetro para ver o quão bom é nosso modelo
-> Quanto mais próximo de 100%, melhor

Vou calcular também o Erro Quadrático Médio, que vai mostrar para gente o quanto o nosso
modelo está errando.
-> Quanto menor for o erro, melhor

In [50]: def avaliar_modelo(nome_modelo, y_teste, previsao):
r2 = r2_score(y_teste, previsao)
RSME = np.sqrt(mean_squared_error(y_teste, previsao))
return f'Modelo {nome_modelo}:\nR²:{r2:.2%}\nRSME:{RSME:.2f}'

Escolha dos Modelos a Serem Testados
1. RandomForest
2. LinearRegression
3. Extra Tree

Esses são alguns dos modelos que existem para fazer previsão de valores numéricos (o que
chamamos de regressão). Estamos querendo calcular o preço, portanto, queremos prever um valor
numérico.

Assim, escolhemos esses 3 modelos. Existem dezenas, ou até centenas de modelos diferentes. A
medida com que você for aprendendo mais e mais sobre Ciência de Dados, você vai aprender
sempre novos modelos e entendendo aos poucos qual o melhor modelo para usar em cada
situação.

Mas na dúvida, esses 3 modelos que usamos aqui são bem bons para muitos problemas de
Regressão.

In [51]: modelo_rf = RandomForestRegressor()
modelo_lr = LinearRegression()
modelo_et = ExtraTreesRegressor()

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 29/33

10/02/2021 Gabarito - Solução Airbnb Rio

modelos = {'RandomForest': modelo_rf,
'LinearRegression': modelo_lr,
'ExtraTrees': modelo_et,
}

y = base_airbnb_cod['price']
X = base_airbnb_cod.drop('price', axis=1)

Separa os dados em treino e teste + Treino do Modelo

Essa etapa é crucial. As Inteligências Artificiais aprendendo com o que chamamos de treino.

Basicamente o que a gente faz é: a gente separa as informações em treino e teste, ex: 10% da base
de dados vai servir para teste e 90% para treino (normalmente treino é maior mesmo)

Aí, damos para o modelo os dados de treino, ele vai olhar aqueles dados e aprender a prever os
preços.

Depois que ele aprende, você faz um teste com ele, com os dados de teste, para ver se ela está bom
ou não. Analisando os dados de teste você descobre o melhor modelo

In [52]: X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=10)

for nome_modelo, modelo in modelos.items():
#treinar
modelo.fit(X_train, y_train)
#testar
previsao = modelo.predict(X_test)
print(avaliar_modelo(nome_modelo, y_test, previsao))

Modelo RandomForest:
R²:97.23%
RSME:44.10
Modelo LinearRegression:
R²:32.70%
RSME:217.54
Modelo ExtraTrees:
R²:97.51%
RSME:41.85

Análise do Melhor Modelo

In [53]: for nome_modelo, modelo in modelos.items():
#testar
previsao = modelo.predict(X_test)
print(avaliar_modelo(nome_modelo, y_test, previsao))

Modelo RandomForest:
R²:97.23%
RSME:44.10
Modelo LinearRegression:
R²:32.70%
RSME:217.54
Modelo ExtraTrees:
R²:97.51%
RSME:41.85

Modelo Escolhido como Melhor Modelo: ExtraTressRegressor 30/33

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false

10/02/2021 Gabarito - Solução Airbnb Rio

Esse foi o modelo com maior valor de R² e ao mesmo tempo o menor valor de RSME. Como
não tivemos uma grande diferença de velocidade de treino e de previsão desse modelo com o
modelo de RandomForest (que teve resultados próximos de R² e RSME), vamos escolher o
Modelo ExtraTrees.

O modelo de regressão linear não obteve um resultado satisfatório, com valores de R² e RSME
muito piores do que os outros 2 modelos.

Resultados das Métricas de Avaliaçõ no Modelo Vencedor:
Modelo ExtraTrees:
R²:97.49%
RSME:41.99

Ajustes e Melhorias no Melhor Modelo

In [54]: #print(modelo_et.feature_importances_)
#print(X_train.columns)
importancia_features = pd.DataFrame(modelo_et.feature_importances_, X_train.columns)
importancia_features = importancia_features.sort_values(by=0, ascending=False)
display(importancia_features)
plt.figure(figsize=(15, 5))
ax = sns.barplot(x=importancia_features.index, y=importancia_features[0])
ax.tick_params(axis='x', rotation=90)

0
bedrooms 0.115197

latitude 0.103485
longitude 0.101353
n_amenities 0.089108
extra_people 0.087071
accommodates 0.070214
bathrooms 0.070116
room_type_Entire home/apt 0.066769
minimum_nights 0.064810

beds 0.053086
host_listings_count 0.039851

instant_bookable 0.021885
cancellation_policy_flexible 0.019602

host_is_superhost 0.013770
property_type_Apartment 0.012592
cancellation_policy_moderate 0.012311

ano 0.011353

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 31/33

10/02/2021 Gabarito - Solução Airbnb Rio
0

cancellation_policy_strict_14_with_grace_period 0.007938
property_type_House 0.006895

property_type_Condominium 0.005172
mes 0.004681

room_type_Private room 0.003998
bed_type_Real Bed 0.002770
bed_type_Outros 0.002663

property_type_Outros 0.002377
property_type_Serviced apartment 0.002266

property_type_Loft 0.002105
room_type_Shared room 0.001887
property_type_Bed and breakfast 0.001299
property_type_Guesthouse 0.000930
cancellation_policy_strict 0.000847
property_type_Guest suite 0.000668

property_type_Hostel 0.000629
room_type_Hotel room 0.000300
is_business_travel_ready 0.000000

Ajustes Finais no Modelo 32/33

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false

10/02/2021 Gabarito - Solução Airbnb Rio

is_business_travel ready não parece ter muito impacto no nosso modelo. Por isso, para chegar
em um modelo mais simples, vamos excluir essa feature e testar o modelo sem ela.

In [55]: base_airbnb_cod = base_airbnb_cod.drop('is_business_travel_ready', axis=1)

y = base_airbnb_cod['price']
X = base_airbnb_cod.drop('price', axis=1)

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=10)

modelo_et.fit(X_train, y_train)
previsao = modelo_et.predict(X_test)
print(avaliar_modelo('ExtraTrees', y_test, previsao))

Modelo ExtraTrees:
R²:97.51%
RSME:41.84

In [56]: base_teste = base_airbnb_cod.copy()
for coluna in base_teste:

if 'bed_type' in coluna:
base_teste = base_teste.drop(coluna, axis=1)

print(base_teste.columns)
y = base_teste['price']
X = base_teste.drop('price', axis=1)

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=10)

modelo_et.fit(X_train, y_train)
previsao = modelo_et.predict(X_test)
print(avaliar_modelo('ExtraTrees', y_test, previsao))

Index(['host_is_superhost', 'host_listings_count', 'latitude', 'longitude',
'accommodates', 'bathrooms', 'bedrooms', 'beds', 'price',
'extra_people', 'minimum_nights', 'instant_bookable', 'ano', 'mes',
'n_amenities', 'property_type_Apartment',
'property_type_Bed and breakfast', 'property_type_Condominium',
'property_type_Guest suite', 'property_type_Guesthouse',
'property_type_Hostel', 'property_type_House', 'property_type_Loft',
'property_type_Outros', 'property_type_Serviced apartment',
'room_type_Entire home/apt', 'room_type_Hotel room',
'room_type_Private room', 'room_type_Shared room',
'cancellation_policy_flexible', 'cancellation_policy_moderate',
'cancellation_policy_strict',
'cancellation_policy_strict_14_with_grace_period'],

dtype='object')
Modelo ExtraTrees:
R²:97.48%
RSME:42.06

In [57]: print(previsao)
[100.99 998.54 249.2 ... 123.12 256.17 119.83]

In [ ]:

localhost:8888/nbconvert/html/Desktop/Intensivão de Python/Aula 3/Gabarito - Solução Airbnb Rio.ipynb?download=false 33/33