Tutorial Loop di R - Penggunaan dan Alternatif

Penjelasan For Loop

Struktur loop ini, terdiri dari kotak persegi panjang ‘init’ (atau inisialisasi), simbol keputusan berbentuk wajik, dan kotak persegi panjang i1 dijalankan sejumlah kali yang diketahui.

Dalam istilah flowchart, kotak persegi panjang berarti sesuatu seperti “lakukan sesuatu yang tidak melibatkan keputusan”. Sementara itu, wajik disebut “simbol keputusan” dan menerjemah menjadi pertanyaan yang hanya memiliki dua jawaban logis, yaitu True (T) atau False (F).

Catatan bahwa untuk menyederhanakan, simbol lain yang mungkin ada dihilangkan dari gambar.

Satu atau lebih instruksi di dalam kotak inisialisasi diikuti oleh evaluasi kondisi pada sebuah variabel yang dapat mengambil nilai dalam suatu urutan tertentu. Pada gambar, ini diwakili oleh simbol wajik: simbol tersebut berarti “apakah nilai saat ini dari variabel v termasuk dalam urutan seq?”.

Dengan kata lain, Anda menguji apakah nilai saat ini dari v berada dalam rentang yang ditentukan. Anda biasanya mendefinisikan rentang ini di inisialisasi, dengan sesuatu seperti 1:100 untuk memastikan loop dimulai.

Jika kondisi tidak terpenuhi dan hasilnya False, loop tidak pernah dijalankan. Ini ditunjukkan oleh panah longgar di sebelah kanan struktur loop for. Program kemudian akan mengeksekusi instruksi pertama yang ditemukan setelah blok loop.

Jika kondisi terpenuhi, sebuah instruksi —atau blok instruksi— i1 dijalankan. Dan mungkin blok instruksi ini adalah loop lain. Dalam kasus seperti itu, ini disebut loop bertingkat (nested loop).

Setelah selesai, kondisi kemudian dievaluasi lagi. Ini ditunjukkan oleh garis dari i1 kembali ke atas, tepat setelah kotak inisialisasi. Di R —dan di Python, hal ini dapat diekspresikan dalam bahasa Inggris biasa, dengan menanyakan apakah variabel kita termasuk dalam suatu rentang nilai atau tidak.

Catatan bahwa di bahasa lain, misalnya C, kondisinya dibuat lebih eksplisit dengan penggunaan operator logika, seperti lebih besar atau lebih kecil dari, sama dengan, …

Berikut contoh for loop sederhana:

# Create a vector filled with random normal values
u1 <- rnorm(30)
print("This loop calculates the square of the first 10 elements of vector u1")

# Initialize `usq`
usq <- 0. 

for (i in 1:10) {
    # i-th element of `u1` squared into `i`-th position of `usq`
    usq[i] <- u1[i] * u1[i]
    print(usq[i])
}

print(i)

Blok for berada dalam kurung kurawal. Ini dapat diletakkan segera setelah kondisi uji atau di baris berikutnya, sebaiknya diikuti indentasi. Tidak ada yang wajib, tetapi kurung kurawal jelas meningkatkan keterbacaan kode Anda dan memudahkan menemukan blok loop dan potensi error di dalamnya.

Catatan bahwa vektor kuadrat, usq, diinisialisasi. Ini tidak akan diperlukan dalam kode RStudio biasa, tetapi dalam versi markup, knitr tidak akan melakukan kompilasi karena referensi ke vektor tidak ditemukan sebelum digunakan dalam loop, sehingga memunculkan error di RStudio. Untuk informasi lebih lanjut tentang knitr, kunjungi halaman R Markdown.

For Loop Bertingkat

Sekarang setelah Anda tahu for loop juga bisa ditumpuk, Anda mungkin bertanya-tanya mengapa dan kapan Anda akan menggunakannya dalam kode.

Misalnya, Anda ingin memanipulasi array dua dimensi dengan mengatur elemennya ke nilai tertentu.

Maka Anda bisa melakukan sesuatu seperti ini:

# Insert your own integer here
my_int <- 42

nr <- as.integer(my_int)

# Create a `n` x `n` matrix with zeros
mymat <- matrix(0, nr, nr)

# For each row and for each column, assign values based on position
# These values are the product of two indexes
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}

Tips: untuk informasi lebih lanjut tentang fungsi matrix(), kunjungi R Documentation.

# Show the first 10x10 chunk or the first `nr` x `nr` chunk
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]

Catatan bahwa untuk mencegah pengguna membanjiri layar dengan tabel berukuran besar, Anda menaruh kondisi di akhir untuk mencetak potongan 10 x 10 pertama, hanya jika pengguna meminta bilangan bulat lebih besar dari 10. Jika tidak, potongan n x n akan dicetak.

Kode lengkapnya terlihat seperti ini:

# Insert your own integer here
my_int <- 42

nr <- as.integer(my_int)

# Create a `n` x `n` matrix with zeroes
mymat <- matrix(0, nr, nr)

# For each row and for each column, assign values based on position
# These values are the product of two indexes
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}

# Show the first 10x10 chunk or the first `nr` x `nr` chunk
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]

For Loop: Populer tetapi Tidak Selalu Tepat untuk Kebutuhan Anda

Loop for sejauh ini yang paling populer, dan konstruksinya menyiratkan bahwa jumlah iterasi bersifat tetap dan diketahui sebelumnya, seperti pada kasus “hasilkan 200 bilangan prima pertama” atau “daftarkan 10 pelanggan paling penting”.

Tetapi bagaimana jika Anda tidak tahu atau tidak mengendalikan jumlah iterasi, dan satu atau beberapa kondisi dapat terjadi yang tidak dapat diprediksi sebelumnya?

Misalnya, Anda mungkin ingin menghitung jumlah klien yang tinggal di area dengan kode pos tertentu, atau jumlah klik pada banner laman web dalam dua hari terakhir, atau kejadian tak terduga serupa.

Dalam kasus seperti ini, loop while dan saudaranya repeat dapat menjadi penolong…

Hentikan Loop Anda dengan break

Saat interpreter R menemukan break, ia akan meneruskan kontrol ke instruksi tepat setelah akhir loop (jika ada). Dalam kasus loop bertingkat, break hanya memungkinkan untuk keluar dari loop yang paling dalam.

Berikut contohnya.

Potongan kode ini mendefinisikan matriks m x n berisi nol lalu masuk ke for loop bertingkat untuk mengisi lokasi matriks, tetapi hanya jika kedua indeks berbeda. Tujuannya adalah membuat matriks segitiga bawah, yaitu matriks yang elemennya di bawah diagonal utama tidak nol. Elemen lainnya dibiarkan seperti nilai nol awalnya.

Saat indeks sama dan dengan demikian kondisi di loop bagian dalam, yang berjalan pada indeks kolom j, terpenuhi, break dijalankan dan loop terdalam diinterupsi dengan lompatan langsung ke instruksi setelah loop dalam. Instruksi tersebut adalah instruksi print(). Kemudian, kontrol kembali ke kondisi for luar (atas baris, indeks i), yang dievaluasi lagi.

Jika indeks berbeda, penugasan dilakukan dan pencacah dinaikkan sebesar 1. Di akhir, program mencetak pencacah ctr, yang berisi jumlah elemen yang ditugaskan.

# Make a lower triangular matrix (zeroes in upper right corner)
m = 10
n = 10

# A counter to count the assignment
ctr = 0

# Create a 10 x 10 matrix with zeroes
mymat = matrix(0, m, n)

for (i in 1:m) {
    for (j in 1:n) {
        if (i == j) {
            break
        } else {
            # you assign the values only when i<>j
            mymat[i, j] = i * j
            ctr = ctr + 1
        }
    }
    print(i * j)
}

# Print how many matrix cells were assigned
print(ctr)

Catatan bahwa menaruh kurung kurawal bahkan saat tidak mutlak diperlukan mungkin terasa terlalu berhati-hati. Biasanya Anda lakukan untuk memastikan apa pun yang dibuka dengan {, juga ditutup dengan }. Jadi jika Anda melihat jumlah { atau } tidak cocok, Anda tahu ada error, meskipun sebaliknya tidak selalu benar!

Penggunaan next dalam Loop

next menghentikan suatu iterasi tertentu dan melompat ke siklus berikutnya. Faktanya, ia melompat ke evaluasi kondisi yang menaungi loop saat ini.

Di bahasa lain, Anda mungkin menemukan padanan (yang agak membingungkan) bernama “continue”, yang artinya sama: di mana pun Anda berada, setelah verifikasi kondisi, lompat ke evaluasi loop.

Contoh yang lebih sederhana untuk menjaga loop tetap berjalan sambil mengabaikan satu siklus tertentu saat kondisi terjadi adalah:

m = 20

for (k in 1:m) {
    if (!k %% 2)
        next
    print(k)
}

Kode ini mencetak semua bilangan ganjil dalam interval 1:m (di sini m=20). Dengan kata lain, semua bilangan bulat kecuali yang memiliki sisa bukan nol saat dibagi 2 (karena itu menggunakan operator modulus %%), seperti ditentukan oleh pengujian if, akan dicetak.

Bilangan yang sisanya nol tidak akan dicetak, karena program melompat ke evaluasi kondisi i in 1:m dan mengabaikan instruksi apa pun yang mungkin mengikuti. Dalam kasus ini, print(k) diabaikan.

Penjelasan Vektorisasi di R

Mengapa vektorisasi berjalan lebih cepat, padahal jumlah operasi elementer tampaknya sama?

Ini paling baik dijelaskan dengan melihat seluk-beluk internal R, yang memerlukan tulisan terpisah, tetapi secara ringkas: pertama-tama, R adalah bahasa terinterpretasi dan karenanya, semua detail tentang definisi variabel ditangani oleh interpreter. Anda tidak perlu menyebutkan bahwa sebuah angka adalah floating point atau mengalokasikan memori menggunakan pointer di memori, misalnya.

Interpreter R “memahami” hal-hal ini dari konteks saat Anda memasukkan perintah, tetapi ia melakukannya per perintah. Karena itu ia perlu menangani definisi semacam itu setiap kali Anda menjalankan sebuah perintah, bahkan jika Anda hanya mengulanginya.

Sebaliknya, sebuah kompiler menyelesaikan semua definisi dan deklarasi saat kompilasi atas keseluruhan kode; kode tersebut diterjemahkan menjadi kode biner yang ringkas dan teroptimasi, sebelum Anda mengeksekusi apa pun. Nah, karena fungsi R ditulis dalam salah satu bahasa level lebih rendah ini, fungsi-fungsi tersebut lebih efisien.

Dalam praktiknya, jika seseorang melihat kode level rendah, ia akan menemukan pemanggilan ke C atau C++, yang biasanya diimplementasikan dalam apa yang disebut kode pembungkus (wrapper).

Kedua, dalam bahasa yang mendukung vektorisasi (seperti R atau Matlab), setiap instruksi yang menggunakan data numerik bekerja pada objek yang secara native didefinisikan sebagai vektor, bahkan jika hanya terdiri dari satu elemen. Ini adalah default saat Anda mendefinisikan, misalnya, sebuah variabel numerik tunggal: representasi internalnya di R selalu berupa vektor, meskipun hanya berisi satu angka.

Loop tetap ada di balik layar, tetapi pada level C/C++ terkompilasi yang lebih rendah dan jauh lebih cepat. Keuntungan memiliki vektor berarti definisi diselesaikan oleh interpreter sekali saja, pada seluruh vektor, tanpa memandang ukurannya, berbeda dengan loop pada skalar, di mana definisi dan alokasi perlu dilakukan per elemen, dan ini lebih lambat.

Terakhir, bekerja dengan format vektor native memungkinkan pemanfaatan rutin Aljabar Linear yang sangat efisien (seperti BLAS atau Basic Linear Algebra Subprograms), sehingga saat menjalankan instruksi tervektorisasi, R memanfaatkan rutin numerik yang efisien ini. Jadi pesannya, jika memungkinkan, proseslah seluruh struktur data dalam satu pemanggilan fungsi untuk menghindari semua operasi penyalinan yang dijalankan.

Tapi cukup dengan pengantar, mari buat contoh umum vektorisasi, lalu di subbagian berikutnya, Anda akan menyelami fungsi-fungsi tervektorisasi R yang lebih spesifik dan populer untuk menggantikan loop.

Contoh Vektorisasi di R

Kembali ke gagasan “menumbuhkan data”, cara yang biasanya tidak efisien untuk “memperbarui” sebuah data frame.

Pertama, Anda membuat matriks m x n dengan replicate(m, rnorm(n)) dengan m=10 vektor kolom yang masing-masing memiliki n=10 elemen, dibentuk dengan rnorm(n), yang membuat angka acak berdistribusi normal.

Lalu Anda mengubahnya menjadi data frame (jadi 10 observasi dari 10 variabel) dan melakukan operasi aljabar pada setiap elemen menggunakan for loop bertingkat: pada tiap iterasi, sebuah fungsi sinus menambah setiap elemen yang dirujuk oleh dua indeks.

Contoh berikut memang agak artifisial, tetapi dapat mewakili penambahan sinyal ke beberapa noise acak:

# This is a bad loop with 'growing' data
set.seed(42)
m = 10
n = 10

# Create matrix of normal random numbers
mymat <- replicate(m, rnorm(n))

# Transform into data frame
mydframe <- data.frame(mymat)

for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
    print(mydframe)
  }
}

Di sini, sebagian besar waktu eksekusi terdiri dari penyalinan dan pengelolaan loop.

Mari lihat seperti apa solusi tervektorisasi:

set.seed(42)
m = 10
n = 10
mymat <- replicate(m, rnorm(n))
mydframe <- data.frame(mymat)
mydframe <- mydframe + 10 * sin(0.75 * pi)
mydframe

Ini terlihat lebih sederhana: baris terakhir menggantikan for loop bertingkat. Catatan penggunaan set.seed() untuk memastikan kedua implementasi memberikan hasil yang persis sama.

Sekarang mari kuantifikasi waktu eksekusi untuk kedua solusi.

Anda dapat melakukannya dengan menggunakan perintah sistem R, seperti system.time() yang dapat diberi potongan kode seperti ini:

Tips: cukup letakkan kode yang ingin Anda evaluasi di dalam tanda kurung fungsi system.time().

# Insert `system.time()` to measure loop execution
for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
  }
}

# Add `system.time()` to measure vectorized execution
mydframe <- mydframe + 10 * sin(0.75 * pi) 

Pada potongan kode di atas, Anda melakukan tugas memilih m dan n, pembuatan matriks dan transformasinya menjadi data frame hanya sekali di awal, lalu mengevaluasi potongan for melawan “satu baris” versi tervektorisasi dengan dua pemanggilan terpisah ke system.time().

Anda melihat bahwa bahkan dengan pengaturan minimal m=n=10 versi tervektorisasi 7 kali lebih cepat, meskipun untuk nilai serendah itu, perbedaannya nyaris tidak penting bagi pengguna.

Perbedaan menjadi nyata (pada skala manusia) jika Anda menaruh m=n=100, sementara peningkatan ke 1000 membuat for loop tampak menggantung selama beberapa puluh detik, sedangkan bentuk tervektorisasi masih berjalan sekejap mata.

Untuk m=n=10000 for loop menggantung lebih dari satu menit sementara bentuk tervektorisasi membutuhkan 2,54 detik. Tentu saja, ukuran ini sebaiknya disikapi ringan dan akan bergantung pada konfigurasi perangkat keras dan perangkat lunak, sebaiknya hindari membebani laptop Anda dengan puluhan tab browser terbuka dan beberapa aplikasi berjalan di latar belakang; tetapi ukuran ini ilustratif terhadap perbedaannya.

Secara adil, peningkatan m dan n juga sangat memengaruhi pembuatan matriks seperti yang dapat Anda lihat dengan mudah dengan menempatkan satu lagi pemanggilan system.time() di sekitar fungsi replikasi.

Anda dipersilakan untuk bereksperimen dengan m dan n guna melihat bagaimana waktu eksekusi berubah, dengan memplot waktu eksekusi sebagai fungsi dari produk m x n. Ini adalah indikator yang relevan, karena mengekspresikan dimensi matriks yang dibuat. Dengan demikian juga mengkuantifikasi jumlah iterasi yang diperlukan untuk menyelesaikan tugas melalui for loop yang nset-ed.

Jadi ini adalah contoh vektorisasi. Namun ada banyak lagi. Dalam R News, buletin untuk proyek R pada halaman 46, terdapat fungsi yang sangat efisien untuk menghitung jumlah dan rerata pada dimensi tertentu dalam array atau matriks, seperti: rowSums(), colSums(), rowMeans(), dan colMeans().

Selain itu, buletin juga menyebutkan bahwa “...fungsi dalam keluarga ‘apply’, bernama [s,l,m,t]apply, disediakan untuk menerapkan fungsi lain ke elemen/dimensi objek. Fungsi ‘apply’ ini menyediakan sintaks ringkas untuk tugas yang kadang cukup kompleks yang lebih mudah dibaca dan lebih cepat daripada loop yang ditulis kurang baik.”.