Hướng dẫn về vòng lặp trong R - Cách dùng và lựa chọn thay thế

Giải thích vòng lặp For

Cấu trúc vòng lặp này, gồm hộp chữ nhật ‘init’ (khởi tạo), hình thoi quyết định, và hộp chữ nhật i1, được thực thi một số lần đã biết.

Trong ngôn ngữ lưu đồ, hộp chữ nhật có nghĩa là “thực hiện một việc không bao hàm quyết định”. Ngược lại, hình thoi là “biểu tượng quyết định” và thể hiện câu hỏi chỉ có hai câu trả lời logic: Đúng (T) hoặc Sai (F).

Lưu ý để đơn giản hóa, các ký hiệu khác có thể có đã được lược bỏ khỏi hình.

Một hoặc nhiều chỉ thị trong khung khởi tạo được theo sau bởi việc đánh giá điều kiện trên một biến có thể nhận giá trị trong một dãy xác định. Trên hình, điều này được biểu diễn bằng hình thoi: các ký hiệu nghĩa là “giá trị hiện tại của biến v có thuộc dãy seq không?”.

Nói cách khác, bạn đang kiểm tra liệu giá trị hiện tại của v có nằm trong một khoảng xác định hay không. Bạn thường xác định khoảng này trong phần khởi tạo, như 1:100 để bảo đảm vòng lặp bắt đầu.

Nếu điều kiện không thỏa và kết quả là False, vòng lặp sẽ không bao giờ chạy. Điều này được chỉ ra bởi mũi tên rời ở bên phải cấu trúc for. Chương trình sau đó sẽ thực thi chỉ thị đầu tiên sau khối vòng lặp.

Nếu điều kiện được xác nhận, một chỉ thị — hoặc khối chỉ thị — i1 sẽ được thực thi. Và có thể khối chỉ thị này lại là một vòng lặp khác. Trong trường hợp như vậy, ta gọi là vòng lặp lồng nhau.

Sau khi xong, điều kiện lại được đánh giá. Điều này được chỉ ra bằng các đường từ i1 quay lại phía trên, ngay sau hộp khởi tạo. Trong R — và trong Python — có thể diễn đạt điều này bằng tiếng Anh đơn giản, bằng cách hỏi biến của ta có thuộc một khoảng giá trị hay không.

Lưu ý rằng ở các ngôn ngữ khác, như C, điều kiện được làm rõ hơn với toán tử logic, như lớn hơn, nhỏ hơn, bằng, …

Dưới đây là một ví dụ for đơn giản:

# 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)

Khối for được đặt trong ngoặc nhọn. Chúng có thể đặt ngay sau điều kiện kiểm tra hoặc xuống dòng bên dưới, tốt nhất là có thụt lề. Không bắt buộc, nhưng ngoặc nhọn chắc chắn tăng tính dễ đọc và giúp dễ dàng phát hiện khối vòng lặp cùng lỗi tiềm ẩn trong đó.

Lưu ý rằng vector bình phương, usq, được khởi tạo. Điều này không cần thiết trong mã RStudio thuần, nhưng ở phiên bản markup, knitr sẽ không biên dịch do tham chiếu đến vector chưa tồn tại trước khi dùng trong vòng lặp, gây lỗi trong RStudio. Để biết thêm về knitr, vào trang R Markdown.

Lồng vòng lặp For

Giờ bạn biết for có thể được lồng nhau, hẳn bạn thắc mắc tại sao và khi nào nên dùng điều này trong mã.

Giả sử bạn muốn thao tác một mảng hai chiều bằng cách gán phần tử của nó thành các giá trị cụ thể.

Lúc đó bạn có thể làm như sau:

# 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
    }
}

Mẹo: để biết thêm về hàm matrix(), truy cập R Documentation.

Bạn có hai vòng lặp for lồng nhau trong đoạn mã trên và do đó có hai cặp ngoặc nhọn, mỗi cái có khối riêng và được điều khiển bởi chỉ số riêng. Tức là i chạy qua các dòng và j chạy qua các cột.

 

Đã tạo ra gì?

# 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]

Lưu ý để tránh làm ngập màn hình với các bảng khổng lồ, bạn đặt một điều kiện ở cuối để in ra khối 10 x 10 đầu tiên chỉ khi người dùng nhập số nguyên lớn hơn 10. Nếu không, sẽ in khối n x n.

Mã hoàn chỉnh như sau:

# 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]

Vòng lặp For: Phổ biến nhưng không phải lúc nào cũng hoàn hảo cho bạn

Vòng lặp for phổ biến nhất, và cấu trúc của nó ngụ ý số lần lặp là cố định và biết trước, như các trường hợp “tạo 200 số nguyên tố đầu tiên” hoặc “liệt kê 10 khách hàng quan trọng nhất”.

Nhưng nếu bạn không biết hoặc không kiểm soát được số lần lặp, và một hoặc vài điều kiện có thể xảy ra không thể dự đoán trước thì sao?

Ví dụ, bạn có thể muốn đếm số khách hàng sống trong khu vực được xác định bởi một mã bưu chính cụ thể, hoặc số lượt nhấp vào banner trên trang web trong hai ngày qua, hay các sự kiện tương tự khó lường.

Trong những trường hợp như vậy, vòng lặp while và “người anh em” repeat có thể ra tay cứu nguy…

Ngắt vòng lặp với break

Khi trình thông dịch R gặp break, nó sẽ chuyển điều khiển đến chỉ thị ngay sau cuối vòng lặp (nếu có). Trong trường hợp vòng lặp lồng nhau, break chỉ thoát khỏi vòng lặp trong cùng.

Ví dụ dưới đây.

Đoạn mã này định nghĩa một ma trận m x n các số 0 rồi vào một vòng lặp for lồng để điền các vị trí của ma trận, nhưng chỉ khi hai chỉ số khác nhau. Mục đích là tạo ma trận tam giác dưới, tức là ma trận có phần tử dưới đường chéo chính khác 0. Các phần còn lại giữ nguyên giá trị 0 ban đầu.

Khi các chỉ số bằng nhau và điều kiện trong vòng lặp trong (chạy theo chỉ số cột j) được thỏa, một break sẽ được thực thi và vòng lặp trong bị ngắt, nhảy trực tiếp đến chỉ thị sau vòng lặp trong. Chỉ thị này là một lệnh print(). Sau đó, điều khiển trở lại điều kiện for ngoài (theo hàng, chỉ số i), và điều kiện lại được đánh giá.

Nếu các chỉ số khác nhau, phép gán được thực hiện và bộ đếm tăng thêm 1. Cuối cùng, chương trình in bộ đếm ctr, chứa số phần tử đã được gán.

# 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)

Lưu ý rằng có thể hơi cẩn thận quá mức khi đặt ngoặc nhọn ngay cả khi không thật sự cần. Bạn thường làm vậy để chắc rằng bất kỳ thứ gì mở bằng { đều được đóng bằng }. Vì vậy nếu bạn thấy số { hoặc } không khớp, bạn biết là có lỗi, dù chiều ngược lại không nhất thiết đúng!

Cách dùng next trong vòng lặp

next ngắt quãng một lần lặp cụ thể và nhảy sang chu kỳ kế tiếp. Thực tế, nó nhảy đến bước đánh giá điều kiện của vòng lặp hiện tại.

Trong các ngôn ngữ khác, bạn có thể gặp tương đương là “continue” (dễ gây nhầm), nghĩa là: ở bất cứ đâu, khi điều kiện được xác nhận, hãy nhảy đến phần đánh giá vòng lặp.

Một ví dụ đơn giản về tiếp tục vòng lặp nhưng bỏ qua một chu kỳ khi điều kiện xảy ra là:

m = 20

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

Đoạn mã này in tất cả số lẻ trong khoảng 1:m (ở đây m=20). Nói cách khác, tất cả số nguyên trừ những số có phần dư khác 0 khi chia cho 2 (do dùng toán tử mô-đun %%), như chỉ định bởi kiểm tra if, sẽ được in.

Các số có phần dư bằng 0 sẽ không được in, vì chương trình nhảy đến đánh giá điều kiện i in 1:m và bỏ qua mọi chỉ thị theo sau. Trong trường hợp này, print(k) bị bỏ qua.

v1 <- c(3,4,5)
v2 <- c(3,4,6)
v3 <- c(0,0,0)
n = length(v1)

for (i in 1:n) {
    v3[i] <- v1[i] + v2[i]
}
v3

v3 = v1 + v2
v3

A <- matrix(1:6, nrow = 3, ncol = 2)
B <- matrix(c(2,4,3,1,5,7), nrow=3, ncol=2)

C= A + B
C

Giải thích vector hóa trong R

Tại sao vector hóa lại chạy nhanh hơn, khi số phép toán cơ bản dường như như nhau?

Điều này được giải thích tốt nhất bằng cách nhìn vào “ngóc ngách” nội bộ của R, vốn cần một bài riêng, nhưng tóm lược: trước hết, R là ngôn ngữ thông dịch, vì vậy mọi chi tiết về định nghĩa biến được trình thông dịch xử lý. Bạn không cần chỉ định một số là số thực dấu phẩy động hay cấp phát bộ nhớ bằng con trỏ, chẳng hạn.

Trình thông dịch R “hiểu” các vấn đề này từ ngữ cảnh khi bạn nhập lệnh, nhưng làm vậy theo từng lệnh. Do đó, nó phải xử lý các định nghĩa đó mỗi lần bạn ra lệnh, ngay cả khi bạn chỉ lặp lại lệnh đó.

Ngược lại, một trình biên dịch giải quyết mọi định nghĩa và khai báo tại thời điểm biên dịch trên toàn bộ mã; mã sau đó được dịch thành mã nhị phân gọn nhẹ và tối ưu trước khi bạn thực thi bất cứ điều gì. Nay, vì các hàm R được viết bằng một trong những ngôn ngữ cấp thấp này, chúng hiệu quả hơn.

Thực tế, nếu nhìn vào mã cấp thấp, bạn sẽ thấy các lời gọi đến C hoặc C++, thường được triển khai trong cái gọi là mã bao (wrapper).

Thứ hai, trong các ngôn ngữ hỗ trợ vector hóa (như R hoặc Matlab), mọi lệnh dùng dữ liệu số đều hoạt động trên một đối tượng vốn được định nghĩa nguyên bản là vector, ngay cả khi chỉ gồm một phần tử. Đây là mặc định khi bạn định nghĩa, ví dụ, một biến số đơn: biểu diễn bên trong của nó trong R luôn là một vector, dù chỉ có một số.

Các vòng lặp vẫn tồn tại “dưới nắp capo”, nhưng ở mức C/C++ biên dịch thấp và nhanh hơn nhiều. Lợi thế của việc có một vector là các định nghĩa được trình thông dịch giải quyết chỉ một lần, trên toàn bộ vector, bất kể kích thước, trái với vòng lặp trên vô hướng, nơi định nghĩa và cấp phát phải làm theo từng phần tử — và điều này chậm hơn.

Cuối cùng, làm việc với định dạng vector nguyên bản cho phép tận dụng các thư viện Đại số tuyến tính rất hiệu quả (như BLAS), nên khi thực thi các lệnh vector hóa, R dựa trên các thủ tục số hiệu quả này. Vậy thông điệp là, nếu có thể, hãy xử lý toàn bộ cấu trúc dữ liệu trong một lời gọi hàm duy nhất để tránh mọi thao tác sao chép.

Nhưng tạm dừng phần lan man, hãy làm một ví dụ tổng quát về vector hóa, rồi ở tiểu mục tiếp theo, bạn sẽ đi sâu vào các hàm vector hóa cụ thể và phổ biến trong R để thay thế vòng lặp.

Ví dụ về vector hóa trong R

Quay lại khái niệm “tăng dần dữ liệu”, một cách điển hình là kém hiệu quả để “cập nhật” data frame.

Đầu tiên, bạn tạo một ma trận m x n với replicate(m, rnorm(n)) cùng m=10 vector cột có n=10 phần tử mỗi vector, được tạo bằng rnorm(n) tạo số chuẩn ngẫu nhiên.

Sau đó bạn chuyển thành data frame (tức 10 quan sát của 10 biến) và thực hiện phép toán đại số trên từng phần tử bằng một vòng lặp for lồng: ở mỗi lần lặp, một hàm hình sin tăng thêm vào mỗi phần tử được tham chiếu bởi hai chỉ số.

Ví dụ sau hơi nhân tạo, nhưng có thể đại diện cho việc thêm một tín hiệu vào nhiễu ngẫu nhiên:

# 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)
  }
}

Ở đây, phần lớn thời gian thực thi là sao chép và quản lý vòng lặp.

Hãy xem giải pháp vector hóa trông như thế nào:

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

Trông đơn giản hơn: dòng cuối thay thế vòng lặp for lồng. Lưu ý việc dùng set.seed() để đảm bảo hai cách triển khai cho kết quả y hệt.

Giờ hãy định lượng thời gian thực thi cho hai giải pháp.

Bạn có thể làm điều này bằng cách dùng các lệnh hệ thống của R như system.time(), cho phép truyền vào một đoạn mã như sau:

Mẹo: chỉ cần đặt đoạn mã bạn muốn đo vào trong dấu ngoặc của hàm 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) 

Trong đoạn mã trên, bạn chỉ thực hiện việc chọn m và n, tạo ma trận và chuyển thành data frame một lần ở đầu, rồi đánh giá khối for so với “một dòng” của phiên bản vector hóa bằng hai lần gọi system.time() riêng biệt.

Bạn sẽ thấy ngay cả với thiết lập tối thiểu m=n=10 phiên bản vector hóa đã nhanh hơn 7 lần, dù với giá trị thấp như vậy, điều này hầu như không quan trọng với người dùng.

Sự khác biệt trở nên đáng chú ý (ở thang đo con người) nếu đặt m=n=100, trong khi tăng lên 1000 khiến vòng lặp for có vẻ “treo” hàng chục giây, còn dạng vector hóa vẫn chạy trong chớp mắt.

Với m=n=10000 vòng lặp for treo hơn một phút trong khi dạng vector hóa mất 2,54 giây. Tất nhiên, các phép đo này chỉ mang tính minh họa và tùy thuộc cấu hình phần cứng/phần mềm, tránh việc máy tính bị quá tải bởi hàng chục tab trình duyệt và nhiều ứng dụng chạy nền; nhưng chúng cho thấy sự khác biệt.

Công bằng mà nói, tăng m và n cũng ảnh hưởng mạnh đến việc tạo ma trận như bạn có thể thấy bằng cách đặt thêm một lần gọi system.time() quanh hàm replicate.

Hãy thử thay đổi m và n để xem thời gian thực thi thay đổi thế nào, bằng cách vẽ thời gian theo tích m x n. Đây là chỉ báo phù hợp, vì nó biểu diễn kích thước ma trận được tạo, cũng như định lượng số lần lặp cần thiết để hoàn thành tác vụ thông qua vòng lặp for lồng.

Đó là một ví dụ về vector hóa. Nhưng còn nhiều ví dụ khác. Trong R News, bản tin của dự án R ở trang 46, có các hàm rất hiệu quả để tính tổng và trung bình theo chiều của mảng hay ma trận, như: rowSums(), colSums(), rowMeans() và colMeans().

Hơn nữa, bản tin cũng nhắc rằng “... các hàm trong họ ‘apply’, tên là [s,l,m,t]apply, được cung cấp để áp dụng một hàm khác lên các phần/tầng của đối tượng. Các hàm ‘apply’ này cung cấp cú pháp gọn gàng cho những tác vụ đôi khi khá phức tạp, dễ đọc hơn và nhanh hơn so với các vòng lặp viết kém.”