apply, lapply, sapply trong R: giải thích họ hàm apply

Họ hàm apply trong một câu

Mọi thành viên của họ hàm apply đều làm cùng một việc: nhận một hàm và chạy nó qua mọi phần tử của một cấu trúc nào đó, rồi gom kết quả lại. Điều khác nhau là hình dạng đầu vào và hình dạng đầu ra. Bản đồ như sau:

• apply(m, MARGIN, FUN): các hàng hoặc cột của một ma trận.
• lapply(x, FUN): từng phần tử của một list hoặc vector; luôn trả về list.
• sapply(x, FUN): giống lapply, rồi đơn giản hóa thành vector hoặc ma trận khi có thể.
• vapply(x, FUN, FUN.VALUE): sapply với kiểu trả về được khai báo và bắt buộc tuân theo.
• mapply(FUN, x, y, ...): duyệt song song nhiều đầu vào, từng phần tử một.
• tapply(values, groups, FUN): áp dụng FUN trong từng nhóm, mỗi nhóm một kết quả.

Tất cả đều nhận các hàm bạn tự viết, kể cả hàm ẩn danh, và đó là nơi sức mạnh của họ hàm này phát huy.

apply(): hàng và cột của ma trận

apply nhận một ma trận, một MARGIN (1 cho hàng, 2 cho cột) và một hàm:

m <- matrix(1:6, nrow = 2)
print(m)

print(apply(m, 1, sum))   # one sum per row
print(apply(m, 2, sum))   # one sum per column

Ma trận được điền theo từng cột, nên các hàng là 1 3 5 và 2 4 6: tổng theo hàng in ra 9 12 và tổng theo cột in ra 3 7 11. Với hai trường hợp phổ biến nhất, base R có sẵn các hàm chuyên dụng nhanh hơn là rowSums, colSums, rowMeans, colMeans, nên hãy để dành apply cho những hàm không có bản chuyên dụng, như apply(m, 2, max).

Một cái bẫy: apply trên data frame sẽ lặng lẽ chuyển nó thành ma trận trước, ép mọi cột về cùng một kiểu dữ liệu. Với data frame, hãy coi các cột như một list và dùng lapply/sapply.

lapply() luôn trả về list, sapply() thì đơn giản hóa

lapply ánh xạ một hàm qua từng phần tử và trả về một list cùng độ dài, trong mọi trường hợp:

scores <- list(math = c(80, 90), art = c(70, 75, 95))

print(lapply(scores, mean))
print(sapply(scores, mean))

Cùng phép tính, hai hình dạng: lapply trả về một list chứa 85 và 80; sapply nhận thấy mọi kết quả đều có độ dài 1 nên đơn giản hóa thành một vector số có tên, dễ đọc hơn nhiều và dễ đưa vào các phép tính tiếp theo.

Tuy vậy, sự tiện lợi này có một mặt sắc cạnh: kiểu trả về của sapply phụ thuộc vào dữ liệu. Chỉ cần một phần tử cho ra độ dài khác, việc đơn giản hóa thất bại và bạn lặng lẽ nhận lại một list:

uneven <- list(a = 1:2, b = 1:3)

result <- sapply(uneven, function(x) x * 10)
print(class(result))                          # could not simplify: still a list

print(sapply(1:3, function(x) x * 10))        # lengths match: a numeric vector

Khi làm việc tương tác thì chẳng sao; nhưng trong một script, điều đó có nghĩa là code chạy tốt cả năm trời sẽ hỏng vào ngày dữ liệu đổi hình dạng. Đó chính là lý do vapply tồn tại.

vapply(): sapply an toàn về kiểu

vapply thêm đối số thứ ba, FUN.VALUE: một khuôn mẫu khai báo một kết quả phải trông như thế nào. integer(1) nghĩa là "mỗi lần gọi trả về đúng một số nguyên":

words <- c("apply", "lapply", "sapply")

print(vapply(words, nchar, integer(1)))

Bạn nhận được một vector số nguyên có tên, 5 6 6, và quan trọng hơn là một sự đảm bảo: nếu nchar có lúc trả về hai giá trị hay một chuỗi ký tự, vapply sẽ dừng với một lỗi ngay tại chỗ gọi thay vì để kết quả sai hình dạng trôi xuống các bước sau. Phần khai báo còn kiêm luôn vai trò tài liệu:

vapply(words, nchar, character(1))
# Error in vapply(words, nchar, character(1)) : values must be type 'character'

Quy tắc kinh nghiệm: sapply ở console, vapply trong các hàm và script phải chạy mà không có người trông chừng.

mapply() và tapply(): đầu vào song song và theo nhóm

lapply duyệt qua một cấu trúc. Khi mỗi lần gọi cần một phần tử từ nhiều cấu trúc ở cùng vị trí, hãy dùng mapply; lưu ý hàm được đặt trước:

print(mapply(function(a, b) a * b, 1:4, c(10, 100, 1000, 10000)))

Mỗi phần tử đầu ra ghép các giá trị thứ nhất, rồi các giá trị thứ hai, cứ thế tiếp tục: 10 200 3000 40000.

tapply là thành viên làm việc theo nhóm: nó chia values theo groups và áp dụng hàm trong từng nhóm, trả về mỗi nhóm một kết quả:

values <- c(10, 20, 30, 40, 50, 60)
groups <- c("a", "b", "a", "b", "a", "b")

print(tapply(values, groups, mean))

Nhóm a có trung bình 30, nhóm b có trung bình 40. Đây là câu trả lời của base R cho bài toán "trung bình theo từng loại", cùng dạng câu hỏi mà group_by + summarize trả lời cho data frame. Nếu bạn đã làm việc với dplyr thì hãy dùng cách đó; tapply tỏa sáng khi bạn có hai vector trần và muốn giải quyết trong một dòng.

Có hai tiện ích dùng được cho cả họ hàm. Các đối số thêm sau hàm sẽ được chuyển tiếp cho hàm đó ở mỗi lần gọi:

readings <- list(c(3.14159, 2.71828), c(1.41421))

print(sapply(c(3.14159, 2.71828), round, digits = 2))
print(lapply(readings, round, digits = 1))

Và hàm ẩn danh có thể chen vào bất cứ khi nào không có hàm dựng sẵn nào phù hợp: sapply(x, \(v) max(v) - min(v)) tính khoảng biến thiên cho từng phần tử mà không cần đặt tên cho một hàm phụ trước.

Họ hàm apply và vòng lặp for

Bạn sẽ nghe nói rằng vòng lặp for trong R chậm còn họ hàm apply thì nhanh. Phần lớn đó là lầm tưởng. Thứ thực sự chậm là nối dài kết quả bên trong vòng lặp: result <- c(result, new_value) sao chép toàn bộ vector ở mỗi lần lặp. Một vòng lặp cấp phát trước đầu ra thì chạy tốt:

squares <- numeric(10)            # pre-allocate, then fill
for (i in 1:10) {
  squares[i] <- i^2
}
print(squares)

print(sapply(1:10, \(i) i^2))     # same result as an expression

Vậy nên hãy chọn theo độ dễ đọc, không phải hiệu năng. Phiên bản apply nói cái gì trong một dòng, "bình phương từng phần tử", và lo việc cấp phát giúp bạn, đó là lý do nó là cách viết chuẩn cho các thao tác đơn giản trên từng phần tử. Vòng lặp for phát huy giá trị khi các lần lặp phụ thuộc vào kết quả trước đó, khi bạn cần thoát sớm bằng break, hoặc khi thân vòng lặp đủ dài để một lambda gây hại nhiều hơn có lợi. Cả hai đều là R chính đáng.

Điều cần nhớ

• Cả họ hàm chỉ là một ý tưởng: chạy một hàm qua mọi phần tử, gom kết quả lại.
• apply dành cho các hàng (MARGIN = 1) và cột (MARGIN = 2) của ma trận; hãy ưu tiên rowSums/colMeans khi chúng có sẵn.
• lapply luôn trả về list; sapply đơn giản hóa khi có thể, nghĩa là kiểu trả về của nó có thể thay đổi theo dữ liệu.
• vapply khóa chặt kiểu trả về; hãy dùng nó trong code không được phép gây bất ngờ.
• mapply ghép nhiều đầu vào lại với nhau; tapply tổng hợp giá trị trong từng nhóm.
• Vòng lặp for vốn không chậm, việc nối dài vector mới chậm. Hãy chọn cách viết dễ đọc nhất.

Tiếp theo: pipe, toán tử nối các lời gọi này thành những pipeline dễ đọc, từng bước một.