R Academy · Pelajaran

Vektorisasi untuk Kecepatan

Q: Apakah pelajaran “Vektorisasi untuk Kecepatan” gratis?

Ya — teks lengkap “Vektorisasi untuk Kecepatan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus R Academy, upgrade ke CoddyKit PRO. Kursus R Academy mencakup 4 pelajaran total.

Q: Apakah aku perlu pengalaman untuk memulai R Academy?

Tidak diperlukan pengalaman sebelumnya. R Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Q: Berapa lama pelajaran “Vektorisasi untuk Kecepatan” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Q: Bisakah aku menulis dan menjalankan kode dalam pelajaran R Academy ini?

Ya. Setiap pelajaran R Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Ganti perulangan eksplisit dengan operasi tervectorisasi untuk peningkatan kecepatan yang signifikan.

Pelajaran 3 dari 413 langkah

Vektorisasi untuk Kecepatan adalah pelajaran R Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar R Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus R Academy mencakup 4 pelajaran total.

Mengapa Vektorisasi Penting

R adalah bahasa yang ditafsirkan, sehingga perulangan for memiliki overhead pada setiap iterasi — pengiriman pemanggilan fungsi, pemeriksaan batas, dan koersi tipe. Operasi tervectorisasi memindahkan pekerjaan tersebut ke kode C terkompilasi yang berjalan jauh lebih cepat.

Vektorisasi adalah pengoptimalan paling berdampak yang tersedia dalam R dasar.

Contoh Perulangan vs cumsum()

Menghitung total berjalan dengan perulangan for dibandingkan dengan cumsum() bawaan menunjukkan perbedaannya dengan jelas. cumsum() memanggil kode terkompilasi tingkat C dan memproses seluruh vektor dalam satu lintasan.

n <- 500000
x <- rnorm(n)

t_loop <- system.time({
  result <- numeric(n)
  result[1] <- x[1]
  for (i in 2:n) result[i] <- result[i-1] + x[i]
})['elapsed']

t_vec <- system.time({
  result2 <- cumsum(x)
})['elapsed']

cat('Loop  :', t_loop, 's
')
cat('cumsum:', t_vec, 's
')

ifelse() vs for + if

ifelse(condition, yes, no) adalah kondisi tervectorisasi yang mengevaluasi kondisi di seluruh vektor sekaligus. Fungsi ini menggantikan perulangan for + if elemen demi elemen dengan satu lintasan tingkat C.

n <- 300000
x <- rnorm(n)

t_loop <- system.time({
  result <- numeric(n)
  for (i in seq_len(n)) result[i] <- if (x[i] > 0) x[i] else -x[i]
})['elapsed']

t_vec <- system.time({
  result2 <- ifelse(x > 0, x, -x)
})['elapsed']

cat('for+if :', t_loop, 's
')
cat('ifelse :', t_vec, 's
')

Pra-Alokasi Vektor Hasil

Jika perulangan tidak dapat dihindari, pra-alokasikan vektor hasil sebelum perulangan. Memperbesar vektor dengan c(result, new_val) di dalam perulangan akan menyalin seluruh vektor pada setiap iterasi — total operasi memori O(n^2).

n <- 20000

t_grow <- system.time({
  result <- c()
  for (i in seq_len(n)) result <- c(result, i^2)
})['elapsed']

t_prealloc <- system.time({
  result2 <- numeric(n)
  for (i in seq_len(n)) result2[i] <- i^2
})['elapsed']

cat('Growing vector:', t_grow, 's
')
cat('Pre-allocated :', t_prealloc, 's
')

Tipe Pra-Alokasi yang Tepat

Gunakan konstruktor bertipe yang sesuai dengan data Anda untuk menghindari koersi implisit selama pra-alokasi:

numeric(n) — bilangan pecahan presisi ganda
integer(n) — bilangan bulat
character(n) — string kosong
logical(n) — nilai FALSE
vector('list', n) — daftar berisi NULL

n <- 5
cat('numeric  :', numeric(n), '
')
cat('integer  :', integer(n), '
')
cat('logical  :', logical(n), '
')
cat('character:', character(n), '
')
cat('list len :', length(vector('list', n)), '
')

colSums() dan rowSums() vs apply()

Untuk operasi matriks, colSums(m), rowSums(m), colMeans(m), dan rowMeans(m) adalah rutin C yang sangat dioptimalkan. Fungsi-fungsi ini secara konsisten lebih cepat daripada apply(m, 1, sum), yang mengirimkan fungsi R sum sekali untuk setiap baris.

m <- matrix(rnorm(1000 * 2000), nrow = 1000)

t_apply <- system.time(apply(m, 2, sum))['elapsed']
t_colsums <- system.time(colSums(m))['elapsed']

cat('apply(m,2,sum):', t_apply, 's
')
cat('colSums(m)    :', t_colsums, 's
')

Aritmetika Tervectorisasi Selalu Cepat

Aritmetika dasar pada vektor — +, -, *, /, ^, sqrt(), log(), exp() — semuanya tervectorisasi. Operasi tersebut bekerja per elemen di seluruh vektor dalam satu pemanggilan C. Selalu utamakan operasi ini daripada perulangan.

x <- 1:1000000

t1 <- system.time(y <- x^2 + 2*x + 1)['elapsed']

t2 <- system.time({
  y2 <- numeric(length(x))
  for (i in seq_along(x)) y2[i] <- x[i]^2 + 2*x[i] + 1
})['elapsed']

cat('Vectorized:', t1, 's
')
cat('Loop      :', t2, 's
')

Subset Logis, Bukan Perulangan

Memfilter vektor dengan kondisi logis dilakukan secara tervectorisasi. Daripada melakukan perulangan dan menambahkan elemen secara kondisional, buat indeks logis lalu lakukan subset sekali—kode C yang mendasarinya cukup melakukan satu kali lintasan.

x <- rnorm(500000)

t_loop <- system.time({
  pos <- c()
  for (v in x) if (v > 0) pos <- c(pos, v)
})['elapsed']

t_vec <- system.time({
  pos2 <- x[x > 0]
})['elapsed']

cat('Loop filter:', t_loop, 's
')
cat('Logical idx:', t_vec, 's
')

which() dan tabulate() untuk Menangani Indeks

Saat Anda memerlukan posisi nilai TRUE, which(condition) tervectorisasi dan cepat. tabulate(bin_vector) menghitung kemunculan bilangan bulat lebih cepat daripada table() untuk rentang bilangan bulat yang padat.

x <- sample(1:10, 100000, replace = TRUE)

t_table    <- system.time(table(x))['elapsed']
t_tabulate <- system.time(tabulate(x, nbins = 10))['elapsed']

cat('table()   :', t_table, 's
')
cat('tabulate():', t_tabulate, 's
')

idx <- which(x == 5)
cat('Positions of 5: first 5 =', head(idx, 5), '
')

Saat Perulangan Masih Dapat Digunakan

Tidak semua perulangan itu buruk. Perulangan dapat digunakan ketika:

Setiap iterasi bergantung pada hasil sebelumnya (ketergantungan berurutan)
Jumlah iterasinya kecil (< 1000)
Badan perulangan memanggil fungsi kompleks yang tidak memiliki padanan tervectorisasi

Dalam kasus ini, fokuslah pada pra-alokasi dan hindari memperbesar struktur di dalam perulangan.

# Sequential dependency -- loop is correct here
fib <- function(n) {
  result <- integer(n)
  result[1] <- 1L
  if (n >= 2) result[2] <- 1L
  for (i in seq_len(n)[-c(1,2)]) result[i] <- result[i-1] + result[i-2]
  result
}
cat('Fibonacci:', fib(10), '
')

Ringkasan Vektorisasi

Aturan utama vektorisasi untuk kode R yang cepat:

Gunakan cumsum/cumprod/diff untuk akumulasi berurutan
Gunakan ifelse() untuk kondisi per elemen
Lakukan pra-alokasi dengan numeric(n) / vector('list',n)
Gunakan colSums/rowSums/colMeans/rowMeans, bukan apply()
Subset logis lebih unggul daripada perulangan pemfilteran

Pemeriksaan Cepat: Pra-alokasi

Mengapa memperbesar vektor dengan result <- c(result, new_val) di dalam perulangan sangat lambat untuk n yang besar?

Jawab di pelajaran interaktif

Ikhtisar Vektorisasi

Vektorisasi adalah pengungkit kinerja utama R:

Fungsi tervectorisasi (cumsum, ifelse, operator aritmetika) memanggil kode C terkompilasi—sehingga 10–100 kali lebih cepat daripada perulangan R yang setara
Lakukan pra-alokasi wadah hasil sebelum perulangan yang tidak dapat dihindari untuk menghindari penyalinan O(n²)
colSums/rowSums lebih cepat daripada apply() untuk agregasi matriks
Subset logis menggantikan perulangan pemfilteran dengan cara yang rapi dan cepat

Gratis untuk memulai

Belajar R dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 43
Pelajaran: 159

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Vektorisasi untuk Kecepatan” gratis?

Ya — teks lengkap “Vektorisasi untuk Kecepatan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus R Academy, upgrade ke CoddyKit PRO. Kursus R Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Vektorisasi untuk Kecepatan”?

Ganti perulangan eksplisit dengan operasi tervectorisasi untuk peningkatan kecepatan yang signifikan. Kamu berlatih R Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai R Academy?

Tidak diperlukan pengalaman sebelumnya. R Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Vektorisasi untuk Kecepatan” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran R Academy ini?

Ya. Setiap pelajaran R Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

system.time() dan proc.time()
Membuat Profil Kode dengan Rprof dan profvis
Vektorisasi untuk Kecepatan
Menguji Kinerja dengan microbenchmark

← Kembali ke R Academy