100 lagu r&b lambat teratas 2022

[Artikel ini pertama kali diterbitkan di DataSascience+, dan berkontribusi dengan baik kepada R-Bloggers]. (Anda dapat melaporkan masalah tentang konten di halaman ini di sini) DataScience+, and kindly contributed to R-bloggers]. (You can report issue about the content on this page here)

Ingin berbagi konten Anda di R-Bloggers? Klik di sini jika Anda memiliki blog, atau di sini jika tidak.

For-loop di R, bisa sangat lambat dalam bentuknya yang tidak dioptimalkan, terutama ketika berhadapan dengan set data yang lebih besar. Ada sejumlah cara Anda dapat membuat logika Anda berjalan cepat, tetapi Anda akan benar -benar terkejut betapa cepatnya Anda benar -benar bisa pergi. Posting ini menunjukkan sejumlah pendekatan termasuk penyesuaian sederhana untuk desain logika, pemrosesan paralel dan

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

Mari kita coba untuk meningkatkan kecepatan logika yang melibatkan pernyataan periksa untuk loop dan kondisi (IF-ELSE) untuk membuat kolom yang ditambahkan ke input data frame (DF). Kode di bawah ini membuat bingkai data input awal itu.

# Create the data frame
col1 <- runif (12^5, 0, 2)
col2 <- rnorm (12^5, 0, 2)
col3 <- rpois (12^5, 3)
col4 <- rchisq (12^5, 2)
df <- data.frame (col1, col2, col3, col4)

Logika yang akan kami optimalkan: untuk setiap baris pada bingkai data ini (DF), periksa apakah jumlah semua nilai lebih besar dari 4. Jika ya, variabel ke -5 baru mendapatkan nilai "Greater_than_4", yang lain, didapatkan “Lesser_than_4”.
For every row on this data frame (df), check if the sum of all values is greater than 4. If it is, a new 5th variable gets the value “greater_than_4”, else, it gets “lesser_than_4”.

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

Semua perhitungan di bawah ini, untuk waktu pemrosesan, dilakukan pada Mac OS X dengan prosesor 2,6 GHz dan RAM 8GB.

Struktur data vektor dan pra-alokasi

Selalu inisialisasi struktur data dan variabel output Anda ke panjang dan tipe data yang diperlukan sebelum membawanya ke loop untuk perhitungan. Cobalah untuk tidak secara bertahap meningkatkan ukuran data Anda di dalam loop. Mari kita bandingkan bagaimana vektorisasi meningkatkan kecepatan pada berbagai ukuran data dari 1000 hingga 100.000 baris.

# after vectorization and pre-allocation
output <- character (nrow(df)) # initialize output vector
system.time({
  for (i in 1:nrow(df)) {
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) {
      output[i] <- "greater_than_4"
    } else {
      output[i] <- "lesser_than_4"
    }
  }
df$output})

Kode mentah vs dengan vektorisasi:

Ambil pernyataan yang memeriksa ketentuan (jika pernyataan) di luar loop

Mengambil kondisi pemeriksaan di luar loop kecepatan dibandingkan dengan versi sebelumnya yang memiliki vektorisasi saja. Tes dilakukan pada kisaran ukuran dataset dari 100.000 hingga 1.000.000 baris. Keuntungan dalam kecepatan sekali lagi dramatis.

# after vectorization and pre-allocation, taking the condition checking outside the loop.
output <- character (nrow(df))
condition <- (df$col1 + df$col2 + df$col3 + df$col4) > 4  # condition check outside the loop
system.time({
  for (i in 1:nrow(df)) {
    if (condition[i]) {
      output[i] <- "greater_than_4"
    } else {
      output[i] <- "lesser_than_4"
    }
  }
  df$output <- output
})

Kondisi memeriksa loop luar:

Jalankan loop hanya untuk kondisi sebenarnya

Optimalisasi lain yang dapat kita lakukan di sini adalah menjalankan loop hanya untuk kasus kondisi yang 'benar', dengan menginisialisasi (pra-pengalokasian) nilai default vektor output dengan keadaan 'false'. Peningkatan kecepatan di sini sangat tergantung pada proporsi kasus 'benar' dalam data Anda.

Tes membandingkan kinerja ini dengan kasus sebelumnya (2) pada ukuran data mulai dari 1.000.000 hingga 10.000.000 baris. Perhatikan bahwa kami telah meningkatkan ‘0’ di sini. Seperti yang diharapkan ada peningkatan yang konsisten dan cukup besar.

output <- character(nrow(df))
condition <- (df$col1 + df$col2 + df$col3 + df$col4) > 4
system.time({
  for (i in (1:nrow(df))[condition]) {  # run loop only for true conditions
    if (condition[i]) {
      output[i] <- "greater_than_4"
    } else {
      output[i] <- "lesser_than_4"
    }
  }
  df$output })

Berjalan hanya pada kondisi sebenarnya:

Gunakan ifelse () jika memungkinkan

Anda dapat membuat logika ini lebih sederhana dan lebih cepat dengan menggunakan pernyataan

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

system.time({
  output <- ifelse ((df$col1 + df$col2 + df$col3 + df$col4) > 4, "greater_than_4", "lesser_than_4")
  df$output <- output
})

Kondisi sebenarnya hanya vs ifelse:

Menggunakan yang ()

Dengan menggunakan perintah

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

# Thanks to Gabe Becker
system.time({
  want = which(rowSums(df) > 4)
  output = rep("less than 4", times = nrow(df))
  output[want] = "greater than 4"
}) 
# nrow = 3 Million rows (approx)
   user  system elapsed 
  0.396   0.074   0.481 

Gunakan Terapkan Keluarga Fungsi alih-alih For-Loops

Menggunakan fungsi Apply () untuk menghitung logika yang sama dan membandingkannya dengan for-loop vektor. Hasilnya lagi lebih cepat dalam urutan besar tetapi lebih lambat dari

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

# apply family
system.time({
  myfunc <- function(x) {
    if ((x['col1'] + x['col2'] + x['col3'] + x['col4']) > 4) {
      "greater_than_4"
    } else {
      "lesser_than_4"
    }
  }
  output <- apply(df[, c(1:4)], 1, FUN=myfunc)  # apply 'myfunc' on every row
  df$output <- output
})

Terapkan fungsi vs untuk loop di r:

Gunakan kompilasi kode byte untuk fungsi cmpFun () dari paket kompiler, daripada fungsi aktual itu sendiri

Ini mungkin bukan contoh terbaik untuk menggambarkan efektivitas kompilasi kode byte, karena waktu yang diambil sedikit lebih tinggi daripada bentuk reguler. Namun, untuk fungsi yang lebih kompleks, kompilasi kode byte diketahui berkinerja lebih cepat. Jadi Anda harus mencobanya.

# byte code compilation
library(compiler)
myFuncCmp <- cmpfun(myfunc)
system.time({
  output <- apply(df[, c (1:4)], 1, FUN=myFuncCmp)
})

Terapkan Vs For-Loop Vs Byte Code Functions:

Gunakan RCPP

Mari kita tingkatkan takik ini. Sejauh ini kami telah memperoleh kecepatan dan kapasitas dengan berbagai strategi dan menemukan yang paling optimal menggunakan pernyataan

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

library(Rcpp)
sourceCpp("MyFunc.cpp")
system.time (output <- myFunc(df)) # see Rcpp function below

Di bawah ini adalah logika yang sama yang dieksekusi dalam kode C ++ menggunakan paket RCPP. Simpan kode di bawah ini sebagai "myfunc.cpp" di direktori kerja sesi R Anda (kalau tidak Anda hanya perlu melakukan sumber dari filepath lengkap). Catatan: Komentar

# after vectorization and pre-allocation
output <- character (nrow(df)) # initialize output vector
system.time({
  for (i in 1:nrow(df)) {
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) {
      output[i] <- "greater_than_4"
    } else {
      output[i] <- "lesser_than_4"
    }
  }
df$output})

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

# after vectorization and pre-allocation
output <- character (nrow(df)) # initialize output vector
system.time({
  for (i in 1:nrow(df)) {
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) {
      output[i] <- "greater_than_4"
    } else {
      output[i] <- "lesser_than_4"
    }
  }
df$output})

Gunakan pemrosesan paralel jika Anda memiliki mesin multicore

Proses paralel:

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

Hapus variabel dan siram memori sedini mungkin

Hapus objek

# after vectorization and pre-allocation
output <- character (nrow(df)) # initialize output vector
system.time({
  for (i in 1:nrow(df)) {
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) {
      output[i] <- "greater_than_4"
    } else {
      output[i] <- "lesser_than_4"
    }
  }
df$output})

# after vectorization and pre-allocation
output <- character (nrow(df)) # initialize output vector
system.time({
  for (i in 1:nrow(df)) {
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) {
      output[i] <- "greater_than_4"
    } else {
      output[i] <- "lesser_than_4"
    }
  }
df$output})

Gunakan struktur data yang mengkonsumsi memori yang lebih rendah

# after vectorization and pre-allocation
output <- character (nrow(df)) # initialize output vector
system.time({
  for (i in 1:nrow(df)) {
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) {
      output[i] <- "greater_than_4"
    } else {
      output[i] <- "lesser_than_4"
    }
  }
df$output})

# Original R code: Before vectorization and pre-allocation
system.time({
  for (i in 1:nrow(df)) { # for every row
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) { # check if > 4
      df[i, 5] <- "greater_than_4" # assign 5th column
    } else {
      df[i, 5] <- "lesser_than_4" # assign 5th column
    }
  }
})

DataFrame vs Data.table:

Ringkasan Kecepatan

Metode: kecepatan, nrow (df)/time_taken = n baris per detik: 1x, 120000/140.15 = 856.2255 baris per detik (dinormalisasi menjadi 1) vektorisasi: 738x, 120000/0.19 = 631578.9 Baris per kondisi STEPTRUE Hanya: 1002x, 120000/100000/9.9 0.14 = 857142.9 Baris per Secondifelse: 1752x, 1200000/0.78 = 1500000 baris per detik: 8806x, 2985984/0.396 = 7540364 Baris per SecondRCPP: 13476x, 1200000/0.09 = 11534 per SecondRCPP: 13476X, 1200000/0.09 = 11534 per SecondRCPP: 13476x, 1200000/0.09 = 11538 per SecondRCPP: 13476x, 1200000/0.09 = 11534 per SecondRCPP: 13476x, 1200000/0.09 = 11538 Speed, nrow(df)/time_taken = n rows per second
Raw: 1X, 120000/140.15 = 856.2255 rows per second (normalised to 1)
Vectorised: 738X, 120000/0.19 = 631578.9 rows per second
True Conditions only: 1002X, 120000/0.14 = 857142.9 rows per second
ifelse: 1752X, 1200000/0.78 = 1500000 rows per second
which: 8806X, 2985984/0.396 = 7540364 rows per second
Rcpp: 13476X, 1200000/0.09 = 11538462 rows per second

Angka -angka di atas adalah perkiraan dan berbasis dalam proses sewenang -wenang. Hasilnya tidak dihitung untuk

# after vectorization and pre-allocation
output <- character (nrow(df)) # initialize output vector
system.time({
  for (i in 1:nrow(df)) {
    if ((df[i, 'col1'] + df[i, 'col2'] + df[i, 'col3'] + df[i, 'col4']) > 4) {
      output[i] <- "greater_than_4"
    } else {
      output[i] <- "lesser_than_4"
    }
  }
df$output})