Home

© 2025 AI Chronicle. All Rights Reserved.

    Gradient Boosting: Giải Mã Thuật Toán Mạnh Mẽ trong Học Máy

    September 14, 2025
    Nguyen Dinh Phuc
    ensemble-learning
    machine-learning
    regression
    classification
    gradient-descent
    gradient-boosting

    Gradient Boosting là một thuật toán mạnh mẽ không thể bỏ qua trong các bài toán xử lý dữ liệu dạng bảng. Với khả năng khám phá các quan hệ phi tuyến phức tạp, nó hoàn toàn giải quyết được các vấn đề phổ biến trong các kiểu dữ liệu dạng bảng như giá trị thiếu, ngoại lai hay dữ liệu phân loại có nhiều giá trị.

    Bài viết này sẽ cung cấp cho bạn cái nhìn sâu sắc về Gradient Boosting, giúp bạn không chỉ biết cách sử dụng mà còn hiểu được tại sao nó lại hiệu quả đến vậy. Khi đã nắm vững nguyên lý, bạn sẽ có đủ kiến thức để tinh chỉnh siêu tham số, tùy chỉnh hàm lỗi, từ đó nâng cao đáng kể chất lượng mô hình của mình.

    1. Giới thiệu

    Nhắc lại một chút về thuật toán Boosting

    Để hiểu về Gradient Boosting, trước hết chúng ta cần nắm vững khái niệm Boosting. Boosting là một kỹ thuật học kết hợp (ensemble learning) nhằm cải thiện hiệu suất của các mô hình học máy.

    Ý tưởng chính của Boosting là xây dựng một mô hình mạnh (strong learner) bằng cách kết hợp nhiều mô hình yếu (weak learners) một cách tuần tự. Mỗi mô hình yếu được thêm vào sẽ tập trung vào việc sửa chữa lỗi của các mô hình trước đó.

    Hãy tưởng tượng bạn đang cố gắng giải một bài toán cực kỳ khó. Thay vì cố gắng giải nó một mình, bạn nhờ một nhóm bạn cùng giúp sức. Mỗi người bạn sẽ giải một phần của bài toán. Tuy nhiên, họ không giải độc lập mà người sau sẽ dựa vào kết quả của người trước để sửa lỗi và hoàn thiện. Cứ như vậy, qua nhiều vòng, cả nhóm sẽ tìm ra được lời giải chính xác nhất.

    Gradient Boosting

    Gradient Boosting là một loại thuật toán Boosting, nhưng nó sử dụng một cách tiếp cận đặc biệt để sửa lỗi. Thay vì chỉ đơn thuần cộng thêm các mô hình yếu (weak learners), Gradient Boosting sử dụng Gradient Descent để tối ưu hóa hàm mất mát (loss function).

    Gradient Descent là một thuật toán tối ưu hóa quen thuộc, dùng để tìm giá trị nhỏ nhất của một hàm số. Trong Gradient Boosting, chúng ta sẽ sử dụng nó để tìm "hướng đi" tốt nhất cho mô hình tiếp theo, sao cho nó có thể giảm thiểu lỗi của mô hình hiện tại một cách hiệu quả nhất. Về mặt lý thuyết, gradient boosting có thể được xem như một dạng gradient descent (xuống dốc theo đạo hàm) trong không gian hàm (functional gradient descent), khi mỗi bước mở rộng (boosting step) thực hiện một “bước” nhỏ hướng tới giảm thiểu hàm mất mát (loss function).

    Hình 1: Minh hoạ thuật toán Gradient Boost
    Hình 1: Minh hoạ thuật toán Gradient Boost

    2. Cách thức hoạt động của Gradient Boosting

    Cho tập huấn luyện {(xi,yi)}i=1n\{(x_i, y_i)\}_{i=1}^n{(xi​,yi​)}i=1n​, hàm mất mát L(y,F(x))L(y, F(x))L(y,F(x)) và số vòng lặp (số cây) MMM. Gradient Boosting xây dựng mô hình theo các bước sau:

    Bước 1: Khởi tạo mô hình ban đầu F0(x)F_{0}(x)F0​(x) sao cho tối thiểu hóa hàm mất mát trên toàn bộ dữ liệu.

    F0(x)=arg⁡min⁡γ∑i=1nL(yi,γ) F_{0}(x) = \arg\min_\gamma \sum_{i=1}^n L(y_i, \gamma) F0​(x)=argγmin​i=1∑n​L(yi​,γ)

    Bước 2: Lặp từ m=1→Mm = 1 \to Mm=1→M:

    • Tính "phần dư" (Residuals):
    rim=−[∂L(yi,F(xi))∂F(xi)]F(x)=Fm−1(x)for i=1,...,n r_{im} = - \left[ \frac{\partial L(y_i, F(x_i))}{\partial F(x_i)} \right]_{F(x)=F_{m-1}(x)} \text{for } i = 1, ..., n rim​=−[∂F(xi​)∂L(yi​,F(xi​))​]F(x)=Fm−1​(x)​for i=1,...,n
    • Huấn luyện mô hình mới: Tìm đạo hàm âm của hàm mất mát tại dự đoán hiện tại Fm−1F_{m-1}Fm−1​
    • Tìm hệ số bước γjm\gamma_{jm}γjm​:
    γjm=arg⁡min⁡γ∑x∈RjmL(yi,Fm−1(xi)+γ) for j=1,...,Jm \gamma_{jm} = \arg\min_\gamma \sum_{x \in R_{jm}} L \big(y_i, F_{m-1}(x_i) + \gamma \big) \text{ for } j = 1, ..., J_m γjm​=argγmin​x∈Rjm​∑​L(yi​,Fm−1​(xi​)+γ) for j=1,...,Jm​
    • Cập nhật mô hình:
    Fm(x)=Fm−1(x)+α∑j=1JmγjmI(x∈Rjm) F_m(x) = F_{m-1}(x) + \alpha \sum_{j = 1}^{J_m} \gamma_{jm} I(x \in R_{jm}) Fm​(x)=Fm−1​(x)+αj=1∑Jm​​γjm​I(x∈Rjm​)

    Bước 3: Sau MMM vòng lặp, kết quả dự đoán chính là kết quả đầu ra của mô hình cuối cùng FM(x)F_{M}(x)FM​(x)

    Chắc hẳn khi nhìn vào các công thức trên, sẽ có nhiều bạn cảm thấy khó hiểu. Để cho dễ hình dung, mình sẽ sử dụng một ví dụ minh hoạ đơn giản và thực hiện lại các bước tính toán của thuật toán nhé!

    Cho tập dữ liệu thể hiện giá của một căn nhà dựa vào diện tích như sau:

    Diện tích (x)Giá nhà (y)
    1001.5
    1201.8
    1502.5
    1802.0
    2002.2

    Khởi tạo mô hình

    Chúng ta khởi tạo mô hình ban đầu F0(x)F_{0}(x)F0​(x) bằng cách lấy giá trị trung bình của tất cả các giá nhà trong tập dữ liệu.
    F0(x)=average(y)=1.5+1.8+2.5+2.0+2.25=2.0 F_{0}(x) = \text{average}(y) = \frac{1.5 + 1.8 + 2.5 + 2.0 + 2.2}{5} = 2.0 F0​(x)=average(y)=51.5+1.8+2.5+2.0+2.2​=2.0
    Đây là mô hình dự đoán ban đầu của chúng ta, nghĩa là với mọi giá trị đầu vào xxx, mô hình sẽ luôn dự đoán y=2y = 2y=2

    Tính "phần dư" (Residuals)

    Residuals rir_{i}ri​ là lỗi của mô hình hiện tại. Nó được tính bằng cách lấy giá trị thực yiy_iyi​ trừ đi giá trị dự đoán F0(x)F_{0}(x)F0​(x).
    r1=y1−F0(x) r_{1} = y_1 - F_{0}(x) r1​=y1​−F0​(x)

    Lúc này, từ bảng dữ liệu huấn luyện ban đầu ta có:

    Diện tích (x)Giá nhà (y)Dự đoán F0F_{0}F0​Residuals r1r_{1}r1​
    1001.52.0-0.5
    1201.82.0-0.2
    1502.52.00.5
    1802.02.00.0
    2002.22.00.2

    Các giá trị residuals chính là mục tiêu mà mô hình kế tiếp cần phải học. Thay vì dự đoán giá nhà, mô hình kế tiếp sẽ dự đoán các giá trị residuals này. Khi đó, đến một mô hình mmm nào đó thì chênh lệch giữa giá trị dự đoán từ mô hình và giá trị thực sự sẽ là nhỏ nhất.

    Huấn luyện và cập nhập mô hình

    Chúng ta huấn luyện một cây quyết định mới h1(x)h_{1}(x)h1​(x) trên tập dữ liệu với giá trị residuals r1r_{1}r1​ là mục tiêu. Cây quyết định này sẽ học cách dự đoán lỗi của mô hình trước đó. Giả sử sau huấn luyện ta thu được một weak-learner có root là x≤120x \leq 120x≤120, ta có thể tính được hệ số bước γ\gammaγ cho mỗi node lá như sau:

    γ1=−0.5−0.22=−0.35γ2=0.5+0.0+0.23≈0.233 \begin{aligned} &\gamma_{1} = \frac{-0.5 - 0.2}{2} = -0.35 \\ &\gamma_{2} = \frac{0.5 + 0.0 + 0.2}{3} \approx 0.233 \end{aligned} ​γ1​=2−0.5−0.2​=−0.35γ2​=30.5+0.0+0.2​≈0.233​

    Diện tích (x)Dự đoán Residual h1(x)h_{1}(x)h1​(x)
    100-0.35
    120-0.35
    1500.233
    1800.233
    2000.233

    Giả sử chúng ta chọn learning rate α=0.3\alpha = 0.3α=0.3, mô hình tổng thể sẽ được cập nhập bằng cách thêm mô hình mới vào.

    F1(x)=F0(x)+αh1(x)F1(100)=F0(100)+αh1(100)F1(100)=2.0+0.3×(−0.35)=1.895 \begin{aligned} &F_{1}(x) = F_{0}(x) + \alpha h_{1}(x) \\ &F_{1}(100) = F_{0}(100) + \alpha h_{1}(100) \\ &F_{1}(100) = 2.0 + 0.3 \times (-0.35) = 1.895 \end{aligned} ​F1​(x)=F0​(x)+αh1​(x)F1​(100)=F0​(100)+αh1​(100)F1​(100)=2.0+0.3×(−0.35)=1.895​

    Sau khi cập nhập mô hình ta có:

    Diện tích (x)Giá nhà (y)Dự đoán F0F_{0}F0​Dự đoán F1F_{1}F1​
    1001.52.01.895
    1201.82.01.895
    1502.52.02.0699
    1802.02.02.0699
    2002.22.02.0699

    Nhận xét: Các giá trị dự đoán F1F_{1}F1​ của mô hình đã gần hơn so với giá trị thực yyy. Quá trình này sẽ được lặp lại MMM lần (tương ướng với MMM cây)
    Qua ví dụ trên các bạn chắc hẳn cũng đã phần nào hiểu hơn về cơ chế hoạt động của thuật toán Gradient Boosting. Nhưng các bạn có thắc mắc tại sao giá trị khởi tạo mô hình F0F_0F0​ lại là giá trị trung bình của tập đầu vào xxx hay các giá trị dự đoán ở cây kế tiếp lại là giá trị trung bình của residual hay không ? Chúng ta sẽ cùng nhau trả lời những câu hỏi trên nhé!

    Mean Squared Error (MSE)

    MSE là một hàm mất mát phổ biến cho bài toán hồi quy, có dạng:

    L(y,F(x))=1n∑i=1n(yi−F(x))2 L(y,F(x)) = \frac{1}{n} \sum_{i=1}^{n}(y_i - F(x))^2 L(y,F(x))=n1​i=1∑n​(yi​−F(x))2

    Lấy đạo hàm theo F(x)F(x)F(x) ta có:

    ∇F(x)L(yi,F(x))=∂∂F(x)2(yi−F(x))=−(yi−F(x)) for i=1,...,n \nabla_{F(x)} L(y_i, F(x)) = \frac{\partial}{\partial F(x)} 2(y_i - F(x)) = -(y_i - F(x)) \text{ for } i = 1, ..., n ∇F(x)​L(yi​,F(x))=∂F(x)∂​2(yi​−F(x))=−(yi​−F(x)) for i=1,...,n

    Chúng ta tạm thời không quan tâm đến giá trị 2 trong hàm trên vì đây là một hằng số, mục tiêu của chúng ta là sẽ tối thiểu hoá hàm mất mát này để sai số giữa giá trị dự đoán và gia trị thực là nhỏ nhất. Chính vì vậy, để tìm cực tiểu của một hàm số, ta cần đi theo hướng ngược lại của đạo hàm.

    −∇F(x)L(yi,F(x))=−(−(yi−F(x)))=yi−F(x) for i=1,...,n -\nabla_{F(x)} L(y_i, F(x)) = -(-(y_i - F(x))) = y_i - F(x) \text{ for } i = 1, ..., n −∇F(x)​L(yi​,F(x))=−(−(yi​−F(x)))=yi​−F(x) for i=1,...,n

    Đây chính xác là công thức tính phần dư (residual) mà chúng ta đã sử dụng! Đối với hệ số bước γ\gammaγ, chúng ta đã biết công thức để tìm giá trị dự đoán tối ưu cho mỗi lá là:

    γjm=arg⁡min⁡γ∑x∈RjmL(yi,Fm−1(xi)+γ) for j=1,...,Jm \gamma_{jm} = \arg\min_\gamma \sum_{x \in R_{jm}} L \big(y_i, F_{m-1}(x_i) + \gamma \big) \text{ for } j = 1, ..., J_m γjm​=argγmin​x∈Rjm​∑​L(yi​,Fm−1​(xi​)+γ) for j=1,...,Jm​

    Sử dụng MSE ta có:

    γjm=arg⁡min⁡γ∑x∈Rjm(yi−(Fm−1(xi)+γ))2 \gamma_{jm} = \arg\min_\gamma \sum_{x \in R_{jm}} (y_i - (F_{m-1}(x_i) + \gamma))^2 γjm​=argγmin​x∈Rjm​∑​(yi​−(Fm−1​(xi​)+γ))2

    Vì Fm−1(xi)+γF_{m-1}(x_i) + \gammaFm−1​(xi​)+γ chính là dự đoán mới, và phần dư (residual) rimr_{im}rim​ được tính là yi−Fm−1(xi)y_i - F_{m-1}(x_i)yi​−Fm−1​(xi​), thay vào công thức trên ta có:

    γjm=arg⁡min⁡γ∑x∈Rjm(rim−γ)2 \gamma_{jm} = \arg\min_\gamma \sum_{x \in R_{jm}}(r_{im} - \gamma)^2 γjm​=argγmin​x∈Rjm​∑​(rim​−γ)2

    Để tìm giá trị tối ưu ta cho đạo hàm bằng 0:

    ∇γγjm=−2∑x∈Rjm(rim−γ)=0∑x∈Rjm(rim−γ)=0∑x∈Rjmrim−∑x∈Rjmγ=0∑x∈Rjm−Rjmγ=0∑x∈Rjm=Rjmγγjm=1Rjm∑x∈Rjmrim \begin{aligned} &\nabla_{\gamma} \gamma_{jm} = -2\sum_{x \in R_{jm}}(r_{im} - \gamma) = 0 \\ &\sum_{x \in R_{jm}}(r_{im} - \gamma) = 0 \\ &\sum_{x \in R_{jm}}r_{im} - \sum_{x \in R_{jm}}\gamma = 0 \\ &\sum_{x \in R_{jm}} - R_{jm}\gamma = 0 \\ &\sum_{x \in R_{jm}} = R_{jm}\gamma \\ &\gamma_{jm} = \frac{1}{R_{jm}}\sum_{x \in R_{jm}}r_{im} \end{aligned} ​∇γ​γjm​=−2x∈Rjm​∑​(rim​−γ)=0x∈Rjm​∑​(rim​−γ)=0x∈Rjm​∑​rim​−x∈Rjm​∑​γ=0x∈Rjm​∑​−Rjm​γ=0x∈Rjm​∑​=Rjm​γγjm​=Rjm​1​x∈Rjm​∑​rim​​

    Đây chính là trung bình cộng của các phần dư trong vùng lá RjmR_{jm}Rjm​. Vì vậy, việc huấn luyện cây quyết định mới trên trung bình phần dư (residual) thực chất là xấp xỉ (approximate) cực tiểu của hàm mất mát. Cây quyết định này sẽ giúp chúng ta tìm "hướng đi" tốt nhất để cập nhật mô hình, sao cho hàm mất mát được giảm xuống. Nhưng tại sao giá trị khởi đầu lại là giá trị trung bình ? Khi khởi tạo mô hình, mục tiêu của chúng ta là tìm một hằng số F(x)F(x)F(x) sao cho hàm mất mát được tối thiểu hóa. Tương tự, để tìm giá trị tối ưu F(x)F(x)F(x), chúng ta chỉ việc đặt giá trị đạo hàm bằng 0.

    ∇F(x)L(y,F(x))=−2n∑i=1n(yi−F(x))=0∑i=1n(yi−F(x))=0∑i=1nyi−∑i=1nF(x)=0∑i=1nyi−nF(x)=0∑i=1nyi=nF(x)F(x)=1n∑i=1nyi \begin{aligned} &\nabla_{F(x)} L(y, F(x)) = -\tfrac{2}{n} \sum_{i=1}^{n}(y_i - F(x)) = 0 \\ &\sum_{i=1}^{n}(y_i - F(x)) = 0 \\ &\sum_{i=1}^{n}y_i - \sum_{i=1}^{n}F(x) = 0 \\ &\sum_{i=1}^{n}y_i - nF(x) = 0 \\ &\sum_{i=1}^{n}y_i = nF(x) \\ &F(x) = \tfrac{1}{n}\sum_{i=1}^{n}y_i \end{aligned} ​∇F(x)​L(y,F(x))=−n2​i=1∑n​(yi​−F(x))=0i=1∑n​(yi​−F(x))=0i=1∑n​yi​−i=1∑n​F(x)=0i=1∑n​yi​−nF(x)=0i=1∑n​yi​=nF(x)F(x)=n1​i=1∑n​yi​​

    Từ biểu thức trên, chúng ta thấy rằng giá trị F(x)F(x)F(x) tối ưu chính là giá trị trung bình của yyy. Do đó, việc khởi tạo mô hình bằng giá trị trung bình của yyy đảm bảo rằng chúng ta bắt đầu từ một điểm tối ưu, nơi hàm mất mát đã ở mức thấp nhất có thể với một hằng số duy nhất.

    3. Gradient Boosting cho bài toán Phân loại

    Trong bài toán phân loại, ý tưởng cốt lõi của Gradient Boosting vẫn tương tự như trong hồi quy: xây dựng mô hình mạnh từ các mô hình yếu một cách tuần tự, tập trung vào việc sửa chữa lỗi của các mô hình trước đó. Tuy nhiên, có một vài thay đổi quan trọng:

    • Hàm mất mát: Chúng ta không sử dụng MSE nữa. Thay vào đó, chúng ta sẽ sử dụng các hàm mất mát phù hợp với bài toán phân loại, chẳng hạn như Binary Cross-Entropy (đối với bài toán phân loại nhị phân) hoặc Categorical Cross-Entropy (đối với bài toán đa lớp).
    • Residual (Phần dư): Thay vì residual trực tiếp, chúng ta sẽ sử dụng pseudo-residual, là gradient âm của hàm mất mát. Cây quyết định mới sẽ học cách dự đoán các giá trị này.
    • Dự đoán: Mô hình sẽ dự đoán log-odds hoặc xác suất, thay vì giá trị thực. Sau đó, chúng ta sẽ sử dụng các hàm chuyển đổi như Sigmoid hoặc Softmax để biến đổi thành xác suất cuối cùng.

    Tương tụ như bài toán hồi quy, mình cũng sẽ sử dụng một ví dụ minh hoạ đơn giản và thực hiện lại các bước tính toán của thuật toán để có thể dễ dàng hình dung nhất nhé!

    Giả sử chúng ta cần dự đoán một khách hàng có mua sản phẩm hay không (có = 1, không = 0) dựa trên số lần truy cập website.

    Số lần truy cập (x)Mua hàng (y)
    101
    150
    201
    250
    301

    Khởi tạo mô hình cho bài toán

    Chúng ta khởi tạo mô hình ban đầu F0(x)F_0(x)F0​(x) bằng cách lấy giá trị log-odds. Với p^\hat{p}p^​ là xác suất của lớp 1 (khách hàng mua hàng). Trong ví dụ này, có 3 người mua hàng trong tổng số 5 người, nên p^=35\hat{p} = \frac{3}{5}p^​=53​

    odds=p^1−p^=351−35=1.5F0(x)=log⁡(odds)=log⁡(1.5)≈0.405 \begin{aligned} &\text{odds} = \frac{\hat{p}}{1 - \hat{p}} = \frac{\frac{3}{5}}{1 - \frac{3}{5}} = 1.5 \\ &F_0(x) = \log(\text{odds}) = \log(1.5) \approx 0.405 \end{aligned} ​odds=1−p^​p^​​=1−53​53​​=1.5F0​(x)=log(odds)=log(1.5)≈0.405​

    Đây là giá trị dự đoán ban đầu của chúng ta trên thang log-odds.

    Tính toán Pseudo-Residual

    Vì đây là bài toán phân loại nhị phân nền chúng ta sẽ sử dụng Binary Cross-Entropy làm hàm mất mát, có dạng:

    L(y,y^)=−[ylog⁡(y^)+(1−y)log⁡(1−y^)] L(y, \hat{y}) = -[y \log(\hat{y}) + (1 - y) \log(1 - \hat{y})] L(y,y^​)=−[ylog(y^​)+(1−y)log(1−y^​)]

    Pseudo-Residual rir_iri​ là gradient âm của hàm mất mát nên ta có:

    −∂L∂F0=yi−Sigmoid(F0(xi)) -\frac{\partial L}{\partial F_0} = y_i - \text{Sigmoid}(F_0(x_i)) −∂F0​∂L​=yi​−Sigmoid(F0​(xi​))

    Trong đó, Sigmoid(F0(xi))\text{Sigmoid}(F_0(x_i))Sigmoid(F0​(xi​)) là hàm chuyển đổi từ log-odds sang xác suất. Chúng ta tính xác suất dự đoán ban đầu p0^\hat{p_0}p0​^​ và pseudo-residual cho từng khách hàng:

    p0^=Sigmoid(F0(xi))=Sigmoid(0.405)≈0.6 \hat{p_0} = \text{Sigmoid}(F_0(x_i)) = \text{Sigmoid}(0.405) \approx 0.6 p0​^​=Sigmoid(F0​(xi​))=Sigmoid(0.405)≈0.6

    Lúc này, ta có bảng dữ liệu sau:

    Số lần truy cập (x)Mua hàng (y)Dự đoán log-odds F0(x)F_0(x)F0​(x)Dự đoán xác suất p0^\hat{p_0}p0​^​Pseudo-Residual r1r_1r1​
    1010.4050.60.4
    1500.4050.6-0.6
    2010.4050.60.4
    2500.4050.6-0.6
    3010.4050.60.4

    Các giá trị pseudo-residual này chính là "mục tiêu" mới mà cây quyết định tiếp theo cần học.

    Huấn luyện và cập nhập

    Tương tự như bài toán hồi quy, chúng ta huấn luyện một cây quyết định mới h1(x)h_{1}(x)h1​(x) trên tập dữ liệu với giá trị pseudo-residual r1r_{1}r1​ là mục tiêu. Giả sử sau huấn luyện ta thu được một weak-learner có root là x≤15x \leq 15x≤15, ta có thể tính được hệ số bước γ\gammaγ cho mỗi node lá như sau:

    γ1=∑ri∑(pi^(1−pi^))=0.4−0.60.6(1−0.6)+0.6(1−0.6)≈−0.417γ2=∑ri∑(pi^(1−pi^))=0.4−0.6+0.40.6(1−0.6)+0.6(1−0.6)+0.6(1−0.6)≈0.278 \begin{aligned} &\gamma_{1} = \frac{\sum r_i}{\sum (\hat{p_i}(1 - \hat{p_i}))} = \frac{0.4 - 0.6}{0.6(1-0.6) + 0.6(1 - 0.6)} \approx -0.417 \\ &\gamma_{2} = \frac{\sum r_i}{\sum (\hat{p_i}(1 - \hat{p_i}))} = \frac{0.4 - 0.6 + 0.4}{0.6(1-0.6) + 0.6(1 - 0.6) + 0.6(1 - 0.6)} \approx 0.278 \end{aligned} ​γ1​=∑(pi​^​(1−pi​^​))∑ri​​=0.6(1−0.6)+0.6(1−0.6)0.4−0.6​≈−0.417γ2​=∑(pi​^​(1−pi​^​))∑ri​​=0.6(1−0.6)+0.6(1−0.6)+0.6(1−0.6)0.4−0.6+0.4​≈0.278​

    Số lần truy cập (x)Dự đoán pseudo-residual h1(x)h_{1}(x)h1​(x)
    10-0.417
    15-0.417
    200.278
    250.278
    300.278

    Giả sử chúng ta chọn learning rate α=0.3\alpha = 0.3α=0.3, mô hình tổng thể sẽ được cập nhập bằng cách thêm mô hình mới vào, ta có thể cập nhập dự đoán xác suất cho điểm dữ liệu đầu tiên như sau:

    F1(x)=F0(x)+αh1(x)F1(10)=F0(10)+αh1(10)F1(10)=0.405+0.3×(−0.417)≈0.28p1^(10)=Sigmoid(F1(10))=Sigmoid(0.28)≈0.57 \begin{aligned} &F_1(x) = F_0(x) + \alpha h_{1}(x) \\ &F_1(10) = F_0(10) + \alpha h_{1}(10) \\ &F_1(10) = 0.405 + 0.3 \times (-0.417) \approx 0.28 \\ &\hat{p_1}(10) = \text{Sigmoid} (F_1(10)) = \text{Sigmoid} (0.28) \approx 0.57 \end{aligned} ​F1​(x)=F0​(x)+αh1​(x)F1​(10)=F0​(10)+αh1​(10)F1​(10)=0.405+0.3×(−0.417)≈0.28p1​^​(10)=Sigmoid(F1​(10))=Sigmoid(0.28)≈0.57​

    Cập nhập tương tự cho toàn bộ tập dữ liệu, ta có:

    Số lần truy cập (x)Mua hàng (y)Dự đoán F0F_0F0​Hệ số bước γ\gammaγCập nhật F1F_1F1​Dự đoán xác suất p1^\hat{p_1}p1​^​
    1010.405-0.4170.280.57
    1500.405-0.4170.280.57
    2010.4050.2780.490.62
    2500.4050.2780.490.62
    3010.4050.2780.490.62

    Nhận xét: Các giá trị xác suất đã thay đổi. Mô hình đã được cập nhật và trở nên chính xác hơn.

    4. Code Implementation

    Vừa rồi, chúng ta đã tìm hiểu về thuật toán Gradient Boosting và có thể thấy rằng quá trình tính toán của nó khá phức tạp — từ việc xây dựng một weak learner cho đến giai đoạn huấn luyện và cập nhật mô hình liên tục. Tuy nhiên, khi triển khai bằng code thì mọi thứ lại trở nên đơn giản hơn rất nhiều, bởi các thư viện như scikit-learn đã hỗ trợ sẵn. Nhờ vậy, bạn hoàn toàn có thể xây dựng một mô hình Gradient Boosting chỉ với một dòng lệnh.

    Chuẩn bị dữ liệu

    Chúng ta sẽ sử dụng bộ dữ liệu "Housing" làm tập dữ liệu huấn luyện cho Gradient Boost. Bộ dữ liệu cung cấp thông tin chi tiết về các đặc điểm của các ngôi nhà. Mục đích chính của tập dữ liệu này có thể là để phân tích mối quan hệ giữa các đặc điểm này và giá nhà, giúp dự đoán giá trị bất động sản dựa trên các yếu tố như diện tích, số phòng ngủ và các tiện ích khác.

    Các bạn có thể tải dữ liệu tại đây

    Đầu tiên, chúng ta import các thư viện cần thiết.

    import pandas as pd
    import matplotlib.pyplot as plt
    
    from sklearn.ensemble import RandomForestRegressor, AdaBoostRegressor, GradientBoostingRegressor
    from sklearn.preprocessing import OrdinalEncoder
    from sklearn.preprocessing import StandardScaler
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import mean_absolute_error, mean_squared_error
    from ydata_profiling import ProfileReport
    

    Bây giờ chúng ta đã có dữ liệu, chúng ta cần kiểm tra và đánh giá bộ dữ liệu.

    dataset_path = './Housing.csv'
    df = pd.read_csv(dataset_path)
    df
    df.info()
    

    #ColumnNon-Null CountDtype
    0price545 non-nullint64
    1area545 non-nullint64
    2bedrooms545 non-nullint64
    3bathrooms545 non-nullint64
    4stories545 non-nullint64
    5mainroad545 non-nullobject
    6guestroom545 non-nullobject
    7basement545 non-nullobject
    8hotwaterheating545 non-nullobject
    9airconditioning545 non-nullobject
    10parking545 non-nullint64
    11prefarea545 non-nullobject
    12furnishingstatus545 non-nullobject

    Hình 2. Bộ dữ liệu Housing
    Hình 2. Bộ dữ liệu Housing

    Bộ dữ liệu gồm 545 mẫu với 13 thuộc tính, trong đó biến mục tiêu là price và các đặc trưng còn lại đóng vai trò biến độc lập. Chúng ta có thể liệt kê số lượng giá trị phân loại (categories) trong từng cột dạng categorical (object) của DataFrame để lựa chọn chiến lược tiền xử lý phù hợp

    categorical_cols = df.select_dtypes(include=['object']).columns.to_list() 
    for col_name in categorical_cols: 
        n_categories = df[col_name].nunique() 
        print(f'Number of categories in {col_name}: {n_categories}')
    
    # Number of categories in mainroad: 2
    # Number of categories in guestroom: 2
    # Number of categories in basement: 2
    # Number of categories in hotwaterheating: 2
    # Number of categories in airconditioning: 2
    # Number of categories in prefarea: 2
    # Number of categories in furnishingstatus: 3
    

    Tiền xử lý dữ liệu

    Chúng ta cần chuyển toàn bộ các biến rời rạc về dạng dữ liệu mà mô hình học máy có thể xử lý được. OrdinalEncoder giúp gán mỗi nhãn phân loại một giá trị số nguyên.

    categorical_cols = df.select_dtypes(include=['object']).columns.to_list()
    
    ordinal_encoder = OrdinalEncoder()
    encoded_categorical_cols = ordinal_encoder.fit_transform(
        df[categorical_cols]
    )
    encoded_categorical_df = pd.DataFrame(
        encoded_categorical_cols,
        columns=categorical_cols
    )
    numerical_df = df.drop(categorical_cols, axis=1)
    encoded_df = pd.concat(
        [numerical_df, encoded_categorical_df], axis=1
    )
    

    Hình 3. Bộ dữ liệu Housing sau bước Encoding
    Hình 3. Bộ dữ liệu Housing sau bước Encoding

    Do các biến số có khoảng giá trị khác nhau (ví dụ: area rất lớn so với parking) nên ta cần chuẩn hóa dữ liệu

    normalizer = StandardScaler()
    dataset_arr = normalizer.fit_transform(encoded_df)
    
    # array([[ 4.56636513,  1.04672629,  1.40341936, ...,  1.4726183 ,
    #          1.80494113, -1.40628573],
    #        [ 4.00448405,  1.75700953,  1.40341936, ...,  1.4726183 ,
    #         -0.55403469, -1.40628573],
    #        [ 4.00448405,  2.21823241,  0.04727831, ..., -0.67906259,
    #          1.80494113, -0.09166185],
    #        ...,
    #        [-1.61432675, -0.70592066, -1.30886273, ..., -0.67906259,
    #         -0.55403469,  1.22296203],
    #        [-1.61432675, -1.03338891,  0.04727831, ..., -0.67906259,
    #         -0.55403469, -1.40628573],
    #        [-1.61432675, -0.5998394 ,  0.04727831, ..., -0.67906259,
    #         -0.55403469,  1.22296203]])
    

    Khởi tạo và huấn luyện mô hình

    Sau khi dữ liệu đã được xử lý, chúng ta sẽ chia chúng ra thành các tâp train và test theo tỷ lệ 7:3

    X, y = dataset_arr[:, 1:], dataset_arr[:, 0]
    
    test_size = 0.3
    random_state = 1
    is_shuffle = True
    X_train, X_val, y_train, y_val = train_test_split(
        X, y, test_size=test_size, random_state=random_state, shuffle=is_shuffle
    )
    

    Chúng ta sẽ khởi tạo mô hình Gradient Boosting Regressor. Ở đây, tham số random_state được truyền vào để đảm bảo kết quả tái lập, còn learning_rate=0.1 kiểm soát tốc độ học, tức là mức độ mà mỗi cây mới đóng góp vào mô hình tổng thể. Sau khi khởi tạo, mô hình được huấn luyện bằng cách gọi fit(X_train, y_train).

    regressor = GradientBoostingRegressor(
        random_state=random_state, learning_rate=0.1
    )
    regressor.fit(X_train, y_train)
    

    Đánh giá trên tập test

    mae = mean_absolute_error(y_val, y_pred)
    mse = mean_squared_error(y_val, y_pred)
    
    print('Evaluation results on validation set:')
    print(f'Mean Absolute Error: {mae}')
    print(f'Mean Squared Error: {mse}')
    
    # Evaluation results on validation set:
    # Mean Absolute Error: 0.4516626127750995
    # Mean Squared Error: 0.39610445936979427
    

    Nhận xét: Kết quả đánh giá cho mô hình trên tập test cho thấy mô hình dự đoán khá tốt, sai số trung bình nhỏ

    Hình 4. Kết quả dự đoán của mô hình sau huấn luyện
    Hình 4. Kết quả dự đoán của mô hình sau huấn luyện

    5. Tài liệu tham khảo

    • All You Need to Know about Gradient Boosting Algorithm − Part 1. Regression
    • All You Need to Know about Gradient Boosting Algorithm − Part 2. Classification
    • Gradient Boosting from Theory to Practice (Part 1)
    • Gradient Boosting from Theory to Practice (Part 2)

    Table of Contents

    • 1. Giới thiệu
    • Nhắc lại một chút về thuật toán Boosting
    • Gradient Boosting
    • 2. Cách thức hoạt động của Gradient Boosting
    • Khởi tạo mô hình
    • Tính "phần dư" (Residuals)
    • Huấn luyện và cập nhập mô hình
    • Mean Squared Error (MSE)
    • 3. Gradient Boosting cho bài toán Phân loại
    • Khởi tạo mô hình cho bài toán
    • Tính toán Pseudo-Residual
    • Huấn luyện và cập nhập
    • 4. Code Implementation
    • Chuẩn bị dữ liệu
    • Tiền xử lý dữ liệu
    • Khởi tạo và huấn luyện mô hình
    • Đánh giá trên tập test
    • 5. Tài liệu tham khảo