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 ETAPAS DE UM PROJETO
Python
1. Entendimento do Desafio 3. Extração/Obtenção de Dados 6. Modelagem + Algoritmos
2. Entendimento da 4. Ajustes de Dados (Limpeza de

7. Interpretação do resultado
Empresa/Área Dados)
5. Análise 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

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]

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
Living in a
0 14063 https://www.airbnb.com/rooms/14063 20180414160018 2018-04-14
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
Modern
Decorated
Studio in Copa
NICE & COZY

1BDR -
IPANEMA
BEACH
... ... ... ... ... ...
TRANSAMERICA
34324 38844730 https://www.airbnb.com/rooms/38844730 20190923212307 2019-09-24 BARRA DA
TIJUCA R IV
Alugo para o
Rock in Rio
Apt COMPLETO
em
34326 38846703 https://www.airbnb.com/rooms/38846703 20190923212307 2019-09-24 COPACABANA
c/TOTAL
SEGURANÇA

id listing_url scrape_id last_scraped name
Cobertura
Cinematografica
Quarto em
34328 38847655 https://www.airbnb.com/rooms/38847655 20190923212307 2019-09-24 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',

'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
Tratar Valores Faltando

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 0
longitude 0
property_type 0
room_type 0
accommodates 0
bathrooms 1724
bedrooms 850
beds 2502
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 0
mes 0
dtype: int64
In [8]: base_airbnb = base_airbnb.dropna()
print(base_airbnb.shape)
print(base_airbnb.isnull().sum())
(897709, 23)
host_is_superhost 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 0
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
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

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 object
room_type object
accommodates int64
bathrooms float64
bedrooms float64
beds float64
bed_type object
amenities object
price float32
guests_included int64
extra_people float32
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
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.

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

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):
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)

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'])
(810427, 23)
extra_people
In [17]: diagrama_caixa(base_airbnb['extra_people'])
histograma(base_airbnb['extra_people'])

In [18]: base_airbnb, linhas_removidas = excluir_outliers(base_airbnb, 'extra_people')

In [19]: histograma(base_airbnb['extra_people'])
(751233, 23)
host_listings_count
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')

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

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')

bathrooms
In [24]: diagrama_caixa(base_airbnb['bathrooms'])
sns.barplot(x=base_airbnb['bathrooms'].value_counts().index, y=base_airbnb['bathrooms']
Out[24]: <AxesSubplot:ylabel='bathrooms'>

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

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

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

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
In [29]: base_airbnb, linhas_removidas = excluir_outliers(base_airbnb, 'beds')

guests_included
In [30]: #diagrama_caixa(base_airbnb['guests_included'])
#grafico_barra(base_airbnb['guests_included'])
print(limites(base_airbnb['guests_included']))
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'])

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')

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

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'])

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())
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
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

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())
grafico = sns.countplot('property_type', data=base_airbnb)
['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
warnings.warn(
- room_type
In [40]: print(base_airbnb['room_type'].value_counts())
grafico = sns.countplot('room_type', data=base_airbnb)

Entire home/apt 372443

Private room 196859
Shared room 11714
Hotel room 967
Name: room_type, dtype: int64
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())
grafico = sns.countplot('bed_type', data=base_airbnb)
# agrupando categorias de bed_type

tabela_bed = base_airbnb['bed_type'].value_counts()
for tipo in tabela_bed.index:

if tabela_bed[tipo] < 10000:

base_airbnb.loc[base_airbnb['bed_type']==tipo, 'bed_type'] = 'Outros'
print(base_airbnb['bed_type'].value_counts())
grafico = sns.countplot('bed_type', data=base_airbnb)
Real Bed 570643

Pull-out Sofa 8055
Futon 1634

Airbed 1155
Couch 496
Name: bed_type, dtype: int64
warnings.warn(
['Pull-out Sofa', 'Futon', 'Airbed', 'Couch']
Real Bed 570643
Outros 11340
Name: bed_type, dtype: int64
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

In [42]: print(base_airbnb['cancellation_policy'].value_counts())
grafico = sns.countplot('cancellation_policy', data=base_airbnb)
# agrupando categorias de cancellation_pollicy

tabela_cancellation = base_airbnb['cancellation_policy'].value_counts()
for tipo in tabela_cancellation.index:

if tabela_cancellation[tipo] < 10000:

base_airbnb.loc[base_airbnb['cancellation_policy']==tipo, 'cancellation_policy'] =
print(base_airbnb['cancellation_policy'].value_counts())
grafico = sns.countplot('cancellation_policy', data=base_airbnb)
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
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
warnings.warn(

- 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

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')

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()

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
3 0 3.0 -22.977117 -43.190454 3 1.0 1.0

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
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()

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

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)
ax = sns.barplot(x=importancia_features.index, y=importancia_features[0])
ax.tick_params(axis='x', rotation=90)
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

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

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 [ ]:

Apostila Aula 3 - Intensivão de Python

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila Aula 3 - Intensivão de Python

Enviado por

Direitos autorais:

Formatos disponíveis

10/02/2021 Ciência de Dados

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

Onde podemos aplicar Ciência de Dados

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

1. Entendimento do Desafio que você quer resolver

Onde o Python entra no meio disso tudo?

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

1. Entendimento do Desafio 3. Extração/Obtenção de Dados 6. Modelagem + Algoritmos

2. Entendimento da 4. Ajustes de Dados (Limpeza de

5. Análise Exploratória 8. Deploy/Produção

Projeto Airbnb Rio - Ferramenta de Previsão

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

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

Os preços são dados em reais (R$)

Importar Bibliotecas e Bases de Dados

In [2]: import pandas as pd

Agora vamos importar as bases de dados

for arquivo in caminho_bases.iterdir():

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

df = pd.read_csv(caminho_bases / arquivo.name, low_memory=False)

id listing_url scrape_id last_scraped name

Very Nice 2Br -

Nice and cozy

NICE & COZY

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

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

id listing_url scrape_id last_scraped name

902210 rows × 108 columns

Agora vamos começar os tratamentos

1. IDs, Links e informações não relevantes para o modelo

['id', 'listing_url', 'scrape_id', 'last_scraped', 'name', 'summary', 'space', 'descript

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

Depois da análise qualitativa das colunas, levando em conta os

base_airbnb = base_airbnb.loc[:, colunas]

['host_response_time', 'host_response_rate', 'host_is_superhost', 'host_listings_count',

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

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

In [7]: for coluna in base_airbnb:

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

Verificar Tipos de Dados em cada coluna

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

Análise Exploratória e Tratar Outliers

Depois vamos analisar as colunas de valores numéricos discretos (accomodates, bedrooms,

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

In [11]: plt.figure(figsize=(15, 10))

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

In [12]: def limites(coluna):

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

def excluir_outliers(df, nome_coluna):

In [13]: def diagrama_caixa(coluna):

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

In [15]: base_airbnb, linhas_removidas = excluir_outliers(base_airbnb, 'price')