library(tidyverse)
library(janitor)
library(tidymodels)
library(embed)
distancia_centro <- function(lat, lon, lat0 = -23.5505, lon0 = -46.6333) {
# aproximação plana, suficiente para a escala da cidade (em km)
sqrt(((lat - lat0) * 111)^2 + ((lon - lon0) * 111 * cos(lat0 * pi / 180))^2)
}
brl <- function(x) paste0("R$ ", formatC(x, format = "f", digits = 0,
big.mark = ".", decimal.mark = ","))
dados_aluguel <- read_csv("data/sao-paulo-properties-april-2019.csv") |>
clean_names() |>
filter(negotiation_type == "rent",
longitude <= -46.36531, longitude >= -46.82619,
latitude <= -23.35629, latitude >= -24.00826) |>
mutate(distrito = factor(str_squish(str_remove(district, "/.*$"))),
dist_centro_km = distancia_centro(latitude, longitude),
condo_m2 = condo / pmax(size, 1),
preco_log = log(price)) |>
select(-negotiation_type, -property_type, -district)4 Um modelo otimizado para sugerir o aluguel
No capítulo anterior, a floresta aleatória usou apenas latitude e longitude para representar a localização, parâmetros padrão e o preço na escala original. Este anexo implementa os “próximos passos” daquele capítulo para chegar a um modelo mais próximo do que seria usado em produção:
- Distrito como variável, agrupando os distritos pequenos e codificando cada um pelo seu nível de preço.
- Logaritmo do preço como variável resposta, o que reduz o peso dos imóveis muito caros.
- Ajuste de hiperparâmetros com validação cruzada, comparando floresta aleatória e XGBoost.
- Uma função que sugere o aluguel de um novo imóvel, com uma faixa de valores.
Este anexo usa o pacote tidymodels, mais adequado a esse tipo de fluxo. O ajuste dos modelos pode levar alguns minutos.
4.1 Dados e variáveis
Repetimos a limpeza do capítulo (apenas aluguel, coordenadas dentro do município) e mantemos o distrito. Criamos duas variáveis novas que não dependem do preço: a distância ao centro (Praça da Sé) e o condomínio por m², um indicador do padrão do prédio.
4.2 Divisão dos dados e validação cruzada
Usamos a mesma semente e a mesma estratificação do capítulo, de modo que o conjunto de teste deve ser o mesmo e os erros sejam comparáveis. O conjunto de treinamento é dividido em 5 partes (folds) para a validação cruzada, que substitui o conjunto de validação do capítulo.
set.seed(123)
split <- initial_split(dados_aluguel, prop = 0.8, strata = price)
treino <- training(split) |> select(-price) # price não pode ser preditora
teste <- testing(split) # mantém price para avaliar em reais
cv <- vfold_cv(treino, v = 5, strata = preco_log)4.3 Pré-processamento
A receita abaixo trata o distrito em duas etapas: distritos com menos de 1% dos imóveis são agrupados em “outros”, e cada distrito restante é substituído pelo logaritmo médio do preço observado nele (codificação por alvo). Isso permite capturar a desigualdade entre bairros vizinhos, sem criar dezenas de colunas. Como a receita é reestimada dentro de cada fold, o preço do imóvel avaliado não vaza para a própria codificação.
receita <- recipe(preco_log ~ ., data = treino) |>
step_other(distrito, threshold = 0.01, other = "outros") |>
step_lencode_glm(distrito, outcome = vars(preco_log)) |>
step_zv(all_predictors())4.4 Modelos e ajuste de hiperparâmetros
Comparamos duas famílias de modelos, cada uma com 20 combinações de hiperparâmetros sorteadas de forma espaço-preenchedora. O critério é o RMSE do log do preço na validação cruzada.
rf_spec <- rand_forest(mtry = tune(), min_n = tune(), trees = 500) |>
set_engine("ranger") |>
set_mode("regression")
xgb_spec <- boost_tree(tree_depth = tune(), learn_rate = tune(),
min_n = tune(), trees = 500) |>
set_engine("xgboost") |>
set_mode("regression")
# faixa mais realista para a taxa de aprendizado e a profundidade
xgb_params <- extract_parameter_set_dials(xgb_spec) |>
update(learn_rate = learn_rate(range = c(-2.5, -0.5)),
tree_depth = tree_depth(range = c(3L, 10L)))
set.seed(123)
resultados <- workflow_set(preproc = list(receita = receita),
models = list(rf = rf_spec, xgb = xgb_spec)) |>
option_add(param_info = xgb_params, id = "receita_xgb") |>
workflow_map("tune_grid", resamples = cv, grid = 20,
metrics = metric_set(rmse), seed = 123, verbose = FALSE)
rank_results(resultados, select_best = TRUE) |>
select(wflow_id, rmse = mean, erro_padrao = std_err, rank) |>
knitr::kable(digits = 4)| wflow_id | rmse | erro_padrao | rank |
|---|---|---|---|
| receita_xgb | 0.2532 | 0.0026 | 1 |
| receita_rf | 0.2560 | 0.0026 | 2 |
melhor_id <- rank_results(resultados, select_best = TRUE) |>
slice(1) |>
pull(wflow_id)
modelo_vencedor <- if_else(str_detect(melhor_id, "xgb"),
"XGBoost", "floresta aleatória (ranger)")
melhores_params <- resultados |>
extract_workflow_set_result(melhor_id) |>
select_best(metric = "rmse")
wf_final <- resultados |>
extract_workflow(melhor_id) |>
finalize_workflow(melhores_params)
melhores_params# A tibble: 1 × 4
min_n tree_depth learn_rate .config
<int> <int> <dbl> <chr>
1 32 10 0.0280 pre0_mod16_post0
O melhor modelo na validação cruzada foi o XGBoost, com os hiperparâmetros acima.
4.5 Avaliação no conjunto de teste
Ajustamos o modelo vencedor em todo o conjunto de treinamento e avaliamos no teste, voltando para a escala em reais. Para comparar, ajustamos também uma versão simplificada da floresta do capítulo (sem distrito, sem ajuste de hiperparâmetros, preço na escala original).
library(randomForest)
ajuste_final <- fit(wf_final, data = treino)
resultado_teste <- teste |>
mutate(previsto = exp(predict(ajuste_final, teste)$.pred))
# referência: floresta do capítulo (versão simplificada)
cols_cap <- c("price", "condo", "size", "rooms", "toilets", "suites", "parking",
"elevator", "furnished", "swimming_pool", "new",
"latitude", "longitude")
set.seed(123)
rf_cap <- randomForest(price ~ ., data = training(split) |> select(all_of(cols_cap)))
pred_cap <- predict(rf_cap, teste)
metricas_reais <- function(obs, pred) {
tibble(REQM = sqrt(mean((obs - pred)^2)),
MAE = mean(abs(obs - pred)),
`Erro % mediano` = 100 * median(abs(obs - pred) / obs))
}
comparacao <- bind_rows(
"Capítulo anterior (floresta, sem distrito)" = metricas_reais(teste$price, pred_cap),
"Modelo otimizado" = metricas_reais(resultado_teste$price,
resultado_teste$previsto),
.id = "Modelo"
)
knitr::kable(comparacao, digits = 1)| Modelo | REQM | MAE | Erro % mediano |
|---|---|---|---|
| Capítulo anterior (floresta, sem distrito) | 1445.4 | 695.9 | 14.7 |
| Modelo otimizado | 1355.1 | 621.8 | 13.2 |
O erro absoluto médio (MAE) passou de R$ 696 para R$ 622, e o erro percentual mediano, de 14.7% para 13.2%. O erro percentual mediano é uma medida direta para o negócio: em metade dos imóveis, a sugestão erra menos do que esse percentual do aluguel real.
4.6 Sugerindo o aluguel de um novo imóvel
Para o uso em produção, o modelo é reajustado com todos os dados. Além do valor sugerido, é útil informar uma faixa: usamos a razão entre o aluguel observado e o previsto nas previsões da validação cruzada (cada imóvel previsto por um modelo que não o viu) e tomamos os percentis 10 e 90.
modelo_producao <- fit(wf_final, data = dados_aluguel |> select(-price))
oof <- fit_resamples(wf_final, resamples = cv,
control = control_resamples(save_pred = TRUE)) |>
collect_predictions()
faixa <- quantile(exp(oof$preco_log - oof$.pred), probs = c(0.10, 0.90))
sugerir_aluguel <- function(novo) {
novo <- novo |>
mutate(distrito = factor(distrito, levels = levels(dados_aluguel$distrito)),
dist_centro_km = distancia_centro(latitude, longitude),
condo_m2 = condo / pmax(size, 1))
p <- exp(predict(modelo_producao, novo)$.pred)
tibble(sugerido = p, minimo = p * faixa[[1]], maximo = p * faixa[[2]])
}Exemplo de uso (o nome do distrito deve existir na base):
novo_imovel <- tibble(distrito = "Pinheiros", size = 65, condo = 700,
rooms = 2, toilets = 2, suites = 1, parking = 1,
elevator = 1, furnished = 0, swimming_pool = 0, new = 0,
latitude = -23.567, longitude = -46.693)
sugerir_aluguel(novo_imovel) |>
mutate(across(everything(), brl)) |>
knitr::kable()| sugerido | minimo | maximo |
|---|---|---|
| R$ 3.619 | R$ 2.717 | R$ 4.881 |
A faixa indica que, em 80% dos imóveis da validação cruzada, o aluguel anunciado ficou entre 0.75 e 1.35 vezes o valor previsto.
4.7 Cuidados
- Os dados são de abril de 2019 e de preços anunciados. Para uso real, é preciso treinar com dados atuais e monitorar o erro ao longo do tempo.
- A faixa é empírica e pressupõe que o novo imóvel se pareça com os da base. Para imóveis atípicos (muito grandes, de altíssimo padrão), o erro tende a ser maior.
- A sugestão deve apoiar a decisão de quem define o preço, e não substituí-la.