De voordelen meten

Parallel programmeren in R

Nabeel Imam

Data Scientist

Speelvoorbeeld

numbers <- 1:1000000


# Sequentieel
sqroots <- lapply(numbers, sqrt)


# Parallel
cl <- makeCluster(4)
sqroots <- parLapply(cl, numbers, sqrt)
stopCluster(my_cluster)

Welke is sneller?

Performance benchmarken

Voer code meerdere keren uit om de gemiddelde uitvoeringstijd te schatten

library(microbenchmark)


microbenchmark(
  "Sequential" = lapply(numbers, sqrt),

  "Parallel" = {
    cl <- makeCluster(4)
    parLapply(cl, numbers, sqrt)
    stopCluster(my_cluster)
  },

  times = 10
)

Unit: milliseconds
      expr     min    mean     max neval
Sequential  633.96  838.09  993.59    10
  Parallel 1136.95 1247.29 1557.58    10

Simpele numerieke operaties profiteren zelden van parallelisatie
Profiling geeft regels-rapport; benchmarking geeft totale tijden

De olifant in de kamer

sqroots <- sqrt(numbers)

Een olifant zit op de bank in een woonkamer en mensen erkennen zijn aanwezigheid.

Vectorisatie

sqroots <- sqrt(numbers)

Basis-R-functies, zoals sqrt(), zijn gevectoriseerd.
Pas één functie toe op veel inputs
Zeer snel maar alleen voor eenvoudige bewerkingen

microbenchmark(
  "Vectorized" = sqrt(numbers),
  "Sequential" = lapply(numbers, sqrt),
  "Parallel" = {
    cl <- makeCluster(4)
    parLapply(cl, numbers, sqrt)
    stopCluster(my_cluster)
  },
  times = 10)

Unit: milliseconds
      expr       min      mean      max neval
Vectorized    2.3904    9.2071   66.303    10
Sequential  352.1166  771.7491 1004.753    10
  Parallel 1191.3176 1377.6926 1700.316    10

De bootstrap

Steekproeven trekken uit de huidige data met teruglegging

print(ls_df)

$`2001`
   Country             Life_expectancy  Year
 1 Afghanistan                    56.3  2001
 2 Albania                        74.3  2001
 3 Algeria                        71.1  2001
...
$`2002`
   Country             Life_expectancy  Year
 1 Afghanistan                    56.8  2002
 2 Albania                        74.6  2002
 3 Algeria                        71.6  2002
...

Klassieke versie

df <- ls_df$`2001`


estimates <- rep(0, 10000)


for (i in 1:10000) {

  b <- sample(df$Life_expectancy,
              replace = T)


  estimates[i] <- mean(b)
  }

Een histogram van gebootstrapte schattingen van de wereldwijde gemiddelde levensverwachting in 2001, met de klassieke klokvorm.

Betrouwbaarheidsinterval via kwantielen: quantile(estimates, c(0.025, 0.975))

Goed nieuws

Bootstraps kun je paralleliseren

estimates <- rep(0, 10000)

for (i in 1:10000) {

  b <- sample(df$Life_expectancy,
              replace = T)

  estimates[i] <- mean(b)
  }

boot_dist <- function (df) {

  estimates <- rep(0, 10000)

  for (i in 1:10000) {
    b <- sample(df$Life_expectancy, replace = T)
    estimates[i] <- mean(b)
  }

  return(estimates)
}


cl <- makeCluster(4)
ls_dists <- parLapply(cl, ls_df, boot_dist)
stopCluster(cl)

De voordelen

microbenchmark(
  "lapply" = lapply(ls_df, boot_dist),
  "parLapply" = {
    cl <- makeCluster(4)
    parLapply(cl, ls_df, boot_dist)
    stopCluster(cl)
  },
  times = 10
)

Unit: seconds
     expr    min   mean    max neval
   lapply 3.6938 4.2184 4.5267    10
parLapply 1.9006 2.5166 2.7292    10

Hoe kom je daar:

Profiler je code, vind het traagste deel
Paralleliseer/optimaliseer die stap
Benchmark en vergelijk

Laten we oefenen!

Parallel programmeren in R