Învățarea spațială a mașinilor cu cadrul Tidymodels

Introducere

În această postare pe blog, vom arăta cum să folosim Tidymodels Cadru pentru învățarea spațială a mașinilor. Tidymodels Framework este o colecție de pachete R pentru modelare și învățare automată folosind Tidyverse Principiile.

Pregătiți date

Încărcați pachetele necesare:

library(terra)
library(sf)
library(tidymodels)
library(ranger)
library(dplyr)
library(spatialsample)
library(waywiser)
library(vip)

Citiți date:

trainingdata <- sf::st_read("https://github.com/LOEK-RS/FOSSGIS2025-examples/raw/refs/heads/main/data/temp_train.gpkg")
predictors <- terra::rast("https://github.com/LOEK-RS/FOSSGIS2025-examples/raw/refs/heads/main/data/predictors.tif")

Pregătiți datele prin extragerea datelor de instruire din raster și transformarea acestora într -un sf obiect.

trainDat <- sf::st_as_sf(terra::extract(predictors, trainingdata, bind = TRUE))
predictor_names <- names(predictors) # Extract predictor names from the raster
response_name <- "temp"

Un model simplu de antrenament și predicție

În primul rând, antrenăm un model de pădure aleatoriu. Acest lucru se face prin definirea unei rețete și a unui model, și apoi combinându -le într -un flux de lucru. Un astfel de flux de lucru poate fi apoi utilizat pentru a se potrivi modelului la date.

# Define the recipe
formula <- as.formula(paste(
    response_name,
    "~",
    paste(predictor_names, collapse = " + ")
))
recipe <- recipes::recipe(formula, data = trainDat)

rf_model <- parsnip::rand_forest(trees = 100, mode = "regression") |>
    set_engine("ranger", importance = "impurity")

# Create the workflow
workflow <- workflows::workflow() |>
    workflows::add_recipe(recipe) |>
    workflows::add_model(rf_model)

# Fit the model
rf_fit <- parsnip::fit(workflow, data = trainDat)

Acum, să folosim modelul pentru predicție spațială cu terra::predict().

prediction_raster <- terra::predict(predictors, rf_fit, na.rm = TRUE)
plot(prediction_raster)

Validare încrucișată spațială

Validarea încrucișată necesită specificarea modului în care datele sunt împărțite în pliuri. Aici, definim o validare încrucișată non-spațială cu rsample::vfold_cv() și o validare încrucișată spațială cu spatialsample::spatial_block_cv().

random_folds <- rsample::vfold_cv(trainDat, v = 4)
block_folds <- spatialsample::spatial_block_cv(trainDat, v = 4, n = 2)
spatialsample::autoplot(block_folds)

# control cross-validation
keep_pred <- tune::control_resamples(save_pred = TRUE, save_workflow = TRUE)

În continuare, ne potrivim modelul la date folosind validarea încrucișată cu tune::fit_resamples().

### Cross-validation
rf_random <- tune::fit_resamples(
    workflow,
    resamples = random_folds,
    control = keep_pred
)
rf_spatial <- tune::fit_resamples(
    workflow,
    resamples = block_folds,
    control = keep_pred
)

Pentru a compara modelele montate, putem folosi tune::collect_metrics() Funcție pentru a obține valorile.

### get CV metrics
tune::collect_metrics(rf_random)

# A tibble: 2 × 6
  .metric .estimator  mean     n std_err .config             
                               
1 rmse    standard   0.934     4  0.0610 Preprocessor1_Model1
2 rsq     standard   0.908     4  0.0154 Preprocessor1_Model1

tune::collect_metrics(rf_spatial)

# A tibble: 2 × 6
  .metric .estimator  mean     n std_err .config             
                               
1 rmse    standard   1.33      4  0.271  Preprocessor1_Model1
2 rsq     standard   0.740     4  0.0783 Preprocessor1_Model1

# rf_spatial$.metrics # metrics from each fold

În plus, putem vizualiza modelele prin extragerea predicțiilor lor cu tune::collect_predictions() și complotându -le.

Reglarea modelului: reglarea hiperparameterului spațial și selecția variabilă

# mark two parameters for tuning:
rf_model <- parsnip::rand_forest(
    trees = 100,
    mode = "regression",
    mtry = tune(),
    min_n = tune()
) |>
    set_engine("ranger", importance = "impurity")

workflow <- update_model(workflow, rf_model)

# define tune grid:
grid_rf <-
    grid_space_filling(
        mtry(range = c(1, 20)),
        min_n(range = c(2, 10)),
        size = 30
    )

# tune:
rf_tuning <- tune_grid(
    workflow,
    resamples = block_folds,
    grid = grid_rf,
    control = keep_pred
)

rf_tuning |>
    collect_metrics()

# A tibble: 60 × 8
    mtry min_n .metric .estimator  mean     n std_err .config              
                                   
 1     1     5 rmse    standard   1.91      4  0.307  Preprocessor1_Model01
 2     1     5 rsq     standard   0.613     4  0.0849 Preprocessor1_Model01
 3     1     9 rmse    standard   1.93      4  0.311  Preprocessor1_Model02
 4     1     9 rsq     standard   0.582     4  0.103  Preprocessor1_Model02
 5     2     4 rmse    standard   1.61      4  0.318  Preprocessor1_Model03
 6     2     4 rsq     standard   0.697     4  0.0692 Preprocessor1_Model03
 7     2     2 rmse    standard   1.68      4  0.285  Preprocessor1_Model04
 8     2     2 rsq     standard   0.654     4  0.111  Preprocessor1_Model04
 9     3     7 rmse    standard   1.47      4  0.304  Preprocessor1_Model05
10     3     7 rsq     standard   0.713     4  0.0837 Preprocessor1_Model05
# ℹ 50 more rows

rf_tuning |>
    collect_metrics() |>
    mutate(min_n = factor(min_n)) |>
    ggplot(aes(mtry, mean, color = min_n)) +
    geom_line(linewidth = 1.5, alpha = 0.6) +
    geom_point(size = 2) +
    facet_wrap(~.metric, scales = "free", nrow = 2) +
    scale_x_log10(labels = scales::label_number()) +
    scale_color_viridis_d(option = "plasma", begin = .9, end = 0)

finalmodel <- fit_best(rf_tuning)
finalmodel

══ Workflow (trained) ══════════════════════════════════════════════════════════
Preprocessor: Recipe
Model: rand_forest()

── Preprocessor ────────────────────────────────────────────────────────────────
0 Recipe Steps

── Model ───────────────────────────────────────────────────────────────────────
Ranger result

Call:
 ranger::ranger(x = maybe_data_frame(x), y = y, mtry = min_cols(~19L,      x), num.trees = ~100, min.node.size = min_rows(~3L, x), importance = ~"impurity",      num.threads = 1, verbose = FALSE, seed = sample.int(10^5,          1)) 

Type:                             Regression 
Number of trees:                  100 
Sample size:                      195 
Number of independent variables:  22 
Mtry:                             19 
Target node size:                 3 
Variable importance mode:         impurity 
Splitrule:                        variance 
OOB prediction error (MSE):       0.7477837 
R squared (OOB):                  0.9062111 

imp <- extract_fit_parsnip(finalmodel) |>
    vip::vip()
imp

final_pred <- terra::predict(predictors, finalmodel, na.rm = TRUE)
plot(final_pred)

Zona de aplicabilitate

Waywiser Pachetul oferă un set de instrumente pentru evaluarea modelelor spațiale, inclusiv o implementare a evaluării pe mai multe scări și a zonei de aplicabilitate. Zona de aplicabilitate este o măsură a cât de bine poate fi aplicat modelul (având în vedere datele de instruire) la datele de predicție. Poate fi calculat cu ww_area_of_applicability() funcționare și apoi a prezis pe raster cu terra::predict().

model_aoa <- waywiser::ww_area_of_applicability(
    st_drop_geometry(trainDat(, predictor_names)),
    importance = vip::vi_model(finalmodel)
)
AOA <- terra::predict(predictors, model_aoa)
plot(AOA$aoa)

Mai multe informații despre Waywiser Pachetul poate fi găsit în documentația sa.

Rezumat

Această postare pe blog a arătat cum să folosești Tidymodels Cadru pentru învățarea spațială a mașinilor. Am demonstrat cum să antrenez un model forestier aleatoriu, să efectuăm validarea spațială, să regleze hiperparametre și să evaluăm aria de aplicabilitate. De asemenea, am arătat cum să vizualizăm rezultatele și să extragem importanța variabilă.¹

Tidymodels Cadru cu pachetele sale Spațial -eșantion şi Waywiser Oferă o modalitate puternică și flexibilă de a efectua învățarea spațială a mașinilor în R. În același timp, este ceva mai complexă decât semn de omisiune: necesită să vă familiarizați cu mai multe pachete² și relațiile dintre ei. Astfel, decizia care trebuie utilizată depinde de nevoile și preferințele specifice ale utilizatorului.