Prova 2 - Aprendizagem de Máquina

Questão 1) Crie um problema de regressão simulado em que a variável target (variável resposta) depende de 5 variáveis preditoras, porém, a base de dados, com 5 mil observações possui outras 15 features que não são relevantes para a predição. A variável target deve ser gerada a partir de uma função linear das variáveis preditoras, em que você poderá definir os pesos dessas 5 primeiras e as outras 15 restantes deverão ter peso zero. Ajuste a regressão Lasso e Ridge usando 10-fold cross-validation e avalie o risco preditivo dos modelos. Quais os valores estimados dos coeficientes e qual modelo você escolheria para fazer previsões? Qual dos modelos gerou um vetor esparso dos coeficientes estimados?

set.seed(0)
library(tidymodels)

## ── Attaching packages ────────────────────────────────────── tidymodels 1.2.0 ──

## ✔ broom        1.0.6     ✔ recipes      1.1.0
## ✔ dials        1.3.0     ✔ rsample      1.2.1
## ✔ dplyr        1.1.4     ✔ tibble       3.2.1
## ✔ ggplot2      3.5.1     ✔ tidyr        1.3.1
## ✔ infer        1.0.7     ✔ tune         1.2.1
## ✔ modeldata    1.4.0     ✔ workflows    1.1.4
## ✔ parsnip      1.2.1     ✔ workflowsets 1.1.0
## ✔ purrr        1.0.2     ✔ yardstick    1.3.1

## ── Conflicts ───────────────────────────────────────── tidymodels_conflicts() ──
## ✖ purrr::discard() masks scales::discard()
## ✖ dplyr::filter()  masks stats::filter()
## ✖ dplyr::lag()     masks stats::lag()
## ✖ recipes::step()  masks stats::step()
## • Use suppressPackageStartupMessages() to eliminate package startup messages

library(glmnet)

## Carregando pacotes exigidos: Matrix

## 
## Anexando pacote: 'Matrix'

## Os seguintes objetos são mascarados por 'package:tidyr':
## 
##     expand, pack, unpack

## Loaded glmnet 4.1-8

tidymodels_prefer()

# Gerando os dados com 5000 observações
gerando_dados <- function(n = 5000) {
  x <- matrix(rnorm(n * 20), ncol = 20)  
  colnames(x) <- paste0("x", 1:20)
  
# Gerando a variável target 
  y <- 3 * x[, 1] - 2 * x[, 2] + 1.5 * x[, 3] - 2.5 * x[, 4] + 1 * x[, 5] + rnorm(n, 0, 1)
  
# Retornando como um data frame
  data <- as.data.frame(cbind(y, x))
  return(data)
}

# Gerando a base de dados simulada
dados <- gerando_dados()

# Realizando o data spliting
dados_split <- initial_split(dados, prop = 0.8)
treino <- training(dados_split)
teste <- testing(dados_split)

# Criando validacao com 10-fold
cv <- vfold_cv(treino, v = 10)

# Modelo Lasso 
modelo_lasso <- 
  linear_reg(penalty = tune(), mixture = 1) |>
  set_engine("glmnet") |>
  set_mode("regression")
# Modelo Ridge
modelo_ridge <- 
  linear_reg(penalty = tune(), mixture = 0) |>
  set_engine("glmnet") |>
  set_mode("regression")

# Criando a Receita
receita <- recipe(y ~ ., data = treino) |>
  step_normalize(all_predictors())

# Workflow Lasso
wf_lasso <- workflow() |>
  add_recipe(receita) |>
  add_model(modelo_lasso)

# Workflow Ridge
wf_ridge <- workflow() |>
  add_recipe(receita) |>
  add_model(modelo_ridge)

# Tunando os modelos
grid <- grid_regular(penalty(), levels = 30)

# Tunando Lasso
tunagem_lasso <- tune_grid(wf_lasso, resamples = cv, grid = grid)
melhor_lasso <- select_best(tunagem_lasso, metric = "rmse")

# Tunando Ridge
tunagem_ridge <- tune_grid(wf_ridge, resamples = cv, grid = grid)
melhor_ridge <- select_best(tunagem_ridge, metric = "rmse")

# Ajustando os modelos finais
wf_lasso_final <- finalize_workflow(wf_lasso, melhor_lasso)
wf_ridge_final <- finalize_workflow(wf_ridge, melhor_ridge)

ajuste_lasso <- last_fit(wf_lasso_final, dados_split)
ajuste_ridge <- last_fit(wf_ridge_final, dados_split)

# Coletando métricas
collect_metrics(ajuste_lasso)

## # A tibble: 2 × 4
##   .metric .estimator .estimate .config             
##   <chr>   <chr>          <dbl> <chr>               
## 1 rmse    standard       0.957 Preprocessor1_Model1
## 2 rsq     standard       0.962 Preprocessor1_Model1

collect_metrics(ajuste_ridge)

## # A tibble: 2 × 4
##   .metric .estimator .estimate .config             
##   <chr>   <chr>          <dbl> <chr>               
## 1 rmse    standard       1.00  Preprocessor1_Model1
## 2 rsq     standard       0.961 Preprocessor1_Model1

# Extraindo os coeficientes
modelo_lasso_final <- extract_fit_parsnip(ajuste_lasso)
modelo_ridge_final <- extract_fit_parsnip(ajuste_ridge)

coeficientes_lasso <- broom::tidy(modelo_lasso_final)
coeficientes_ridge <- broom::tidy(modelo_ridge_final)

# Visualizando os coeficientes
coeficientes_lasso

## # A tibble: 21 × 3
##    term        estimate      penalty
##    <chr>          <dbl>        <dbl>
##  1 (Intercept)   0.0429 0.0000000001
##  2 x1            2.99   0.0000000001
##  3 x2           -1.95   0.0000000001
##  4 x3            1.50   0.0000000001
##  5 x4           -2.46   0.0000000001
##  6 x5            1.00   0.0000000001
##  7 x6            0      0.0000000001
##  8 x7            0      0.0000000001
##  9 x8            0.0125 0.0000000001
## 10 x9            0      0.0000000001
## # ℹ 11 more rows

coeficientes_ridge

## # A tibble: 21 × 3
##    term        estimate      penalty
##    <chr>          <dbl>        <dbl>
##  1 (Intercept)  0.0429  0.0000000001
##  2 x1           2.82    0.0000000001
##  3 x2          -1.84    0.0000000001
##  4 x3           1.42    0.0000000001
##  5 x4          -2.32    0.0000000001
##  6 x5           0.954   0.0000000001
##  7 x6           0.00426 0.0000000001
##  8 x7           0.0116  0.0000000001
##  9 x8           0.0165  0.0000000001
## 10 x9          -0.00205 0.0000000001
## # ℹ 11 more rows

Conclusão 1: Com base nos resultados o melhor modelo seria o Lasso, ele gerou um vetor esparso de coeficientes estimados e seu rmse de 0.9901 tendo assim um menor erro comparado com o rmse da ridge que foi de 1.0272.

Questão 2) Considere o melhor modelo da questão anterior, e compare-o com a regressão Elastic Net. Faça uma comparação justa dos modelos, utilizando workflow_set e workflow_map. Avalie o risco preditivo dos modelos e compare os coeficientes estimados. Qual dos modelos você escolheria para fazer previsões? Explique!

set.seed(0)

library(tidyverse)

## ── Attaching core tidyverse packages ──────────────────────── tidyverse 2.0.0 ──
## ✔ forcats   1.0.0     ✔ readr     2.1.5
## ✔ lubridate 1.9.3     ✔ stringr   1.5.1
## ── Conflicts ────────────────────────────────────────── tidyverse_conflicts() ──
## ✖ readr::col_factor() masks scales::col_factor()
## ✖ purrr::discard()    masks scales::discard()
## ✖ Matrix::expand()    masks tidyr::expand()
## ✖ dplyr::filter()     masks stats::filter()
## ✖ stringr::fixed()    masks recipes::fixed()
## ✖ dplyr::lag()        masks stats::lag()
## ✖ Matrix::pack()      masks tidyr::pack()
## ✖ readr::spec()       masks yardstick::spec()
## ✖ Matrix::unpack()    masks tidyr::unpack()
## ℹ Use the conflicted package (<http://conflicted.r-lib.org/>) to force all conflicts to become errors

library(tidymodels)
library(tibble)
library(purrr)
library(ggplot2)
library(patchwork)
library(workflowsets)
library(yardstick)
library(glmnet)

# Modelo Lasso 
modelo_lasso <- 
  linear_reg(penalty = tune(), mixture = 1) |>
  set_engine("glmnet") |>
  set_mode("regression")

# Modelo Elastic
modelo_elastic <- 
  linear_reg(penalty = tune(), mixture = tune()) |> 
  set_engine("glmnet") |> 
  set_mode("regression")

# Criando o workflows
wf <-
    workflow_set(
    preproc = list(y ~ .),
    models = list(lasso = modelo_lasso, elastic = modelo_elastic), 
    cross = TRUE
  )

# Criando validacao cruzada
cv <- vfold_cv(treino, v = 10)

# Tunando o modelo
tunagem <- 
  wf |> 
  workflow_map(
    seed = 0, 
    verbose = TRUE,
    resamples = cv,
    grid = 50,
    metrics = metric_set(rmse)
  )

## i 1 of 2 tuning:     formula_lasso
## ✔ 1 of 2 tuning:     formula_lasso (690ms)
## i 2 of 2 tuning:     formula_elastic
## ✔ 2 of 2 tuning:     formula_elastic (14.3s)

# Selecionando os melhores modelos 
melhor_lasso <- 
  tunagem |> 
  extract_workflow_set_result("formula_lasso") |> 
  select_best(metric ="rmse")

melhor_elastic <- 
  tunagem |>
  extract_workflow_set_result("formula_elastic") |>
  select_best(metric = "rmse")

# Finalizando os modelos 
finalizando_lasso <- 
  tunagem |>
  extract_workflow("formula_lasso") |>
  finalize_workflow(melhor_lasso) |>
  last_fit(split = dados_split)

finalizando_elastic <- 
  tunagem |>
  extract_workflow("formula_elastic") |>
  finalize_workflow(melhor_elastic) |>
  last_fit(split = dados_split)

# Visualizando as métricas do modelo Lasso
finalizando_lasso |> collect_metrics()

## # A tibble: 2 × 4
##   .metric .estimator .estimate .config             
##   <chr>   <chr>          <dbl> <chr>               
## 1 rmse    standard       0.957 Preprocessor1_Model1
## 2 rsq     standard       0.962 Preprocessor1_Model1

# Visualizando as métricas do modelo Elastic Net
finalizando_elastic |> collect_metrics()

## # A tibble: 2 × 4
##   .metric .estimator .estimate .config             
##   <chr>   <chr>          <dbl> <chr>               
## 1 rmse    standard       0.957 Preprocessor1_Model1
## 2 rsq     standard       0.962 Preprocessor1_Model1

Conclusão 2: Baseando-se nas métricas fornecidas, o Lasso e o Elastic Net apresentam desempenhos preditivos bem semelhantes, com valores de RMSE e $R^2$ muito semelhantes. Dada essa equivalência no desempenho, a escolha entre os dois modelos pode ser orientada por outros fatores como a simplicidade na interpretação e na complexidade do modelo, sendo assim, o modelo Lasso é o mais adequado.

Questão 3) Utilize o método K - Nearest Neighbors para prever o preço médio (variável MEDV) de uma casa em diferentes áreas da cidade de Boston com base em várias características socioeconômicas e geográficas. Faça uma descritiva dos dados e realize a fase de preprocessamento dos dados.

Você deverá:

Explorar as variáveis, identificando as variáveis que possuem um comportamento assimétrico;
Pré-processar os dados e incluir o preprocessamento no pipeline. No preprocessamento, você deverá:

Realizar a transformação de Yeo-Johnson nas variáveis que possuem um comportamento assimétrico. No pacote recipes, utilize step_YeoJohnson;
Incluir no preprocessamento a eliminação de variáveis talmamente correlacionadas;
Incluir no preprocessamento a eliminação de covariáveis com zero variância.

Estimar o risco preditivo do modelo. Houve boas previsões? Explique!
Você deverá estratificar os dados em 80% para treino e 20% para teste, com base na variável target.
Utilize na validação cruzada 10-fold cross-validation.

Informações do Banco de Dados

CRIM: taxa de criminalidade per capita por cidade
ZN: proporção de terrenos residenciais zoneados para lotes acima de 25.000 pés quadrados.
INDUS: proporção de acres de negócios não varejistas por cidade
CHAS: variável fictícia do rio Charles (1 se o trato delimita o rio; 0 caso contrário)
NOX: concentração de óxidos nítricos (partes por 10 milhões) [partes / 10M]
RM: número médio de quartos por habitação
IDADE: proporção de unidades ocupadas pelo proprietário construídas antes de 1940
DIS: distâncias ponderadas para cinco centros de emprego de Boston 9) RAD: índice de acessibilidade a rodovias radiais 10) IMPOSTO: taxa de imposto predial de valor total por $ 10.000 [$ / 10k]
PTRATIO: proporção aluno-professor por cidade
B: O resultado da equação B = 1000 (Bk - 0,63) ^ 2 onde Bk é a proporção de negros por cidade
LSTAT: % menor status da população

Variável de saída: 1) MEDV: Valor médio das casas ocupadas pelo proprietário em $ 1000 [k $]

library(tidymodels)
library(ggplot2)
library(dplyr)
library(recipes)
library(kknn)

# Carregando os dados
dados <- read.csv("C:/Users/gleyc/Downloads/boston_questao3.csv")

# Visualizaçao das variáveis
dados %>%
  pivot_longer(cols = everything(), names_to = "variable", values_to = "value") %>%
  ggplot(aes(x = value)) +
  facet_wrap(~ variable, scales = "free") +
  geom_histogram(bins = 30) +
  theme_minimal() +
  labs(title = "Distribuição das Variáveis")

# Criar receita
receita <- recipe(MEDV ~ ., data = dados) %>%
  step_YeoJohnson(all_numeric_predictors()) %>%  
  step_corr(all_predictors(), threshold = 0.85) %>%  
  step_zv(all_predictors())  

# Fazendo o hold-out
set.seed(123)
dados_split <- initial_split(dados, prop = 0.8, strata = "MEDV")
treino <- training(dados_split)
teste <- testing(dados_split)

# Preparar e aplicar a receita
receita_prep <- prep(receita, training = treino)
treino_prep <- bake(receita_prep, treino)
teste_prep <- bake(receita_prep, teste)

# Criaçao da validação cruzada
cv <- vfold_cv(treino_prep, v = 10)

# Definir o modelo KNN
modelo_knn <- nearest_neighbor(neighbors = tune(), weight_func = "rectangular") %>%
  set_engine("kknn") %>%
  set_mode("regression")

# Criar workflow
wf_knn <- workflow() %>%
  add_model(modelo_knn) %>%
  add_recipe(receita)

# Definir o grid para o tuning
grid_knn <- tibble(
  neighbors = c(5, 10, 15, 20)
)

# Rodar tuning com validação cruzada
tunagem_knn <- tune_grid(
  wf_knn,
  resamples = cv,
  grid = grid_knn,
  control = control_grid(save_pred = TRUE)
)

## → A | error:   Not all variables in the recipe are present in the supplied training
##                set: `NOX`.

## There were issues with some computations   A: x1There were issues with some computations   A: x2There were issues with some computations   A: x4There were issues with some computations   A: x6There were issues with some computations   A: x8There were issues with some computations   A: x10There were issues with some computations   A: x10

## Warning: All models failed. Run `show_notes(.Last.tune.result)` for more
## information.

Questão 4) Com base na questão 1, escolha entre as 5 features preditoras que foram úteis para gerar y, duas para introduzir 10% de missing values em cada uma dessas duas variáveis. A introdução das observações faltantes deverá ser aleatória. Após, isso, realize a comparação do método Elastic-Net com o método K - Nearest Neighbors - KNN. Compare o risco preditivo de cada um do modelos. Na fase de pré-processamento, você deverá utilizar também o método KNN, considerando k=5 para imputar os dados faltantes. Qual o modelo que forneceu um melhor risco preditivo? Explique!

set.seed(0)
library(tidymodels)
library(glmnet)
library(recipes)
library(tune)
library(parsnip)

tidymodels_prefer()

# Gerando os dados com 5000 observações
gerando_dados <- function(n = 5000) {
  x <- matrix(rnorm(n * 20), ncol = 20)  
  colnames(x) <- paste0("x", 1:20)
  
# Gerando a variável target 
  y <- 3 * x[, 1] - 2 * x[, 2] + 1.5 * x[, 3] - 2.5 * x[, 4] + 1 * x[, 5] + rnorm(n, 0, 1)
  
# Retornando como um data frame
  data <- as.data.frame(cbind(y, x))
  return(data)
}

# Gerando a base de dados simulada
dados <- gerando_dados()

# Introduçao de valores faltantes aleatórios
introduzir_faltantes <- function(dados, variaveis, proporcao = 0.1) {
  dados_mod <- dados %>%
    mutate(across(all_of(variaveis), ~ ifelse(runif(n()) < proporcao, NA, .)))
  return(dados_mod)
}

# Escolhendo duas variáveis para introduzir valores faltantes
variaveis_utiles <- c("x1", "x2", "x3", "x4", "x5")  
variaveis_faltantes <- sample(variaveis_utiles, 2)

# Introduzir 10% de valores faltantes
dados_com_faltantes <- introduzir_faltantes(dados, variaveis_faltantes)

# Criando o recipe para pré-processamento
receita <- recipe(y ~ ., data = dados_com_faltantes) %>%
  step_impute_knn(all_predictors(), neighbors = 5) %>%
  step_normalize(all_predictors())

# Modelo Elastic-Net
modelo_elastic_net <- linear_reg(penalty = tune(), mixture = tune()) %>%
  set_engine("glmnet") %>%
  set_mode("regression")

# Modelo KNN
modelo_knn <- nearest_neighbor(neighbors = tune()) %>%
  set_engine("kknn") %>%
  set_mode("regression")

# Criar workflows
wf_elastic_net <- workflow() %>%
  add_recipe(receita) %>%
  add_model(modelo_elastic_net)

wf_knn <- workflow() %>%
  add_recipe(receita) %>%
  add_model(modelo_knn)

# Dividindo os dados
dados_split <- initial_split(dados_com_faltantes, prop = 0.8)
treino <- training(dados_split)
teste <- testing(dados_split)

# Configurar validação cruzada
cv <- vfold_cv(treino, v = 10)

# Configurar grid para Elastic-Net
grid_elastic_net <- expand.grid(penalty = 10^seq(-3, 3, length = 30),
                                 mixture = seq(0, 1, length = 10))

# Tunar modelo Elastic-Net
tunagem_elastic_net <- tune_grid(wf_elastic_net, resamples = cv, grid = grid_elastic_net)

## → A | warning: A correlation computation is required, but `estimate` is constant and has 0
##                standard deviation, resulting in a divide by 0 error. `NA` will be returned.

## There were issues with some computations   A: x1There were issues with some computations   A: x2There were issues with some computations   A: x3There were issues with some computations   A: x4There were issues with some computations   A: x5There were issues with some computations   A: x6There were issues with some computations   A: x7There were issues with some computations   A: x8There were issues with some computations   A: x9There were issues with some computations   A: x10There were issues with some computations   A: x10

# Melhor modelo Elastic-Net
melhor_elastic_net <- select_best(tunagem_elastic_net, metric = "rmse")

# Ajustar o modelo Elastic-Net final
wf_elastic_net_final <- finalize_workflow(wf_elastic_net, melhor_elastic_net)
ajuste_elastic_net <- last_fit(wf_elastic_net_final, dados_split)

# Configurar grid para KNN
grid_knn <- expand.grid(neighbors = seq(1, 20, by = 1))

# Tunar modelo KNN
tunagem_knn <- tune_grid(wf_knn, resamples = cv, grid = grid_knn)

# Melhor modelo KNN
melhor_knn <- select_best(tunagem_knn, metric = "rmse")

# Ajustar o modelo KNN final
wf_knn_final <- finalize_workflow(wf_knn, melhor_knn)
ajuste_knn <- last_fit(wf_knn_final, dados_split)

# Coletar métricas para Elastic-Net
metricas_elastic_net <- collect_metrics(ajuste_elastic_net)

# Coletar métricas para KNN
metricas_knn <- collect_metrics(ajuste_knn)

# Mostrar métricas
print(metricas_elastic_net)

## # A tibble: 2 × 4
##   .metric .estimator .estimate .config             
##   <chr>   <chr>          <dbl> <chr>               
## 1 rmse    standard       1.13  Preprocessor1_Model1
## 2 rsq     standard       0.948 Preprocessor1_Model1

print(metricas_knn)

## # A tibble: 2 × 4
##   .metric .estimator .estimate .config             
##   <chr>   <chr>          <dbl> <chr>               
## 1 rmse    standard       2.78  Preprocessor1_Model1
## 2 rsq     standard       0.806 Preprocessor1_Model1

Conclusão 4: O modelo do Elastic-Net foi escolhido porque apresenta um menor RMSE e uma maior explicação da variabilidade dos dados, ou seja, um maior $R^2$. Isso indica que o Elastic-Net oferece previsões mais precisas e é mais capaz de capturar a variabilidade nos dados.

Questão 5) Considere a base de dados referente à despesas médicas, cujo o objetivo é predizer a variável charges. Considere os algoritmos, lasso, ridge, elastic net e KNN e compare o risco preditivo de cada um dos modelos. Você deverá utilizar boas práticas na comparação, explorar os dados e avaliar de forma adequada o risco preditivo de cada um dos modelos considerados. Perceba que existem variáveis categóricas na base de dados. Dessa forma, você deverá introduzir no pipeline o pré-processamento. Discuta o resultado.

library(tidymodels)
library(glmnet)
library(kknn)
library(dplyr)

# Carregar a base de dados
dados <- read.csv("C:/Users/gleyc/Downloads/insurance_questao5.csv")

# Dividir os dados em treino e teste
set.seed(0)
dados_split <- initial_split(dados, prop = 0.8)
dados_treino <- training(dados_split)
dados_teste <- testing(dados_split)

# Criar uma receita para pré-processamento
receita <- recipe(charges ~ ., data = dados_treino) %>%
  step_dummy(all_nominal(), -all_outcomes()) %>%  
  step_normalize(all_numeric(), -all_outcomes())  

# Modelos
modelo_lasso <- linear_reg(penalty = tune(), mixture = 1) %>%
  set_engine("glmnet") %>%
  set_mode("regression")

modelo_ridge <- linear_reg(penalty = tune(), mixture = 0) %>%
  set_engine("glmnet") %>%
  set_mode("regression")

modelo_elastic_net <- linear_reg(penalty = tune(), mixture = tune()) %>%
  set_engine("glmnet") %>%
  set_mode("regression")

modelo_knn <- nearest_neighbor(neighbors = tune()) %>%
  set_engine("kknn") %>%
  set_mode("regression")

# Workflows
wf_lasso <- workflow() %>%
  add_recipe(receita) %>%
  add_model(modelo_lasso)

wf_ridge <- workflow() %>%
  add_recipe(receita) %>%
  add_model(modelo_ridge)

wf_elastic_net <- workflow() %>%
  add_recipe(receita) %>%
  add_model(modelo_elastic_net)

wf_knn <- workflow() %>%
  add_recipe(receita) %>%
  add_model(modelo_knn)

# Definir validação cruzada
cv_folds <- vfold_cv(dados_treino, v = 10)

# Definir grid de parâmetros
grid_lasso <- grid_regular(penalty(), levels = 30)
grid_ridge <- grid_regular(penalty(), levels = 30)
grid_elastic_net <- grid_regular(penalty(), mixture(), levels = 10)
grid_knn <- grid_regular(neighbors(), levels = 10)

# Ajustar e tunar os modelos
tune_lasso <- tune_grid(wf_lasso, resamples = cv_folds, grid = grid_lasso)
tune_ridge <- tune_grid(wf_ridge, resamples = cv_folds, grid = grid_ridge)
tune_elastic_net <- tune_grid(wf_elastic_net, resamples = cv_folds, grid = grid_elastic_net)
tune_knn <- tune_grid(wf_knn, resamples = cv_folds, grid = grid_knn)

# Coletar métricas
metricas_lasso <- collect_metrics(tune_lasso)
metricas_ridge <- collect_metrics(tune_ridge)
metricas_elastic_net <- collect_metrics(tune_elastic_net)
metricas_knn <- collect_metrics(tune_knn)

# Visualizar os resultados
metricas_lasso

## # A tibble: 60 × 7
##     penalty .metric .estimator     mean     n  std_err .config              
##       <dbl> <chr>   <chr>         <dbl> <int>    <dbl> <chr>                
##  1 1   e-10 rmse    standard   5977.       10 262.     Preprocessor1_Model01
##  2 1   e-10 rsq     standard      0.755    10   0.0217 Preprocessor1_Model01
##  3 2.21e-10 rmse    standard   5977.       10 262.     Preprocessor1_Model02
##  4 2.21e-10 rsq     standard      0.755    10   0.0217 Preprocessor1_Model02
##  5 4.89e-10 rmse    standard   5977.       10 262.     Preprocessor1_Model03
##  6 4.89e-10 rsq     standard      0.755    10   0.0217 Preprocessor1_Model03
##  7 1.08e- 9 rmse    standard   5977.       10 262.     Preprocessor1_Model04
##  8 1.08e- 9 rsq     standard      0.755    10   0.0217 Preprocessor1_Model04
##  9 2.40e- 9 rmse    standard   5977.       10 262.     Preprocessor1_Model05
## 10 2.40e- 9 rsq     standard      0.755    10   0.0217 Preprocessor1_Model05
## # ℹ 50 more rows

metricas_ridge

## # A tibble: 60 × 7
##     penalty .metric .estimator     mean     n  std_err .config              
##       <dbl> <chr>   <chr>         <dbl> <int>    <dbl> <chr>                
##  1 1   e-10 rmse    standard   6023.       10 262.     Preprocessor1_Model01
##  2 1   e-10 rsq     standard      0.755    10   0.0216 Preprocessor1_Model01
##  3 2.21e-10 rmse    standard   6023.       10 262.     Preprocessor1_Model02
##  4 2.21e-10 rsq     standard      0.755    10   0.0216 Preprocessor1_Model02
##  5 4.89e-10 rmse    standard   6023.       10 262.     Preprocessor1_Model03
##  6 4.89e-10 rsq     standard      0.755    10   0.0216 Preprocessor1_Model03
##  7 1.08e- 9 rmse    standard   6023.       10 262.     Preprocessor1_Model04
##  8 1.08e- 9 rsq     standard      0.755    10   0.0216 Preprocessor1_Model04
##  9 2.40e- 9 rmse    standard   6023.       10 262.     Preprocessor1_Model05
## 10 2.40e- 9 rsq     standard      0.755    10   0.0216 Preprocessor1_Model05
## # ℹ 50 more rows

metricas_elastic_net

## # A tibble: 200 × 8
##          penalty mixture .metric .estimator     mean     n  std_err .config     
##            <dbl>   <dbl> <chr>   <chr>         <dbl> <int>    <dbl> <chr>       
##  1 0.0000000001        0 rmse    standard   6023.       10 262.     Preprocesso…
##  2 0.0000000001        0 rsq     standard      0.755    10   0.0216 Preprocesso…
##  3 0.00000000129       0 rmse    standard   6023.       10 262.     Preprocesso…
##  4 0.00000000129       0 rsq     standard      0.755    10   0.0216 Preprocesso…
##  5 0.0000000167        0 rmse    standard   6023.       10 262.     Preprocesso…
##  6 0.0000000167        0 rsq     standard      0.755    10   0.0216 Preprocesso…
##  7 0.000000215         0 rmse    standard   6023.       10 262.     Preprocesso…
##  8 0.000000215         0 rsq     standard      0.755    10   0.0216 Preprocesso…
##  9 0.00000278          0 rmse    standard   6023.       10 262.     Preprocesso…
## 10 0.00000278          0 rsq     standard      0.755    10   0.0216 Preprocesso…
## # ℹ 190 more rows

metricas_knn

## # A tibble: 20 × 7
##    neighbors .metric .estimator     mean     n  std_err .config              
##        <int> <chr>   <chr>         <dbl> <int>    <dbl> <chr>                
##  1         1 rmse    standard   6415.       10 277.     Preprocessor1_Model01
##  2         1 rsq     standard      0.730    10   0.0238 Preprocessor1_Model01
##  3         2 rmse    standard   5878.       10 276.     Preprocessor1_Model02
##  4         2 rsq     standard      0.766    10   0.0228 Preprocessor1_Model02
##  5         3 rmse    standard   5542.       10 278.     Preprocessor1_Model03
##  6         3 rsq     standard      0.787    10   0.0229 Preprocessor1_Model03
##  7         4 rmse    standard   5394.       10 281.     Preprocessor1_Model04
##  8         4 rsq     standard      0.797    10   0.0231 Preprocessor1_Model04
##  9         5 rmse    standard   5314.       10 287.     Preprocessor1_Model05
## 10         5 rsq     standard      0.802    10   0.0233 Preprocessor1_Model05
## 11         6 rmse    standard   5266.       10 290.     Preprocessor1_Model06
## 12         6 rsq     standard      0.806    10   0.0233 Preprocessor1_Model06
## 13         7 rmse    standard   5233.       10 292.     Preprocessor1_Model07
## 14         7 rsq     standard      0.808    10   0.0233 Preprocessor1_Model07
## 15         8 rmse    standard   5212.       10 294.     Preprocessor1_Model08
## 16         8 rsq     standard      0.810    10   0.0232 Preprocessor1_Model08
## 17         9 rmse    standard   5201.       10 295.     Preprocessor1_Model09
## 18         9 rsq     standard      0.811    10   0.0231 Preprocessor1_Model09
## 19        10 rmse    standard   5196.       10 296.     Preprocessor1_Model10
## 20        10 rsq     standard      0.812    10   0.0229 Preprocessor1_Model10

Conclusão 5: Os resultados sugerem que, para este conjunto de dados, o modelo KNN com K=10 oferece o melhor equilíbrio entre precisão e capacidade de explicação da variabilidade dos preços das casas. No entanto, os modelos de regularização como Lasso e Ridge podem ser preferíveis em situações onde a interpretabilidade e a simplicidade sejam fatores mais fortes, especialmente quando se busca entender o impacto individual de cada variável explicativa no modelo.

Prova 2 - Aprendizagem de Máquina

Gleyce Ryelle - Matricula: 20180088030

09/09/2024