Mô hình Ensemble: Học máy với R

Bạn từng muốn xây dựng một ensemble học máy nhưng không biết bắt đầu từ đâu? Hướng dẫn này sẽ giúp bạn làm quen với SuperLearner. Gói R này cung cấp cách đơn giản để tạo các ensemble học máy bằng các hàm cấp cao, thông qua một wrapper tiêu chuẩn hóa để huấn luyện ensemble với những thư viện học máy R phổ biến như glmnet, knn, randomForest và nhiều thư viện khác!

Trong hướng dẫn này, bạn sẽ tìm hiểu các chủ đề sau:

Ensemble là gì? Đi qua định nghĩa ngắn gọn về ensemble trước khi bắt tay vào ví dụ thực hành mà hướng dẫn này cung cấp!
Vì sao dùng SuperLearner và gói này thực sự làm gì?
Học Ensemble trong R với SuperLearner: ở phần này, bạn sẽ học cách cài đặt các gói cần thiết, chuẩn bị dữ liệu và tạo mô hình ensemble đầu tiên! Bạn cũng sẽ thấy cách huấn luyện mô hình và thực hiện dự đoán. Qua đó, bạn sẽ đi qua Kernel Support Vector Machines, Bayes Generalized Linear Models và Bagging. Cuối cùng, bạn sẽ thấy cách tinh chỉnh siêu tham số để cải thiện hiệu năng mô hình!

Khi hoàn thành, bạn sẽ huấn luyện xong ensemble đầu tiên, dự đoán dữ liệu mới và tinh chỉnh một số thành phần của ensemble.

Ensemble là gì?

Tất cả điều này thật tuyệt, nhưng chính xác ensemble là gì?

Một ensemble xuất hiện khi các dự đoán xác suất hoặc dự đoán số của nhiều mô hình máy học được kết hợp bằng cách lấy trung bình, gán trọng số cho từng mô hình rồi cộng lại, hoặc sử dụng quan sát phổ biến nhất giữa các mô hình. Cách này tạo ra kịch bản “bỏ phiếu” đa mô hình, có khả năng đẩy dự đoán vào đúng lớp hoặc gần hơn với giá trị đúng trong các mô hình hồi quy. Ensemble thường hoạt động tốt nhất khi các mô hình thành phần có sự bất đồng. Khái niệm kết hợp nhiều mô hình cũng cho thấy hiệu quả thực tế cao, thường vượt các triển khai thuật toán đơn lẻ.

Bạn có thể tạo ensemble thủ công bằng cách huấn luyện nhiều mô hình, dự đoán với từng mô hình và sau đó kết hợp chúng.

Vì sao dùng `SuperLearner`?

Bây giờ bạn đã biết ensemble là gì, có thể bạn tự hỏi thư viện SuperLearner chính xác làm gì. Nói đơn giản, SuperLearner là một thuật toán dùng cross-validation để ước lượng hiệu năng của nhiều mô hình học máy, hoặc cùng một mô hình với các thiết lập khác nhau. Sau đó, nó tạo ra trung bình có trọng số tối ưu của các mô hình đó, còn gọi là “ensemble”, dựa trên hiệu năng trên dữ liệu kiểm tra.

Nhưng vì sao bạn nên dùng SuperLearner?

Mặc dù trong suốt hướng dẫn bạn sẽ tìm hiểu sâu hơn về sức mạnh của gói R này, bạn có thể tham khảo sớm danh sách ưu điểm sau:

SuperLearner cho phép bạn khớp một mô hình ensemble chỉ bằng cách thêm các thuật toán
Như đã nói, SuperLearner sử dụng cross-validation, vốn dùng để ước lượng rủi ro cho tất cả mô hình. Điều này khiến SuperLearner rất phù hợp để so sánh mô hình!
SuperLearner khiến ensembling hiệu quả bằng cách tự động ước lượng trọng số của ensemble. Đây thường là một tác vụ tốn công và cần rất nhiều thử nghiệm.
SuperLearner tự động loại bỏ các mô hình không đóng góp vào sức mạnh dự đoán của ensemble, nhờ đó bạn thoải mái thử nghiệm với nhiều thuật toán!

Hãy xem quy trình sử dụng SuperLearner.

Học Ensemble trong R với `SuperLearner`

Cài đặt gói `SuperLearner`

SuperLearner có thể được cài từ CRAN với hàm install.packages() và sau đó nạp vào workspace bằng hàm library():

 # Install the package
install.packages("SuperLearner")

# Load the package
library("SuperLearner")Được hỗ trợ bởi

Chuẩn bị dữ liệu

Để minh họa SuperLearner, bạn sẽ dùng bộ dữ liệu Pima Indian Women từ gói MASS. Gói MASS có một tập huấn luyện để huấn luyện mô hình và một tập kiểm tra để đánh giá hiệu năng mô hình trên dữ liệu chưa thấy. Bộ dữ liệu cung cấp một số yếu tố mô tả về phụ nữ Pima như số lần mang thai, tuổi và tình trạng mắc tiểu đường hay không. Mục tiêu là dự đoán bệnh tiểu đường.

Cột type là cột cho biết sự hiện diện của tiểu đường. Đây là cột nhị phân Yes hoặc No, nghĩa là nó tuân theo phân phối nhị thức.

Lưu ý rằng, không đi quá sâu vào lý thuyết, phân phối nhị thức là tập hợp các phép thử Bernoulli, tức phép thử thành công/thất bại trong xác suất. Phân phối nhị thức dễ nhận ra vì chỉ có hai phản hồi có thể, trong trường hợp này là Yes hoặc No. Vì sao bạn cần biết điều này? Bởi SuperLearner yêu cầu bạn xác định họ phân phối của bài toán mà mô hình thuộc về. Bạn sẽ thấy rõ hơn khi khớp mô hình ở phần sau.

     # Get the `MASS` library
    library(MASS)

    # Train and test sets
    train <- Pima.tr
    test <- Pima.te

    # Print out the first lines of `train`
    head(train)Được hỗ trợ bởi

    ##   npreg glu bp skin  bmi   ped age type
    ## 1     5  86 68   28 30.2 0.364  24   No
    ## 2     7 195 70   33 25.1 0.163  55  Yes
    ## 3     5  77 82   41 35.8 0.156  35   No
    ## 4     0 165 76   43 47.9 0.259  26   No
    ## 5     0 107 60   25 26.4 0.133  23   No
    ## 6     5  97 76   27 35.6 0.378  52  YesĐược hỗ trợ bởi

    # Get a summary of `train`
    summary(train)Được hỗ trợ bởi

    ##      npreg            glu              bp              skin      
    ##  Min.   : 0.00   Min.   : 56.0   Min.   : 38.00   Min.   : 7.00  
    ##  1st Qu.: 1.00   1st Qu.:100.0   1st Qu.: 64.00   1st Qu.:20.75  
    ##  Median : 2.00   Median :120.5   Median : 70.00   Median :29.00  
    ##  Mean   : 3.57   Mean   :124.0   Mean   : 71.26   Mean   :29.21  
    ##  3rd Qu.: 6.00   3rd Qu.:144.0   3rd Qu.: 78.00   3rd Qu.:36.00  
    ##  Max.   :14.00   Max.   :199.0   Max.   :110.00   Max.   :99.00  
    ##       bmi             ped              age         type    
    ##  Min.   :18.20   Min.   :0.0850   Min.   :21.00   No :132  
    ##  1st Qu.:27.57   1st Qu.:0.2535   1st Qu.:23.00   Yes: 68  
    ##  Median :32.80   Median :0.3725   Median :28.00            
    ##  Mean   :32.31   Mean   :0.4608   Mean   :32.11            
    ##  3rd Qu.:36.50   3rd Qu.:0.6160   3rd Qu.:39.25            
    ##  Max.   :47.90   Max.   :2.2880   Max.   :63.00Được hỗ trợ bởi

Mẹo: nếu bạn muốn có thêm thông tin về các biến trong bộ dữ liệu này, hãy dùng hàm help() như sau:

 help(Pima.tr)Được hỗ trợ bởi

Chạy lệnh trên, bạn có thể suy ra rằng cột type chỉ báo tình trạng tiểu đường.

SuperLearner cũng yêu cầu biến phản hồi được mã hóa nếu là bài toán phân loại. Vì bạn đang giải bài toán phân loại nhị thức, bạn sẽ mã hóa factor cho biến type về mã 0-1:

     y <- as.numeric(train[,8])-1
    ytest <- as.numeric(test[,8])-1Được hỗ trợ bởi

Vì cột type là factor, R sẽ mã hóa thành 1 và 2, nhưng đây không phải là điều bạn muốn: lý tưởng là bạn muốn mã hóa thành 0 và 1, tương ứng “No” và “Yes”. Trong đoạn mã trên, bạn trừ 1 khỏi toàn bộ để có mã 0-1. R cũng sẽ mã hóa theo thứ tự của factor.

Gói còn yêu cầu biến dự báo (X) và biến phản hồi (Y) nằm trong cấu trúc dữ liệu riêng. Bạn đã tách Y ở trên, giờ cần tách X. Đồng thời tách luôn tập kiểm tra:

     x <- data.frame(train[,1:7])
    xtest <- data.frame(test[,1:7])Được hỗ trợ bởi

Lưu ý rằng một số thuật toán không chỉ yêu cầu data frame, mà cần một ma trận mô hình (model matrix) được lưu dưới dạng data frame. Ví dụ là thuật toán nnet. Khi giải bài toán hồi quy, bạn hầu như luôn dùng model matrix để lưu dữ liệu cho SuperLearner. Model matrix chỉ đơn giản là tách các biến factor thành các cột riêng và mã hóa chúng thành giá trị 0-1 thay vì dạng chữ. Nó không ảnh hưởng tới các cột số. Model matrix sẽ tăng số lượng cột mà thuật toán phải xử lý, do đó có thể tăng thời gian tính toán. Với bộ dữ liệu nhỏ như này, tác động là tối thiểu, nhưng các bộ dữ liệu lớn có thể bị ảnh hưởng đáng kể. Bài học là hãy quyết định thuật toán bạn muốn thử trước khi khớp mô hình. Với ví dụ đơn giản này, bạn chỉ dùng data frame cho cấu trúc hiện có.

Mô hình Ensemble đầu tiên với `SuperLearner`

Để bắt đầu tạo mô hình đầu tiên, bạn có thể dùng lệnh sau để xem trước các mô hình sẵn có trong gói:

     listWrappers()Được hỗ trợ bởi

    ## All prediction algorithm wrappers in SuperLearner:

    ##  [1] "SL.bartMachine"      "SL.bayesglm"         "SL.biglasso"        
    ##  [4] "SL.caret"            "SL.caret.rpart"      "SL.cforest"         
    ##  [7] "SL.dbarts"           "SL.earth"            "SL.extraTrees"      
    ## [10] "SL.gam"              "SL.gbm"              "SL.glm"             
    ## [13] "SL.glm.interaction"  "SL.glmnet"           "SL.ipredbagg"       
    ## [16] "SL.kernelKnn"        "SL.knn"              "SL.ksvm"            
    ## [19] "SL.lda"              "SL.leekasso"         "SL.lm"              
    ## [22] "SL.loess"            "SL.logreg"           "SL.mean"            
    ## [25] "SL.nnet"             "SL.nnls"             "SL.polymars"        
    ## [28] "SL.qda"              "SL.randomForest"     "SL.ranger"          
    ## [31] "SL.ridge"            "SL.rpart"            "SL.rpartPrune"      
    ## [34] "SL.speedglm"         "SL.speedlm"          "SL.step"            
    ## [37] "SL.step.forward"     "SL.step.interaction" "SL.stepAIC"         
    ## [40] "SL.svm"              "SL.template"         "SL.xgboost"

    ## 
    ## All screening algorithm wrappers in SuperLearner:

    ## [1] "All"
    ## [1] "screen.corP"           "screen.corRank"        "screen.glmnet"        
    ## [4] "screen.randomForest"   "screen.SIS"            "screen.template"      
    ## [7] "screen.ttest"          "write.screen.template"Được hỗ trợ bởi

Bạn sẽ thấy có các wrapper thuật toán dự đoán và wrapper sàng lọc. Có nhiều thư viện phổ biến có thể dùng cho phân loại, hồi quy hoặc cả hai. Các thuật toán sàng lọc được dùng để tự động chọn biến bởi SuperLearner.

Khi muốn dùng một thuật toán trong danh sách trên, bạn cần cài đặt gói tương ứng trong môi trường của mình. Bởi SuperLearner thực chất gọi các gói đó và khớp mô hình khi phương thức được sử dụng. Điều đó cũng có nghĩa là nếu bạn không bao giờ dùng phương thức SL.caret, chẳng hạn, bạn không cần cài gói caret.

Khớp mô hình rất đơn giản, nhưng bạn sẽ đi từng bước với ví dụ một mô hình.

Bạn sẽ khớp thuật toán Ranger, là triển khai nhanh hơn của Random Forest nổi tiếng.

Nhớ rằng Random Forest là một phương pháp mạnh mẽ, thực chất là ensemble của các cây quyết định. Cây quyết định hoạt động bằng cách quan sát dữ liệu và tính toán điểm chia xác suất giữa các biến trong mô hình, từ đó tạo lộ trình đến dự đoán. Cây quyết định thường bị overfit vào dữ liệu của chúng, nghĩa là không khái quát tốt trên dữ liệu mới. Random Forest giải quyết bằng cách trồng nhiều cây quyết định dựa trên nhiều mẫu dữ liệu và sau đó lấy trung bình các dự đoán để tìm dự đoán đúng. Nó cũng chỉ chọn một tập con đặc trưng cho mỗi mẫu, khác với bagging trên cây. Điều này tạo mô hình không overfit dữ liệu. Thật thú vị, đúng không?

Trong trường hợp này, có thể bạn cần cài thư viện ranger bằng hàm install.packages() trước khi bắt đầu khớp mô hình.

Nếu đã làm xong, bạn có thể tiếp tục và dùng SL.ranger trong hàm SuperLearner().

Vì Random Forest - và do đó Ranger - chứa lấy mẫu ngẫu nhiên trong thuật toán, bạn sẽ không nhận cùng một kết quả nếu khớp nhiều lần. Do đó, với bài tập này, bạn đặt seed để có thể tái lập ví dụ và cũng so sánh nhiều mô hình trên cùng một seed cơ sở. R dùng set.seed() để đặt seed ngẫu nhiên. Seed có thể là bất kỳ số nào, ở đây bạn dùng 150.

    set.seed(150)
    single.model <- SuperLearner(y,
                                 x,
                                 family=binomial(),
                                 SL.library=list("SL.ranger"))Được hỗ trợ bởi

SuperLearner yêu cầu biến Y là biến phản hồi/kết quả cần dự đoán, biến X là các biến dự báo, family sử dụng (có thể là gaussian hoặc binomial) và thư viện thuật toán dưới dạng list. Ở đây là SL.ranger.

Bạn còn nhớ phần bàn về phân phối nhị thức lúc trước không? Giờ bạn thấy vì sao cần biết nó: dùng mô hình gaussian sẽ không cho ra dự đoán phù hợp trong miền 0-1 của bạn.

Tiếp theo, chỉ cần in mô hình là có được hệ số, tức trọng số của thuật toán trong mô hình, và yếu tố rủi ro là lỗi mà thuật toán tạo ra. Ở hậu trường, gói sẽ khớp từng thuật toán dùng trong ensemble để tạo ra hệ số rủi ro.

     single.modelĐược hỗ trợ bởi

    ## 
    ## Call:  
    ## SuperLearner(Y = y, X = x, family = binomial(), SL.library = list("SL.ranger")) 
    ## 
    ## 
    ## 
    ##                    Risk Coef
    ## SL.ranger_All 0.1759541    1Được hỗ trợ bởi

Trong trường hợp này, hệ số rủi ro của bạn nhỏ hơn 0,20. Dĩ nhiên, điều này cần được kiểm tra qua cross-validation bên ngoài và trên tập kiểm tra, nhưng đây là khởi đầu tốt. Điểm hay của SuperLearner là nó cố tự động xây ensemble bằng cross-validation. Tất nhiên, nếu chỉ có một mô hình, nó sẽ nhận toàn bộ trọng số của ensemble.

Một mô hình đơn lẻ thì tốt, nhưng bạn có thể làm điều này không cần SuperLearner. Vậy làm sao khớp mô hình ensemble?

Huấn luyện một Ensemble với R: Kernel SVM, Bayes GLM và Bagging

Ensembling với SuperLearner đơn giản như việc chọn các thuật toán sử dụng. Ở đây, hãy thêm Kernel Support Vector Machines (KSVM) từ kernlab, Bayes Generalized Linear Models (GLM) từ arm và bagging từ ipred.

Nhưng KSVM và Bayes GLM là gì?

KSVM dùng cái gọi là “kernel trick” để tính khoảng cách giữa các điểm. Thay vì phải vẽ bản đồ đặc trưng và tính tọa độ, phương pháp kernel tính tích trong giữa các điểm. Điều này cho phép tính toán nhanh hơn. Sau đó SVM được dùng để học biên phân tách phi tuyến giữa các điểm trong phân loại. SVM cố tạo một khoảng cách giữa hai lớp trong bài toán học máy vốn thường phi tuyến, rồi phân loại điểm mới về hai phía của khoảng cách đó dựa trên vị trí của chúng trong không gian.
Mô hình Bayes GLM đơn giản là một triển khai của hồi quy logistic, ít nhất trong trường hợp này khi bạn phân loại bài toán 0-1. Bayes GLM khác KSVM ở chỗ nó dùng thuật toán hồi quy tăng cường để cập nhật hệ số mỗi bước. Bagging tương tự random forest ở trên nhưng không lấy tập con đặc trưng. Nghĩa là bạn sẽ trồng nhiều cây quyết định từ các mẫu ngẫu nhiên và lấy trung bình để có dự đoán.

Bây giờ hãy khớp ensemble đầu tiên của bạn!

Mẹo: đừng quên cài các gói này nếu bạn chưa có! Ngoài ra, bạn có thể được nhắc cài thêm các gói phụ thuộc.

     # Set the seed
    set.seed(150)

    # Fit the ensemble model
    model <- SuperLearner(y,
                          x,
                          family=binomial(),
                          SL.library=list("SL.ranger",
                                          "SL.ksvm",
                                          "SL.ipredbagg",
                                          "SL.bayesglm"))

    # Return the model
    modelĐược hỗ trợ bởi

    ## 
    ## Call:  
    ## SuperLearner(Y = y, X = x, family = binomial(), SL.library = list("SL.ranger",  
    ##     "SL.ksvm", "SL.ipredbagg", "SL.bayesglm")) 
    ## 
    ## 
    ##                       Risk     Coef
    ## SL.ranger_All    0.1756230 0.000000
    ## SL.ksvm_All      0.1838340 0.000000
    ## SL.ipredbagg_All 0.1664828 0.524182
    ## SL.bayesglm_All  0.1677593 0.475818Được hỗ trợ bởi

Việc thêm các thuật toán này đã cải thiện mô hình và thay đổi cục diện. Ranger và KVSM có hệ số bằng không, nghĩa là không còn được gán trọng số trong ensemble. Bayes GLM và Bagging tạo nên phần trọng số còn lại của mô hình. Bạn sẽ thấy SuperLearner đang tính rủi ro cho bạn và quyết định pha trộn mô hình tối ưu để giảm lỗi.

Để hiểu đóng góp cụ thể và độ biến thiên của từng mô hình, bạn có thể dùng hàm cross-validation nội bộ CV.SuperLearner() của SuperLearner. Để đặt số fold, dùng đối số V. Ở đây, bạn đặt bằng 5:

     # Set the seed
    set.seed(150)

    # Get V-fold cross-validated risk estimate
    cv.model <- CV.SuperLearner(y,
                                x,
                                V=5,
                                SL.library=list("SL.ranger",
                                                "SL.ksvm",
                                                "SL.ipredbagg",
                                                "SL.bayesglm"))

    # Print out the summary statistics
    summary(cv.model)Được hỗ trợ bởi

    ## 
    ## Call:  
    ## CV.SuperLearner(Y = y, X = x, V = 5, SL.library = list("SL.ranger",  
    ##     "SL.ksvm", "SL.ipredbagg", "SL.bayesglm")) 
    ## 
    ## Risk is based on: Mean Squared Error
    ## 
    ## All risk estimates are based on V =  5 
    ## 
    ##         Algorithm     Ave       se     Min     Max
    ##     Super Learner 0.17277 0.014801 0.16250 0.19557
    ##       Discrete SL 0.17964 0.014761 0.16363 0.19244
    ##     SL.ranger_All 0.17866 0.015004 0.14811 0.20518
    ##       SL.ksvm_All 0.19382 0.020301 0.15685 0.26215
    ##  SL.ipredbagg_All 0.17791 0.015858 0.15831 0.19244
    ##   SL.bayesglm_All 0.16628 0.014318 0.15322 0.18022Được hỗ trợ bởi

Bản tóm tắt cross-validation cho thấy rủi ro trung bình của mô hình, mức biến thiên và khoảng rủi ro.

Vẽ biểu đồ cũng cho ra đồ thị đẹp thể hiện các mô hình dùng và độ biến thiên của chúng:

     plot(cv.model)Được hỗ trợ bởi

Dễ thấy Bayes GLM hoạt động tốt nhất trung bình, trong khi KSVM tệ nhất và có nhiều biến thiên so với các mô hình khác. Điểm hay của SuperLearner là nếu một mô hình không khớp tốt hoặc đóng góp ít, nó đơn giản sẽ được gán trọng số bằng 0! Không cần loại bỏ và huấn luyện lại, trừ khi bạn định huấn luyện lại trong tương lai. Hãy nhớ rằng huấn luyện mô hình đúng đắn bao gồm cross-validation cho toàn bộ mô hình. Trong thực tế, đó là cách bạn xác định rủi ro trước khi dự đoán dữ liệu mới.

Tạo dự đoán với SuperLearner

Với lệnh cụ thể predict.SuperLearner() bạn có thể dễ dàng dự đoán trên các tập dữ liệu mới. Nghĩa là bạn không thể dùng hàm predict() thông thường!

     predictions <- predict.SuperLearner(model, newdata=xtest)Được hỗ trợ bởi

Hàm predict.SuperLearner() nhận đối số mô hình (một mô hình SuperLearner đã khớp) và dữ liệu mới để dự đoán. Kết quả dự đoán trước tiên sẽ trả về dự đoán tổng thể của ensemble:

     head(predictions$pred)Được hỗ trợ bởi

    ##            [,1]
    ## [1,] 0.79322181
    ## [2,] 0.11895658
    ## [3,] 0.04612200
    ## [4,] 0.05928159
    ## [5,] 0.68824522
    ## [6,] 0.54373451Được hỗ trợ bởi

Nó cũng trả về dự đoán của từng thư viện thành phần:

     head(predictions$library.predict)Được hỗ trợ bởi

    ##      SL.ranger_All SL.ksvm_All SL.ipredbagg_All SL.bayesglm_All
    ## [1,]         0.796   0.8089502       0.82086658      0.76276712
    ## [2,]         0.129   0.1580203       0.18586049      0.04525230
    ## [3,]         0.016   0.1579566       0.06255427      0.02801949
    ## [4,]         0.102   0.1885473       0.07238268      0.04484885
    ## [5,]         0.638   0.7108875       0.58791672      0.79877149
    ## [6,]         0.550   0.6898737       0.37488066      0.72975132Được hỗ trợ bởi

Điều này cho phép bạn xem từng mô hình phân loại mỗi quan sát ra sao. Nó hữu ích khi gỡ lỗi mô hình hoặc khớp nhiều mô hình cùng lúc để xem nên tiếp tục với mô hình nào.

Bạn có thể đã để ý các giá trị dự đoán được trả về là xác suất. Nghĩa là bạn cần một ngưỡng cắt để quyết định phân loại 1 hay 0. Điều này chỉ cần trong phân loại nhị thức, không phải hồi quy.

Thông thường, bạn sẽ xác định điều này trong huấn luyện với cross-validation, nhưng để đơn giản, bạn sẽ dùng ngưỡng 0,50. Vì đây là bài toán nhị thức đơn giản, bạn dùng hàm ifelse() của dplyr để tái mã hóa xác suất:

     # Load the package
    library(dplyr)

    # Recode probabilities
    conv.preds <- ifelse(predictions$pred>=0.5,1,0)Được hỗ trợ bởi

Bây giờ bạn có thể tạo ma trận nhầm lẫn với caret để xem kết quả:

     # Load in `caret`
    library(caret)

    # Create the confusion matrix
    cm <- confusionMatrix(conv.preds, ytest)

    # Return the confusion matrix
    cm
 Được hỗ trợ bởi

    ## Confusion Matrix and Statistics
    ## 
    ##           Reference
    ## Prediction   0   1
    ##          0 199  45
    ##          1  24  64
    ##                                           
    ##                Accuracy : 0.7922          
    ##                  95% CI : (0.7445, 0.8345)
    ##     No Information Rate : 0.6717          
    ##     P-Value [Acc > NIR] : 8.166e-07       
    ##                                           
    ##                   Kappa : 0.5044          
    ##  Mcnemar's Test P-Value : 0.01605         
    ##                                           
    ##             Sensitivity : 0.8924          
    ##             Specificity : 0.5872          
    ##          Pos Pred Value : 0.8156          
    ##          Neg Pred Value : 0.7273          
    ##              Prevalence : 0.6717          
    ##          Detection Rate : 0.5994          
    ##    Detection Prevalence : 0.7349          
    ##       Balanced Accuracy : 0.7398          
    ##                                           
    ##        'Positive' Class : 0               
    ##Được hỗ trợ bởi

Bạn đạt độ chính xác khoảng 0,7921687 trên bộ dữ liệu này, là hiệu năng tốt đối với bộ này. Nhiều thuật toán có thể đạt cao hơn, nhưng đây là kết quả tốt cho một ensemble nhanh. Với huấn luyện đúng đắn bằng cross-validation và thử các mô hình khác, bạn có thể nhanh chóng cải thiện điểm số này.

Tinh chỉnh siêu tham số

Dù hiệu năng mô hình không tệ, bạn có thể cố cải thiện bằng cách tinh chỉnh một số siêu tham số của các mô hình trong ensemble. Ranger không được gán trọng số cao trong mô hình của bạn, nhưng có thể vì bạn cần thêm cây và cần tinh chỉnh tham số mtry. Có lẽ bạn cũng có thể cải thiện bagging bằng cách tăng tham số nbagg lên 250 thay vì mặc định 25.

Có hai cách làm: hoặc bạn định nghĩa một hàm gọi learner và sửa một tham số, hoặc bạn dùng hàm create.Learner(). Ở các phần tiếp theo, bạn sẽ tìm hiểu thêm về các lựa chọn này.

Định nghĩa một hàm

Cách đầu tiên là dùng function(). Ở đây, bạn sẽ định nghĩa một hàm gọi learner và sửa một tham số. Lời gọi hàm dùng dấu ba chấm ... để truyền các đối số bổ sung vào hàm. Ba dấu chấm này cho phép bạn sửa đổi một công thức mà không phải chỉ rõ trong hàm các sửa đổi đó là gì. Nghĩa là nếu bạn thay đổi 10 tham số, bạn không cần 10 đối tượng trong hàm để ánh xạ. Đây là cách viết hàm có thể khái quát.

     SL.ranger.tune <- function(...){
      SL.ranger(..., num.trees=1000, mtry=2)
    }

    SL.ipredbagg.tune <- function(...){
      SL.ipredbagg(..., nbagg=250)
    }Được hỗ trợ bởi

SL.ranger.tune là tên phương thức ranger đã chỉnh sửa và SL.ipredbagg.tune là tên phương thức ipredbagg đã chỉnh sửa. Giờ bạn đã có các hàm learner mới, hãy truyền chúng vào công thức cross-validation để xem hiệu năng có cải thiện không.

Lưu ý rằng bạn sẽ giữ nguyên các hàm SL.ranger và SL.ipredbagg gốc trong thuật toán để xem bản tinh chỉnh có tốt hơn các phiên bản gốc không.

     # Set the seed
    set.seed(150)

    # Tune the model
    cv.model.tune <- CV.SuperLearner(y,
                                     x,
                                     V=5,
                                     SL.library=list("SL.ranger",
                                                     "SL.ksvm",
                                                     "SL.ipredbagg","SL.bayesglm", 
                                                     "SL.ranger.tune",
                                                     "SL.ipredbagg.tune"))

    # Get summary statistics
    summary(cv.model.tune)Được hỗ trợ bởi

    ## 
    ## Call:  
    ## CV.SuperLearner(Y = y, X = x, V = 5, SL.library = list("SL.ranger",  
    ##     "SL.ksvm", "SL.ipredbagg", "SL.bayesglm", "SL.ranger.tune", "SL.ipredbagg.tune")) 
    ## 
    ## 
    ## Risk is based on: Mean Squared Error
    ## 
    ## All risk estimates are based on V =  5 
    ## 
    ##              Algorithm     Ave       se     Min     Max
    ##          Super Learner 0.17272 0.014969 0.15849 0.19844
    ##            Discrete SL 0.17250 0.014989 0.15645 0.18430
    ##          SL.ranger_All 0.17897 0.015084 0.15388 0.19920
    ##            SL.ksvm_All 0.19573 0.020278 0.16095 0.26304
    ##       SL.ipredbagg_All 0.17667 0.015629 0.16473 0.18898
    ##        SL.bayesglm_All 0.16628 0.014318 0.15322 0.18022
    ##     SL.ranger.tune_All 0.17637 0.014882 0.15218 0.19793
    ##  SL.ipredbagg.tune_All 0.17813 0.015869 0.16455 0.19260Được hỗ trợ bởi

    # Plot the tuned model
    plot(cv.model.tune)Được hỗ trợ bởi

Bạn có thể thấy từ biểu đồ này rằng ipredbagg dường như cải thiện khi bạn tăng tham số nbagg như trong SL.ipredbagg.tune. Ranger có vẻ tệ hơn khi tinh chỉnh tham số, nhưng hãy giữ lại và xem SuperLearner có thấy nó phù hợp không.

Một lần nữa, điểm hay là SuperLearner sẽ đặt trọng số bằng 0 nếu không phù hợp. Hãy nhớ rằng các ensemble tốt nhất không phải là tập hợp các thuật toán hoạt động tốt nhất, mà là những thuật toán bù trừ cho nhau tốt nhất để phân loại dự đoán.

Hãy khớp mô hình mới với các tham số đã tinh chỉnh và xem trọng số của chúng:

     # Set the seed
    set.seed(150)

    # Create the tuned model
    model.tune <- SuperLearner(y,
                              x,
                              SL.library=list("SL.ranger",
                                              "SL.ksvm",
                                              "SL.ipredbagg",
                                              "SL.bayesglm",
                                              "SL.ranger.tune",
                                              "SL.ipredbagg.tune"))

    # Return the tuned model
    model.tuneĐược hỗ trợ bởi

    ## 
    ## Call:  
    ## SuperLearner(Y = y, X = x, SL.library = list("SL.ranger", "SL.ksvm",  
    ##     "SL.ipredbagg", "SL.bayesglm", "SL.ranger.tune", "SL.ipredbagg.tune")) 
    ## 
    ## 
    ## 
    ##                            Risk      Coef
    ## SL.ranger_All         0.1748247 0.0000000
    ## SL.ksvm_All           0.1974033 0.0000000
    ## SL.ipredbagg_All      0.1745503 0.0000000
    ## SL.bayesglm_All       0.1634855 0.7162423
    ## SL.ranger.tune_All    0.1725514 0.0000000
    ## SL.ipredbagg.tune_All 0.1711161 0.2837577Được hỗ trợ bởi

SL.bayesglm và SL.ipredbagg.tune giờ là hai thuật toán duy nhất được gán trọng số trong ensemble. Dự đoán trên tập kiểm tra cho kết quả sau:

     # Gather predictions for the tuned model
    predictions.tune <- predict.SuperLearner(model.tune, newdata=xtest)

    # Recode predictions
    conv.preds.tune <- ifelse(predictions.tune$pred>=0.5,1,0)

    # Return the confusion matrix
    confusionMatrix(conv.preds.tune,ytest)Được hỗ trợ bởi

    ## Confusion Matrix and Statistics
    ## 
    ##           Reference
    ## Prediction   0   1
    ##          0 200  43
    ##          1  23  66
    ##                                           
    ##                Accuracy : 0.8012          
    ##                  95% CI : (0.7542, 0.8428)
    ##     No Information Rate : 0.6717          
    ##     P-Value [Acc > NIR] : 1.116e-07       
    ##                                           
    ##                   Kappa : 0.5271          
    ##  Mcnemar's Test P-Value : 0.01935         
    ##                                           
    ##             Sensitivity : 0.8969          
    ##             Specificity : 0.6055          
    ##          Pos Pred Value : 0.8230          
    ##          Neg Pred Value : 0.7416          
    ##              Prevalence : 0.6717          
    ##          Detection Rate : 0.6024          
    ##    Detection Prevalence : 0.7319          
    ##       Balanced Accuracy : 0.7512          
    ##                                           
    ##        'Positive' Class : 0               
    ##Được hỗ trợ bởi

Điều này cho bạn chút cải thiện trên tập kiểm tra và minh họa cách dùng SuperLearner để tinh chỉnh mô hình.

`create.Learner()`

Cách thứ hai để tinh chỉnh siêu tham số là dùng hàm create.Learner(). Cách này cho phép bạn tùy biến một SuperLearner hiện có:

     learner <- create.Learner("SL.ranger", params=list(num.trees=1000, mtry=2))
    learner2 <- create.Learner("SL.ipredbagg", params=list(nbagg=250))Được hỗ trợ bởi

Chuỗi ký tự learner là đối số đầu tiên của hàm create.Learner(). Sau đó bạn truyền một list các tham số cần sửa. Việc này sẽ tạo một đối tượng:

     learnerĐược hỗ trợ bởi

    ## $grid
    ## NULL
    ## 
    ## $names
    ## [1] "SL.ranger_1"
    ## 
    ## $base_learner
    ## [1] "SL.ranger"
    ## 
    ## $params
    ## $params$num.trees
    ## [1] 1000
    ## 
    ## $params$mtry
    ## [1] 2Được hỗ trợ bởi

Bây giờ, khi truyền learner vào SuperLearner, bạn dùng thuộc tính names trong đối tượng learner:

     # Set the seed
    set.seed(150)

    # Create a second tuned model
    cv.model.tune2 <- CV.SuperLearner(y,
                                      x,
                                      V=5,
                                      SL.library=list("SL.ranger",
                                                      "SL.ksvm",
                                                      "SL.ipredbagg",
                                                      "SL.bayesglm", 
                                                      learner$names,
                                                      learner2$names))

    # Get summary statistics
    summary(cv.model.tune2)Được hỗ trợ bởi

    ## 
    ## Call:  
    ## CV.SuperLearner(Y = y, X = x, V = 5, SL.library = list("SL.ranger",  
    ##     "SL.ksvm", "SL.ipredbagg", "SL.bayesglm", learner$names, learner2$names)) 
    ## 
    ## 
    ## Risk is based on: Mean Squared Error
    ## 
    ## All risk estimates are based on V =  5 
    ## 
    ##           Algorithm     Ave       se     Min     Max
    ##       Super Learner 0.17272 0.014969 0.15849 0.19844
    ##         Discrete SL 0.17250 0.014989 0.15645 0.18430
    ##       SL.ranger_All 0.17897 0.015084 0.15388 0.19920
    ##         SL.ksvm_All 0.19573 0.020278 0.16095 0.26304
    ##    SL.ipredbagg_All 0.17667 0.015629 0.16473 0.18898
    ##     SL.bayesglm_All 0.16628 0.014318 0.15322 0.18022
    ##     SL.ranger_1_All 0.17637 0.014882 0.15218 0.19793
    ##  SL.ipredbagg_1_All 0.17813 0.015869 0.16455 0.19260Được hỗ trợ bởi

    # Plot `cv.model.tune2`
    plot(cv.model.tune2)Được hỗ trợ bởi

Kết quả cuối cùng giống với khi bạn dùng cách đầu tiên. Bạn tùy chọn phương pháp mình thích.

Nhiều mô hình Ensemble và Học máy trong R

Thật nhiều kiến thức! Đến giờ, bạn đã nắm được SuperLearner và đã khớp thành công ensemble đầu tiên bằng SuperLearner. Gói này giúp bạn thêm mô hình rất nhanh chóng, dễ dàng. Có một số điểm tinh tế về phương pháp và dạng dữ liệu sử dụng. Tuy nhiên, khi chưa chắc, một model matrix lưu dưới dạng data frame gần như luôn hiệu quả.

Nhắc lại, bạn đã cài và nạp SuperLearner, định dạng bộ dữ liệu, khớp một mô hình đơn, khớp ensemble đầu tiên, dự đoán với ensemble và tinh chỉnh một số siêu tham số!

Bước tiếp theo là xử lý các chủ đề nâng cao hơn với gói này, như song song hóa, chọn đặc trưng và sàng lọc, dùng model matrix, tự viết SuperLearner của riêng bạn và cross-validation cho ensemble.

Xem thêm hướng dẫn Machine Learning trong R cho người mới bắt đầu của DataCamp.

Chủ đề

Machine Learning Khoa học Dữ liệu R

Chủ đề

Công nghệ

Học Ensemble trong R với SuperLearner

Khám phá cùng AI

Ensemble là gì?

Vì sao dùng `SuperLearner`?

Học Ensemble trong R với `SuperLearner`

Cài đặt gói `SuperLearner`

Chuẩn bị dữ liệu

Mô hình Ensemble đầu tiên với `SuperLearner`

Huấn luyện một Ensemble với R: Kernel SVM, Bayes GLM và Bagging

Tạo dự đoán với SuperLearner

Tinh chỉnh siêu tham số

Định nghĩa một hàm

`create.Learner()`

Nhiều mô hình Ensemble và Học máy trong R

Chủ đề

Tìm hiểu thêm về R và Học máy

Học có giám sát với R: Hồi quy

Machine Learning với Mô hình Dựa trên Cây trong R

Machine Learning với caret trong R

Liên quan

Claude Opus 4.6: Tính năng, Điểm chuẩn, Bài kiểm tra thực hành và hơn thế nữa

Chủ đề

Công nghệ

Tìm hiểu thêm về R và Học máy

Học có giám sát với R: Hồi quy

Machine Learning với Mô hình Dựa trên Cây trong R

Machine Learning với caret trong R

Ensemble là gì?

Vì sao dùng SuperLearner?

Học Ensemble trong R với SuperLearner

Cài đặt gói SuperLearner

Chuẩn bị dữ liệu

Mô hình Ensemble đầu tiên với SuperLearner

Huấn luyện một Ensemble với R: Kernel SVM, Bayes GLM và Bagging

Tạo dự đoán với SuperLearner

Tinh chỉnh siêu tham số

Định nghĩa một hàm

create.Learner()

Nhiều mô hình Ensemble và Học máy trong R

Chủ đề

Tìm hiểu thêm về R và Học máy

Liên quan

Tìm hiểu thêm về R và Học máy

Vì sao dùng `SuperLearner`?

Học Ensemble trong R với `SuperLearner`

Cài đặt gói `SuperLearner`

Mô hình Ensemble đầu tiên với `SuperLearner`

`create.Learner()`