Tự động hóa các tác vụ phổ biến là yếu tố then chốt để phân tích dữ liệu hiệu quả. Nó không chỉ giúp bạn tiết kiệm rất nhiều thời gian khỏi việc lặp đi lặp lại cùng một chuỗi thao tác, mà còn giảm thiểu lỗi bằng cách hạn chế những gì bạn phải thực hiện thủ công.
Trong bài viết này, chúng ta sẽ cùng nhau tự động hóa một tác vụ đơn giản: chuẩn hóa một biến số. Chuẩn hóa ở đây có nghĩa là trừ đi giá trị trung bình của biến số đó và chia cho độ lệch chuẩn của nó. Điều quan trọng không phải là tác vụ cụ thể chúng ta tự động hóa, mà là việc làm quen với cách thức tự động hóa các tác vụ.
Cần lưu ý rằng đã có những lệnh do cộng đồng phát triển để thực hiện việc này và với độ linh hoạt cao hơn nhiều so với phương pháp chúng ta sẽ thực hiện. Bạn có thể gõ `search normalize variable` trong Stata để tìm hiểu thêm. Ngoài ra, bạn cũng có thể chuẩn hóa một biến số bằng lệnh `egen` của Stata. Tuy nhiên, mục tiêu của chúng ta là đi xa hơn thế, xây dựng hiểu biết sâu sắc về tự động hóa. Tôi giả định độc giả mới làm quen với việc tự động hóa tác vụ trong Stata.
Viết Mã Lệnh Trực Tiếp (Scripting)
Đầu tiên, chúng ta sẽ thực hiện việc chuẩn hóa trực tiếp trong mã lệnh phân tích của mình. Trong Stata, các mã lệnh phân tích được gọi là do-file vì chúng "làm" một điều gì đó.
Hãy chuẩn hóa biến `x`. Tôi không thích thay đổi nội dung của các biến hiện có, vì vậy tôi sẽ tạo một biến mới là `xN`, trong đó hậu tố N chỉ ra rằng biến đã được chuẩn hóa. Nếu bạn không thích hậu tố N, hãy sử dụng một cái gì đó khác, có thể là `_norm`. Hoặc dùng tiền tố. Lệnh `summarize` của Stata sẽ cung cấp cho chúng ta giá trị trung bình và độ lệch chuẩn.
1summarize x
2generate xN = (x - r(mean)) / r(sd)Chỉ mất hai dòng để chuẩn hóa một biến số.
`r(mean)` và `r(sd)` là gì, và làm sao tôi biết về chúng? Trong Stata, hầu hết các lệnh đều trả về kết quả. Các lệnh ước lượng trả về kết quả dưới dạng giá trị `e()`, và hầu hết các lệnh khác trả về kết quả dưới dạng giá trị `r()`. Tôi đã biết tên `r(mean)` và `r(sd)` bằng cách gõ `help summarize` và cuộn xuống cuối file trợ giúp. Ở đó, tôi tìm thấy tất cả các kết quả được trả về bởi `summarize` và mô tả của chúng. Tôi cũng có thể chỉ cần gõ `return list` sau lệnh `summarize`. Lệnh này sẽ hiển thị cho chúng ta từng kết quả trả về và giá trị của nó.
Thao tác đơn giản chỉ gồm hai dòng. Tại sao chúng ta phải tự động hóa nó? Ngay cả trong hai dòng đó, vẫn có rất nhiều chỗ cho lỗi. Nếu bạn sao chép khối mã lệnh để chuẩn hóa một biến khác, hoặc giả sử bạn sao chép nó 100 lần để chuẩn hóa 100 biến khác, hãy cẩn thận rằng bạn phải thay đổi `x` thành tên biến mới của mình ở mọi nơi cần thiết. Quên thay đổi nó trong `summarize`, và biến mới của bạn, ví dụ `y`, sẽ được chuẩn hóa bởi giá trị trung bình và độ lệch chuẩn của `x`. Quên thay đổi nó trong `xN`, và bạn sẽ nhận được thông báo lỗi. Quên thay đổi nó trong biểu thức cho `xN`, và biến mới của bạn sẽ là `x` được chuẩn hóa bởi giá trị trung bình và độ lệch chuẩn của `y`. Tôi đã từng mắc tất cả những lỗi này.
Tự Động Hóa Với Do-file
Hãy đặt mã lệnh của chúng ta vào một do-file riêng.
Chuẩn Hóa Biến Số Đầu Tiên
1version 15.1
2summarize x
3generate xN = (x - r(mean)) / r(sd)Tôi đã thêm một thứ: lệnh `version` ở đầu. Luôn luôn, luôn luôn thêm thông tin phiên bản vào do-file của bạn. Tôi đang chạy Stata 15.1, vì vậy đó là những gì tôi đã đặt ở đầu. Nếu tôi làm vậy, mã lệnh này sẽ luôn hoạt động theo cách nó đang hoạt động hôm nay, ngay cả khi một phiên bản Stata tương lai, ví dụ Stata 42, loại bỏ lệnh `summarize` hoặc thay đổi hoàn toàn cách nó hoạt động.
Chúng ta chạy mã lệnh mới bằng cách gõ:
1do normalizehoặc bằng cách đặt `do normalize` vào một do-file phân tích khác.
do-file `normalize.do` hiện tại của chúng ta chưa thực sự thú vị. Chúng ta cần nó hoạt động trên các biến khác ngoài `x`.
Đưa Đối Số Vào Do-file
Đây là một phiên bản làm được điều đó:
1version 15.1
2summarize `1'
3generate `1'N = (`1' - r(mean)) / r(sd)Sau đó chúng ta gõ:
1do normalize yĐiều gì đã thay đổi từ phiên bản (1) sang (2)? Tất cả những gì chúng ta làm là thay thế mọi sự xuất hiện của `x` bằng ` `1' `. Tại sao lại là ` `1' `? Các do-file của Stata phân tích các đối số của chúng thành các local macro được đánh số 1, 2, 3, v.v. Đối số đầu tiên đi vào local macro 1, đối số thứ hai vào 2, v.v. Một local macro chỉ là một tên giữ một giá trị. Vâng, 1 có thể là tên của một local macro. Tại sao chúng ta lại đặt 1 giữa một dấu backtick trái và một dấu tick phải? Nếu chúng ta chỉ gõ 1, đó sẽ là số 1. Chúng ta cần giá trị trong 1, vì vậy chúng ta "lấy giá trị của nó". Vì chúng ta đã gõ `do normalize y`, đối số đầu tiên (và duy nhất) của chúng ta là `y`, vì vậy ` `1' ` sẽ mở rộng thành `y`.
Khi bạn thay thế `y` cho ` `1' ` trong phiên bản thứ hai của `normalize.do`, nó sẽ trở thành phiên bản đầu tiên. Đó chính xác là những gì Stata thực hiện.
Với do-file `normalize.do` mới của chúng ta, chúng ta có thể vui vẻ gõ:
1do normalize myvariable
2do normalize myothervariable
3do normalize x1
4do normalize x2
5...
6do normalize x100Tôi ít có khả năng mắc lỗi hơn rất nhiều.
Vẫn còn rất nhiều thao tác gõ thừa. Chúng ta sẽ quay lại vấn đề đó sau.
Bây giờ tôi muốn hỏi, chúng ta có thể làm cho do-file này tuân thủ `if qualifier` của Stata không? Câu trả lời chắc chắn là "có", và rất dễ dàng. Nếu không, tôi đã không hỏi.
Tại sao chúng ta muốn `if qualifier`? Chúng ta có thể muốn gõ:
1do normalize income if male == 0và giới hạn việc chuẩn hóa của chúng ta cho các nữ trong mẫu. Đó là những gì `if male == 0` nói.
Hỗ Trợ Điều Kiện If Và In
Đây là một do-file hỗ trợ cả `if qualifier` và `in qualifier`.
1version 15.1
2syntax varlist(min=1 max=1) [if] [in]
3summarize `varlist' `if' `in'
4generate `varlist'N = (`varlist' - r(mean)) / r(sd) `if' `in'Khi nhìn vào hai dòng mã lệnh cuối cùng, những dòng đã được điều chỉnh từ do-file trước đó của chúng ta, chúng ta thấy hai thay đổi— ` `1' ` đã được thay thế khắp nơi bằng ` `varlist' `, và cả hai lệnh đã có thêm ` `if' ` `in' ` vào cuối lệnh. Vì chúng ta đã tuyên bố do-file của mình hiện hỗ trợ trực tiếp các `if` và `in qualifier`, lệnh `syntax` mới đó dường như đang thực hiện rất nhiều điều kỳ diệu, và thực sự là vậy.
Lệnh `syntax` phân tích cú pháp các lệnh trông giống như các lệnh Stata tiêu chuẩn. Có nghĩa là các lệnh có danh sách biến (`varlist`), một `if qualifier` tùy chọn, một `in qualifier` tùy chọn, và các tùy chọn (option). Chúng ta chưa có bất kỳ tùy chọn nào, nhưng chúng ta có tất cả những thứ khác. Tôi đang đơn giản hóa ở đây; `syntax` có thể làm được nhiều hơn thế.
Điều thực sự thú vị về lệnh `syntax` là bạn về cơ bản gõ những gì lệnh của bạn trông như thế nào, và `syntax` sẽ phân tích dòng lệnh, điền vào các local macro với các phần liên quan của cú pháp bạn đã chỉ định. Nó cũng đưa ra các thông báo lỗi khi những gì được gõ không khớp với cú pháp bạn đã chỉ định. Đó là lý do tại sao chúng ta đã phải thêm `(min=1 max=1)` vào `varlist` trong lệnh `syntax` của chúng ta. Chúng ta có thể chỉ gõ `varlist`, nhưng sau đó `syntax` sẽ cho phép nhiều hơn một biến được chỉ định. Và điều đó sẽ không hoạt động trên lệnh `generate` của chúng ta. Chúng ta chỉ muốn một biến. Các `if` và `in qualifier` là tùy chọn, và đó là lý do tại sao chúng xuất hiện trong dấu ngoặc vuông trong lệnh `syntax`. Nếu chúng ta đã gõ `if in` thay vì `[if] [in]`, các `if` và `in qualifier` sẽ là bắt buộc. Yêu cầu cả hai sẽ rất hiếm, nhưng tôi đã từng yêu cầu `if qualifier` là bắt buộc trên một số lệnh.
Có một vấn đề với hai do-file đầu tiên của chúng ta mà tôi đã bỏ qua. Tôi chưa bao giờ kiểm tra rằng ` `1' ` là một tên biến đầy đủ. Stata cho phép các tên biến viết tắt. Nếu bạn có một biến `foreign` và không có biến nào khác được viết tắt thành `for`, thì việc gõ:
1do normalize forsẽ tạo ra biến mới `forN`, chứ không phải `foreignN`. Bạn có thể ổn với điều đó; bạn cũng có thể không. Dù sao đi nữa, bạn sẽ phải cẩn thận. Có những cách để khắc phục điều đó trong các phiên bản trước của chúng ta, nhưng chúng ta sẽ không bận tâm.
Phiên bản hiện tại của chúng ta không có vấn đề đó. Ngay cả khi `for` được gõ trên dòng lệnh, ` `varlist' ` sẽ mở rộng thành tên biến đầy đủ `foreign`. Đó là một phần của sự kỳ diệu của `syntax`.
Chuẩn Hóa Nhiều Biến Cùng Lúc
Bây giờ, quay lại với việc gõ thừa thãi đó. Điều gì sẽ xảy ra nếu chúng ta muốn chuẩn hóa một loạt biến một cách đồng loạt? Điều đó cũng khá dễ dàng, nhưng cuối cùng chúng ta phải thêm vào hai dòng mã tính toán của mình.
Đây là một do-file nhận một danh sách các biến và chuẩn hóa từng biến đồng thời tuân thủ `if` và `in`.
1version 15.1
2syntax varlist [if] [in]
3foreach var in `varlist' {
4 summarize `var' `if' `in'
5 generate `var'N = (`var' - r(mean)) / r(sd) `if' `in'
6}Bắt đầu từ trên xuống. Chúng ta đã loại bỏ `(min=1 max=1)` khỏi lệnh `syntax` vì bây giờ chúng ta muốn chấp nhận một danh sách biến (`varlist`).
Lệnh `foreach` là mới nhưng dễ hiểu. Đối với mỗi biến trong danh sách biến, chạy hai lệnh mà chúng ta đã chạy từ trước đến nay. ` `varlist' ` mở rộng thành danh sách các biến được chỉ định cho do-file của chúng ta. `var` chỉ là một tên để giữ một tên biến duy nhất khi chúng ta lặp qua chúng từng cái một. Chúng ta có thể sử dụng `variable`, hoặc chỉ `v`, hoặc thậm chí `z`, điều đó không quan trọng.
Trong các lệnh `summarize` của chúng ta, bây giờ chúng ta sử dụng ` `var' `, vì vậy chúng ta đang truy cập một biến duy nhất.
Vậy là xong.
Bây giờ chúng ta có thể gõ những thứ như:
1do normalize x1 x2 x3 if male==0hoặc:
1do normalize x*`normalize.do` bây giờ sẽ nhận các danh sách biến (`varlist`) hợp lệ của Stata.
Tạo Lệnh Mới Trong Stata
Quá trình tự động hóa nhỏ của chúng ta đã dẫn đến một thứ khá linh hoạt và hữu ích. Có lẽ quá hữu ích để giữ nó như một do-file. Có lẽ chúng ta nên biến nó thành một lệnh Stata mới mà chúng ta có thể sử dụng trong bất kỳ dự án nào của mình hoặc thậm chí chia sẻ với đồng nghiệp.
Một lần nữa, nếu điều đó khó, tôi đã không đặt ra khả năng này.
Chúng ta sẽ tạo một ado-file, một do-file tự động. Một chương trình được định nghĩa trong một ado-file hoạt động như một lệnh mới trong Stata. Nó được tự động tìm thấy và chạy.
Không cần thêm dài dòng, đây là nó:
Chuyển Đổi Thành Lệnh `normalize.ado`
1program normalize
2 version 15.1
3 syntax varlist [if] [in]
4 foreach var in `varlist' {
5 summarize `var' `if' `in'
6 generate `var'N = (`var' - r(mean)) / r(sd) `if' `in'
7 }end
Chúng ta đã làm gì? Chúng ta đã thụt lề mã lệnh từ phiên bản (4) của do-file của mình, nhưng đó chỉ là để đẹp mắt. Chúng ta đã thêm `program normalize` ở đầu file. Chúng ta đã thêm `end` ở cuối file. Hai điều sau cùng này nói rằng hãy coi đây là một lệnh, vì vậy chúng ta không cần phải gõ `do` trước nó.
Với nguy cơ lặp lại, chỉ có thế thôi.
Bây giờ chúng ta có một chương trình sẽ tự động được tìm thấy và chạy bất cứ khi nào chúng ta gõ `normalize`.
Chúng ta có thể gõ:
1normalize x1 x2 x3 if male==0hoặc:
1normalize x*Chúng ta có thể đưa file `normalize.ado` cho đồng nghiệp, và nó cũng sẽ hoạt động cho họ.
Bây giờ hãy ra ngoài và tự động hóa một số tác vụ của riêng bạn.
Một Vài Ghi Chú Quan Trọng
Tôi nói rằng `normalize.ado` sẽ tự động có sẵn. Nó sẽ như vậy, nếu bạn đặt nó ở nơi có thể tìm thấy. Nếu nó nằm trong thư mục làm việc hiện tại của bạn, nó có thể được tìm thấy. Nhưng bạn có thể không muốn đặt nó vào mỗi thư mục làm việc. Và nếu bạn cải thiện nó thì sao? Khi đó bạn phải thay đổi nó ở nhiều nơi. Thay vào đó, trong Stata, gõ:
1adopathMột trong các thư mục trên đường dẫn đó sẽ được dán nhãn `(PERSONAL)`. Sao chép `normalize.ado` vào đó. Nó bây giờ sẽ được tìm thấy trong tất cả các dự án của bạn, bất kể bạn đang làm việc trong thư mục nào.
Nếu bạn đưa `normalize.ado` cho đồng nghiệp, hãy bảo họ sao chép nó vào thư mục `(PERSONAL)` của họ.
Tôi không phải lúc nào cũng tự động hóa đến mức này. Tôi thấy hữu ích khi dừng lại ở các phiên bản (1), (2), (3) hoặc (4) của do-file của chúng ta. Hoặc đi xa hơn đến một lệnh mới.
Ngoài ra, không phải ngẫu nhiên mà chúng ta gọi chương trình là `program normalize` và đặt nó vào file `normalize.ado`. Tên của chương trình và tên của file phải giống nhau.
Một chi tiết nữa. do-file của bạn được tải lại từ file `normalize.do` mỗi khi bạn gõ `do normalize …`. Chương trình ado-file của bạn vẫn nằm trong bộ nhớ của Stata sau khi bạn gõ `normalize …`. Lần tới khi bạn gõ `normalize`, Stata chạy chương trình từ bộ nhớ mà không đọc lại file `normalize.ado`. Tuyệt vời, điều đó nhanh hơn. Nhưng … nếu bạn đang gỡ lỗi chương trình của mình và chỉnh sửa file, các thay đổi của bạn sẽ không được tải lại. Bạn cần gõ `discard` trước khi gõ `normalize …`. Bằng cách đó, chương trình của bạn sẽ bị loại bỏ khỏi bộ nhớ và sẽ được tải lại từ file của bạn.
Có những cách dễ dàng để chia sẻ các lệnh mới của bạn với toàn bộ cộng đồng Stata.
Thêm Tùy Chọn Tùy Chỉnh
Bạn có thể không thích việc tự động gắn thêm một chữ N vào cuối tên biến gốc của mình để chỉ định biến đã được chuẩn hóa. Có thể bạn muốn sử dụng một chữ cái khác, hoặc một tập hợp các ký tự, ví dụ `_norm`. Hoặc bạn có thể thích tiền tố hơn hậu tố. Thậm chí, bạn có thể muốn cả hai.
Chúng ta có thể đáp ứng điều đó.
1program normalize
2 version 15.1
3 syntax varlist [if] [in] [ , prefix(name) suffix(name) ]
4 foreach var in `varlist' {
5 summarize `var' `if' `in'
6 generate `prefix'`var'`suffix' = (`var' - r(mean)) / r(sd) `if' `in'
7 }end
Từ phiên bản (a) sang phiên bản (b), tất cả những gì chúng ta làm là thay đổi:
1syntax varlist [if] [in]thành:
1syntax varlist [if] [in] [, prefix(name) suffix(name)]và thay đổi:
1generate `var'N = ...thành:
1generate `prefix'`var'`suffix' = ...Hãy hiểu các thay đổi đối với dòng `syntax`.
Dấu ngoặc vuông một lần nữa có nghĩa là tùy chọn; người dùng không cần phải gõ bất cứ điều gì ở đây.
Nếu họ gõ bất cứ điều gì, trước tiên họ phải gõ một dấu phẩy `,`. Sau đó họ có thể gõ `prefix( pstuff )` hoặc `suffix( sstuff )`, hoặc cả hai. Nếu họ gõ `prefix( pstuff )`, thì local macro `prefix` sẽ chứa bất cứ điều gì họ gõ trong dấu ngoặc đơn—`pstuff`. Local macro `suffix` sẽ chứa bất cứ điều gì người dùng gõ trong dấu ngoặc đơn của tùy chọn `suffix`.
Chúng ta đã cẩn thận khi viết lệnh `syntax` của mình. Bởi vì chúng ta đã viết `(name)` chứ không phải `(string)`, người dùng không thể gõ bất cứ thứ gì trong dấu ngoặc đơn. Bất cứ điều gì họ gõ phải là một tên biến Stata hợp lệ. Chúng ta dự định sử dụng những gì được gõ làm tiền tố hoặc hậu tố cho tên biến, vì vậy chuỗi đó bản thân nó không được chứa bất cứ thứ gì không hợp lệ trong một tên biến.
Bây giờ, điều này có nghĩa là gì:
1generate `prefix'`var'`suffix' = ...Các macro ` `prefix' ` và ` `suffix' ` chỉ đơn giản được mở rộng thành bất cứ điều gì người dùng đã gõ trong các tùy chọn `prefix` và `suffix`. Biến mới của chúng ta sẽ có tiền tố và hậu tố mà người dùng đã gõ.
Với ado-file mới của chúng ta, bây giờ chúng ta có thể gõ những thứ như:
1normalize x1 x2 x3 x4 , prefix(norm_of_)
2normalize x* , prefix(norm_of_)Dòng đầu tiên tạo ra bốn biến mới: `norm_of_x1`, `norm_of_x2`, `norm_of_x3`, `norm_of_x4`. Tôi không thích những tên đó lắm, nhưng khá rõ ràng chúng có nghĩa là gì. Đôi khi, những biến này được gọi là biến đã chuẩn hóa, vì vậy bạn có thể thích `prefix(std_)`.
Trong dòng thứ hai, `x*` khớp với tất cả các biến bắt đầu bằng `x`. Mỗi biến trong số đó sẽ được chuẩn hóa và một biến mới được tạo ra với tiền tố `norm_of_` được chỉ định.
Bạn có thể đã nhận thấy một lỗi tiềm ẩn. Nếu người dùng không gõ tùy chọn `prefix()` cũng như `suffix()`, thì cả ` `prefix' ` và ` `suffix' ` sẽ trống. Lệnh `generate` của chúng ta sẽ cố gắng tạo một biến có cùng tên với biến gốc. Và điều đó … là một lỗi cú pháp.
Một cách để tránh lỗi đó là mặc định hành vi ban đầu của chúng ta là thêm hậu tố "N" vào biến mới. Chúng ta làm điều đó bằng cách thêm ba dòng sau ngay dưới dòng `syntax` của chúng ta:
1if "`prefix'`suffix'" == "" {
2 local suffix "N"
3}Chúng chỉ đơn giản nói rằng, nếu cả tiền tố và hậu tố (` `prefix'`suffix' `) đều trống, thì gán "N" cho hậu tố.
Một cải tiến nhỏ khác nữa là thêm một nhãn cho biến mới của chúng ta. Đây là một khả năng:
1label variable `prefix'`var'`suffix' "`var' normalized"Chúng ta sẽ thêm dòng này ngay sau lệnh `generate`. Bên trong vòng lặp `for`.
Và đó là cách các chương trình trở nên dài hơn. Bạn cải thiện chúng và bạn thêm các tính năng. Tiếp tục làm điều này, và bạn sẽ sớm viết các khối mã lệnh khiến đồng nghiệp của bạn phải e dè.
✨ **Giá trị đắt giá** ✨
Thông qua hành trình xây dựng lệnh chuẩn hóa biến số trong Stata, chúng ta đã biến một tác vụ lặp đi lặp lại thành một công cụ mạnh mẽ, linh hoạt và dễ sử dụng. Từ việc hiểu cách các do-file hoạt động, sử dụng các đối số, tận dụng lệnh `syntax` để phân tích cú pháp, đến việc tạo ra các lệnh `ado-file` tùy chỉnh có khả năng mở rộng với các tùy chọn đa dạng. Quá trình này không chỉ giúp bạn tối ưu hóa quy trình làm việc mà còn trang bị cho bạn kỹ năng tư duy lập trình và khả năng chia sẻ giải pháp với cộng đồng khoa học dữ liệu.
Câu hỏi tư duy hoặc bài tập ứng dụng
1. Lệnh `normalize.ado` hiện tại mặc định sử dụng hậu tố "N" nếu không có `prefix` hoặc `suffix` nào được chỉ định. Hãy điều chỉnh lệnh này để người dùng có thể tùy chọn tắt hoàn toàn việc thêm tiền tố/hậu tố nếu họ muốn (ví dụ: `normalize x, noautosuffix`). Gợi ý: bạn có thể thêm một `option` mới vào lệnh `syntax`.
2. Viết một `ado-file` mới để thực hiện việc chuyển đổi một biến số thành biến nhị phân (binary variable) dựa trên một ngưỡng giá trị (ví dụ: biến mới bằng 1 nếu biến gốc lớn hơn ngưỡng, và 0 nếu ngược lại). Hãy đảm bảo lệnh của bạn hỗ trợ `varlist`, `if qualifier`, `in qualifier` và có thể tùy chỉnh tên biến nhị phân mới (sử dụng tiền tố hoặc hậu tố).
