BÀI 6: MULTIPLE LINEAR REGRESSION (HỒI QUY TUYẾN TÍNH NHIỀU BIẾN)

Trong Bài 5, chúng là đã thảo luận thuật toán Simple Linear Regression. Thuật toán Linear Regression đó chỉ phụ thuộc vào một biến độc lập để dự đoán cho một biến phụ thuộc khác. Trong Bài 6, chúng ta sẽ tìm hiểu và cài đặt thuật toán Multiple Linear Regression. Thuật toán này phụ thuộc vào hai hay nhiều biến độc lập để dự đoán cho một biến phụ thuộc khác.

 Sau bài học này, người học có khả năng:

·         Tìm hiểu bài toán và dữ liệu

·         Cài đặt thuật toán Gradient descent

·         Sử dụng thư viện scikit-learn 

6.1 Bài toán và dữ liệu

Trong bài này chúng ta sẽ tìm hiểu dữ liệu được thu thập có 2 biến độc lập là: diện tích của ngôi nhà (Size - tính bằng feet²), cùng số phòng ngủ (Bedrooms); và một biến phụ thuộc đó là giá của ngôi nhà (Price – tính bằng USD) tương ứng được bán (dữ liệu lấy từ [1], có thể download từ [2]). Người ta muốn đoán giá của ngôi nhà thông qua thông tin thu thập được: diện tích và số phòng ngủ.

Chương trình 6.1 không khác ở Bài 5, ngoại trừ dòng 04 và 05:

01. import pandas as pd 02. import numpy as np 03. import os 04. from matplotlib import pyplot 05. duongDan = os.getcwd() + '\data\ex1data2.txt' 06. tenCot = ['Size', 'Bedrooms', 'Price'] 07. duLieu = pd.read_csv(duongDan, names= tenCot) 08. print (duLieu.shape) 09. print (duLieu.head())

Chương trình 6.1

Thông tin dữ liệu chúng ta có được như sau:

(47, 3)

   Size  Bedrooms   Price

0  2104     3      399900

1  1600     3      329900

2  2400     3      369000

3  1416     2      232000

4  3000     4      539900

Vậy chúng ta biết dữ liệu gồm có 47 hàng và 3 cột (Size, Bedrooms, và Price). Chúng ta cũng biết thêm rằng giá trị trên cột Bedrooms rất khác so với các giá trị trên cột Size, và cả hai cột đầu có giá trị rất khác so với cột Price. 

duLieu.plot(kind='box', subplots=True, layout=(2,2), sharex=False, sharey=False) pyplot.show()

Chúng ta có biểu đồ (giống như Hình 6.1)

 
Hình 6.1 Đồ thị dữ liệu cho diện tích, số phòng
ngủ và giá của một ngôi nhà.

Chúng ta thấy khoảng giá trị của từng cột là rất khác nhau, với dữ liệu cột Bedrooms ở trong đoạn [1,5], với cột Size khoảng từ 800 tới 3200, với cột Price trong khoảng từ 170.000 tới 580.000.

Chính vì sự khác biệt lớn này, nên nếu chúng ta không xử lý dữ liệu, thuật toán sẽ gặp vấn đề lớn.

6.2 Thuật toán Gradient descent

Chương trình không khác gì ở Bài 5, ngoại trừ chúng ta cho số lần lặp là soLanLap = 10:

01. maTran = duLieu.values 02. m,n = maTran.shape 03. X_cacCot = maTran[:,0:n-1] 04. X = np.insert(X_cacCot, 0, values = 1, axis = 1) 05. y = maTran[:,n-1:n] 06. print X[:5] 07. print y[:5] 08. theta = np.zeros((1, X.shape[1])) 09. print theta 10. print X.shape, y.shape, theta.shape 11. def h_X(X, theta): 12.     return np.dot(X, theta.T) 13. def computeCost(X, y, theta): 14.     saiSo = np.power((h_X(X, theta) - y),2) 15.     J = (1.0/(2 * m)) * np.sum(saiSo) 16.     return J 17. print computeCost(X, y, theta) 18. def gradientDescent(X, y, theta, alpha, soLanLap): 01.     theta_tam = np.zeros(theta.shape) 19.     heso_Theta = theta.shape[1] 20.     J_tam = np.zeros(soLanLap) 21.     for i in range(soLanLap): 22.         saiSo = h_X(X,theta) - y 23.         for j in range(heso_Theta): 24.             X_ij = np.reshape(X[:, j],(len(X),1)) 25.             term = np.multiply(saiSo, X_ij) 26.             theta_tam[0, j] = theta[0, j] - ((alpha / len(X)) * np.sum(term)) 27.         theta = theta_tam 28.         J_tam[i] = computeCost(X, y, theta) 29.     return theta, J_tam 30. alpha = 0.01 31. soLanLap = 10 32. theta_sauCung, J_chiphi = gradientDescent(X, y, theta, alpha, soLanLap) 33. print theta_sauCung 34. print J_chiphi[-1]

Chương trình 6.2

Khi chạy chương trình 6.2 sẽ cho kết quả:

[[   1 2104    3]

 [   1 1600    3]

 [   1 2400    3]

 [   1 1416    2]

 [   1 3000    4]]

[[399900]

 [329900]

 [369000]

 [232000]

 [539900]]

[[ 0.  0.  0.]]

(47, 3) (47, 1) (1, 3)

65591548106.5

[[ -3.17739580e+45 -7.33861634e+48  -1.05993953e+46]]

1.24428862154e+104

Kết quả lần lượt in ra 5 dòng đầu của X, y, theta (khởi tạo) cùng kích thước của chúng. Thật đáng ngạc nhiên khi dòng 17 cho kết quả một con số rất lớn. Với giá trị khởi tạo, hàm chi phí của chúng ta lên tới xấp xỉ 65 tỉ. Và sau 10 vòng lặp, trị giá của theta một con số không tưởng, và hàm chi phí khoảng 1.24.10¹⁰⁴.

Chúng ta có thể cho rằng do hệ số theta chưa hội tụ sau số lần lặp ít như vậy. Tuy nhiên khi càng tăng số lần lặp lên, con số dự đoán lại càng lớn hơn. Khi thử với soLanLap từ 50 trở đi, giá trị dự đoán vượt cả giới hạn số mà Python sử dụng.

Nguyên nhân vì sao? Như chúng ta đã quan sát dữ liệu ở phần 6.1: có sự chênh lệch rất lớn giữa giá trị và tỉ lệ giữa các cột. Chính điều này làm thuật toán của chúng ta không hội tụ (càng lặp nhiều, càng phân tán).

 Vậy thì ta cần điều chuẩn hóa dữ liệu. Trong bài này ta dùng kĩ thuật chuẩn hóa dữ liệu Standardization. Bằng cách thêm vào dòng lệnh:

duLieu = (duLieu - duLieu.mean())/duLieu.std()

 vào trước dòng lệnh 01 trong Chương trình 6.2 trên. Sau đó chạy chương trình thì kết quả in ra sẽ là (với soLanLap = 1000):

[[ 1.          0.13000987 -0.22367519]

 [ 1.         -0.50418984 -0.22367519]

 [ 1.          0.50247636 -0.22367519]

 [ 1.         -0.73572306 -1.53776691]

 [ 1.          1.25747602  1.09041654]]

[[ 0.47574687]

 [-0.08407444]

 [ 0.22862575]

 [-0.86702453]

 [ 1.59538948]]

[[ 0.  0.  0.]]

(47, 3) (47, 1) (1, 3)

0.489361702128

[[ -1.10963248e-16   8.78503652e-01  -4.69166570e-02]]

0.130703369608

Như chúng ta thấy, giá trị của theta ở ngưỡng phù hợp (θ  = [θ₀  θ₁  θ₂] = [0  0.8785  -0.0469]), và chi phí sau 1000 lần lặp là 0.131.

Chúng ta sử dụng lại Chương trình 5.5, ta sẽ có đồ thị của hàm chi phí ứng với số lần lăp:

Hình 6.2 Hàm chi phí biến đổi sau các bước lặp của thuật toán.

Nhìn vào đồ thị chúng ta thấy rằng không có sự thay đổi nhiều từ bước lặp 500 trở đi. Nói một cách khác, sau 500 vòng lặp, theta của chúng ta đã hội tụ.

Và khi chúng ta thay soLanLap = 500 thì kết quả cho theta và hàm chi phí là:

[[ -1.24238681e-16   8.30383883e-01   8.23982853e-04]]

0.131951337758

Kết quả rất gần với kết quả sau 1000 lặp ở phía trên.

6.3 Kết luận

Cần bổ sung vào đây.

Bài tập:

Bạn thử áp dụng các kĩ thuật điều chỉnh dữ liệu khác trong Bài 4 để áp dụng vào Bài 6 này xem kết quả khác nhau như thế nào?

Tài liệu tham khảo:

1.       https://www.coursera.org/learn/machine-learning

2.    https://github.com/alexband/ml-class/blob/master/mlclass-ex1/ex1data2.txt

Read More

Bài 5: SIMPLE LINEAR REGRESSION (HỒI QUY TUYẾN TÍNH MỘT BIẾN)

Mô hình Linear Regression là một kĩ thuật thường được dùng trong các mô hình phân tích và dự đoán. Mô hình chỉ ra một quan hệ tuyến tính giữa một biến phụ thuộc vào một hay nhiều biến độc lập. Có hai mô hình Linear Regression:  Simple Linear Regression và Multiple Linear Regression (trong Bài 6). Mô hình Linear Regression  cần có một vài giả định cho dữ liệu. Cụ thể, giá trị của biến phụ thuộc phải là giá trị liên tục (số thực); trong khi giá trị của các biến độc lập có thể là giá trị liên tục hoặc là kiểu liệt kê hữu hạn.

Thuật toán Linear Regression có lịch sử hơn 200 năm. Do vậy, thuật toán Simple Linear Regression là sự lựa chọn rất phù hợp cho người mới bắt đầu học tìm hiểu và cài đặt một thuật toán Máy học.

Sau bài học này, người học có khả năng:

·         Tìm hiểu bài toán và dữ liệu

·         Xây dựng mô hình Simple Linear Regression (SLR)

·         Cài đặt thuật toán Gradient descent

·         Biểu đồ hóa dữ liệu quan sát và dữ liệu dự đoán

·         Quan sát sự thay đổi của hàm chi phí sau số các bước lặp

5.1 Bài toán và dữ liệu

Chúng ta hãy quay lại với dữ liệu (Chương trình 1.3) về thông tin số dân và lợi nhuận thu được khi mở hàng ăn ở 97 thành phố tương ứng [1].

01. import pandas as pd 02. import os 03. from matplotlib import pyplot 04. duongDan = os.getcwd() + '\data\ex1data1.txt' 05. tenCot = ['Population', 'Profit'] 06. duLieu = pd.read_csv(duongDan, names= tenCot) 07. print duLieu.head()

Chương trình 5.1: Kết nối và hiển thị dữ liệu.

Thông tin dữ liệu với 5 dòng đầu như sau:

    Population   Profit

0      6.1101  17.5920

1      5.5277   9.1302

2      8.5186  13.6620

3      7.0032  11.8540

4      5.8598   6.8233

Bài toán đặt ra là: với dữ liệu cho như vậy, làm sao ta có thể dự đoán được lợi nhuận của một cửa hàng ăn nào đó, nếu chúng ta biết số dân của thành phố tại cửa hàng ăn đó.

duLieu.plot(kind='scatter', x='Population', y='Profit') pyplot.show()

Chúng ta có biểu đồ (giống như Hình 3.1)

Hình 3.1: Đồ thị dữ liệu cho số dân (đơn vị 10.000 người) và lợi nhuận (đơn vị 10.000 USD).

Theo như đồ thị biểu diễn, mối tương quan giữa số dân và lợi nhuận của thành phố tương ứng có thể xấp xỉ bởi một mô hình tuyến tính (đường thẳng). Cho tới lúc này, chúng ta có cơ sở để xây dựng một mô hình tuyến tính để dự đoán giá trị mục tiêu y với những dữ liệu nhập vào x ϵ R¹. Nói một cách khác, chúng ta cần xây dựng một hàm y = h(x) sao cho y⁽ⁱ⁾ ≈ h(x⁽ⁱ⁾) cho mỗi x⁽ⁱ⁾ – mỗi giá trị nhập. Nếu chúng ta tìm thấy một hàm h(x) như vậy với tương đối đủ những dữ liệu quan sát (x⁽ⁱ⁾, y⁽ⁱ⁾), chúng ta hi vọng rằng hàm h(x) đủ tốt để dự báo lợi nhuận của một thành phố nếu biết số dân của nó, mặc dù chúng ta không biết lợi nhuận là bao nhiêu.

5.2 Mô hình SLR

Mô hình Simple Linear Regression giả định mối quan hệ giữa các dữ liệu nhập (X) và dữ liệu xuất (y) có quan hệ tuyến tính. Nói một cách khác, đồ thị biểu diễn mối quan hệ giữa X và y là một đường thẳng. Khi dữ liệu nhập (X) chỉ là một biến (một đặc tính), thì mô hình gọi là simple linear regression (SLR).

Mô hình SLR, hàm dự đoán h(x) có thể được công thức hóa như sau [2]:

                      

                                   (5.1)

Ở đây θ  = [θ₀  θ₁] được coi là vector các hệ số / tham số (hay trọng số) mà chúng ta cần ước lượng từ tập dữ liệu huấn luyện cho mô hình. Vector dữ liệu nhập x = [1  x₁],  từ nay về sau để cho dễ dạng biểu diễn cũng như cài đặt, chúng ta coi x₀ = 1.

Với bài toán hiện tại, chúng ta cần lấy ra dữ liệu nhập (số dân của thành phố) và giá trị mục tiêu (lợi nhuận). Muốn vậy, chúng ta cần biết chính xác kích cỡ của dữ liệu:

01. maTran= duLieu.values # maTran là một ndarray 02. m, n = maTran.shape   # m:=97 (số hàng); n:=2 (số cột) 03. X_tam = maTran[:,0:n-1]# X_tam gồm các cột, trừ cột cuối cùng 04. X = np.insert(X_tam,0, values =1, axis = 1) # chèn cột [1] vào trước các cột khác 05. y = maTran[:,n-1:n]                          # y là cột cuối cùng 06. print X[:5]  # in ra 5 hàng đầu để kiểm tra 07. print y[:5]  # in ra 5 hàng đầu để kiểm tra

Chương trình 5.2: Phân tách dữ liệu thành tập đặc trưng và nhãn

Công thức (5.1) phía trên có thể viết gọn lại dưới dạng tích có hướng của hai vecto:

Hàm dự đoán trên là áp dụng cho một thể hiện (một quan sát) và kết quả, tức là x có kích 

cỡ 1xn, cho ra là một giá trị thực y. Tuy nhiên để thuận tiện cho cài đặt và biểu diễn, khi 

chúng ta làm việc với X (gồm m quan sát), là một ma trận mxn. Khi đó công thức trên sẽ 

cần được viết lại: 

Hàm dự đoán được cài đặt:

def h_X(X, theta):     return np.dot(X,theta.T)      # theta.T là ma trận chuyển vị của theta

Vecto theta có thể ban đầu được khởi tạo (θ = [ 0.  0.] ):

theta = np.zeros((1, X.shape[1])) print (theta)    # in ra theta print (theta.T)  # in ra ma trận chuyển vị của theta

Tới lúc này ta nên kiểm tra lại các kích cỡ của 3 thành phần quan trọng:

print (X.shape) print (y.shape) print (theta.shape)

Kết quả sẽ in ra lần lượt 3 ma trận:

(97, 2) (97, 1) (1, 2)

Sau khi đã xây dựng được mô hình, chúng ta có thể tiến hành dự đoán cho dữ liệu nhập mới. Trong tay chúng ta bây giờ có các cặp dữ liệu (x⁽ⁱ⁾, y⁽ⁱ⁾) và hàm h_θ (x) – phụ thuộc vào θ_­. Ý tưởng của mô hình SLR là tìm θ sao cho h_θ (x) càng gần y càng tốt, ít nhất là trên các tập dữ liệu huấn luyện. Để thực hiện ý tưởng này, chúng ta xây dựng một hàm để đo khoảng cách giữa y⁽ⁱ⁾ và h(x⁽ⁱ⁾) ứng với một giá trị θ cụ thể. Chúng ta gọi đó là hàm chi phí:

Trong đó m là số dữ liệu mà chúng ta quan sát được (có m cặp (x⁽ⁱ⁾, y⁽ⁱ⁾)). Công thức trên chính là hàm chi phí bình phương cực tiểu (least-squares cost). Hàm chi phí (cost) cũng được gọi là hàm phạt (loss, penalty), hay là hàm mục tiêu (objective).   

Hàm chi phí được cài đặt trên Python như sau:

def computeCost(X, y, theta):     saiSo = np.power((h_X(X, theta) - y),2)     J = (1.0/(2 * m)) * np.sum(saiSo)     return J

Để kiểm tra quá trình cài đặt của chúng ta tới lúc này có gì sai sót không. Chúng ta hãy kiểm tra hàm chi phí với giá trị theta khởi tạo θ = [ 0.  0.]:

print (computeCost(X,y,theta))

Nếu kết quả in ra là: 32.0727338775 thì yên tâm là việc thiết lập và cài đặt của chúng ta là chính xác.

5.3 Thuật toán Gradient descent

Chúng ta muốn tìm θ cực tiểu hóa để hàm   có giá trị nhỏ nhất (cực tiểu). Có thể có nhiều kĩ thuật để cực tiểu hóa một hàm, tuy nhiên Gradient Descent là kĩ thuật thường được dùng.

1.  Thiết lập một giá trị khởi đầu cho θ (tùy ý, nhưng trong bài này chúng ta khởi tạo là ma trận 0).
2.  Tính giá trị hàm chi phí 
3. Tìm các điểm lân cận của θ để sao cho hàm chi phí nhỏ hơn
4. Bước 2 và 3 được lặp lại cho tới khi chuỗi θ hội tụ tới một giá trị để  đạt cực trị.

Kĩ thuật chúng ta quan tâm trong cuốn sách này là Gradient descent.  Đây là một kĩ thuật hiệu quả vì nó có thể áp dụng cho bài toán dữ liệu lớn và dễ cài đặt. Kĩ thuật Gradient descent cần một quá trình cập nhật θ (sau giá trị khởi tạo ban đầu) [2, 3]:

Trong đó  là hệ số học (learning rate). Và j là số thành phần của vector θ, và trong bài toán hiện tại của chúng ta θ  = [θ₀  θ₁], do vậy j = 0,1.  

Công thức cập nhật trên có thể thay cụ thể bằng các quan sát (x⁽ⁱ⁾, y⁽ⁱ⁾), thì chúng ta sẽ được [2, 3] công thức mới:

 cho mọi giá trị của j.

Với bài toán của chúng ta ứng với mỗi giá trị của i = 1, ..., m, giá trị của θ lại phải được cập nhật. Tức là trong thuật toán các thành phần    (j = 0,1) phải được cập nhật ĐỒNG THỜI.

01. def gradientDescent(X, y, theta, alpha, soLanLap): 02. theta_tam = np.zeros(theta.shape) 03. heso_Theta = theta.shape[1] 04. J_tam = np.zeros(soLanLap) 05. For i in range(soLanLap): 06.     saiSo = h_X(X,theta) – y 07.     For j in range(heso_Theta): 08.         X_ij = np.reshape(X[:, j],(len(X),1)) 09.         term = np.multiply(saiSo, X_ij) 10.         theta_tam[0, j] = theta[0, j] – ((alpha / len(X)) * np.sum(term)) 11.     theta = theta_tam 12.     J_tam[i] = computeCost(X, y, theta) 13. Return theta, J_tam

Chương trình 5.3: Cài đặt hàm gradient descent

Chú thích thêm cho Chương trình 5.3 phía trên:

-          Dòng 02: Tạo ra một biến tạm cho theta (θ  = [θ₀  θ₁])

-          Dòng 03: Lấy số chiều của theta (trong bài này là 2)

-          Dòng 04: Lưu lại giá trị của hàm chi phí J để về sau quan sát sự biến đổi của nó

-          Dòng 05: Thuật toán được lặp với số lần soLanLap

-          Dòng 06: Tính hiệu số giữa hàm dự đoán và giá trị mục tiêu quan sát được

-          Dòng 07: Tiến hành cập nhật ĐỒNG THỜI cho các hệ số của theta

-          Dòng 08: Chuyển toàn bộ cột j thành dạng mảng có kích thước (m,1)

-          Dòng 09: Tích (element-wise) của hai mảng, nhân từng phần tử tương ứng với nhau

-          Dòng 10: Cập nhật từng thành phần (θ₀,  θ₁) của theta

-          Dòng 11: Cập nhật lại theta, sau mỗi lần lặp

-          Dòng 12: Lưu lại giá trị hàm chi phí, sau mỗi lần lặp

Vậy là chúng ta đã hoàn tất thuật toán Gradient descent. Bây giờ chúng ta thiết lập cho hệ số học (  - learning rate) và số lần lặp cho thuật toán:

alpha = 0.01 soLanLap = 1000 theta_sauCung, J_chiphi = gradientDescent(X, y, theta, alpha, soLanLap) print theta_sauCung       # in ra theta, sau khi đã chạy xong thuật toán print J_chiphi[-1]        # in ra hàm chi phí cuối cùng

Sau khi thiết lập 4 dòng lệnh trên chạy chương trình thì kết quả là:

[[-3.24140214  1.1272942 ]]

4.51595550308

Cuối cùng chúng ta cũng được mô hình dự đoán:

            h_θ (x) = θ₀ + θ₁x₁ = -3.24140214 + 1.1272942.x₁

Và nếu ai đưa cho chúng ta số dân của một thành phố nào đó, chúng ta có thế dự đoán lợi nhuận mà thành phố đó đem lại. Ví dụ ở quận Đống Đa có 401.000 người, Quận 11 có 232.000 người.  áp dụng công thức trên cho 2 quan sát:

duDoan_profit = ([[1., 40.1],[1., 23.2]] * theta_sauCung) print duDoan_profit.sum(axis = 1) # in ra [ 41.96309537  22.91182335]

Chúng ta in ra kết quả dự đoán và được kết quả dự đoán: Đống Đa sẽ có lợi nhuận khoảng 419.000 USD, trong khi Quận 11 (ở Tp.HCM) được 229.000 USD lợi nhuận.

5.4 Đồ thị hóa dữ liệu

Cuối cùng thì chúng ta cũng có được mô hình dự đoán. Chúng ta dùng dựng biểu đồ để quan sát. 

Sau khi chúng ta xây dựng hàm và gọi luôn hàm đó,  duDoan_fig():

01. def duDoan_fig(): 02.     x_pop = np.linspace(X_dacTinh.min(), X_dacTinh.max(), 100) 03.     f = theta_sauCung[0, 0] + (theta_sauCung[0, 1] * x_pop) 04.     fig, ax = pyplot.subplots() # (figsize=(12,8)) 05.     ax.plot(x_pop, f, 'r', label='Prediction') 06.     ax.scatter(X_dacTinh, y, label='Traning Data') 07.     ax.legend(loc=2) 08.     ax.set_xlabel('Population in 10.000 people') 09.     ax.set_ylabel('Profit in 10.000 USD') 10.     ax.set_title('Predicted Profit vs. Population Size') 11.     pyplot.show()

12. duDoan_fig()

Chương trình 5.4: Đồ thị hóa hàm dự đoán.

Một vài chú thích cho chương trình trên:

-          Dòng 02: Tạo ra một mảng (ndarray) có 100 phần tử cách đều nhau có giá trị chạy trong khoảng [min, max] của cột dữ liệu lưu trữ số dân của thành phố

-          Dòng 03: tạo ra mảng (ndarray) tính giá trị lợi nhuận dự đoán tương ứng với số dân, dựa vào theta_sauCung tính được ở Chương trình 5.1

-          Dòng 04: là một hàm trả gia một cặp, fig - hình ảnh và ax- trục của hình ảnh. Nếu chúng ta muốn thay đổi các đặc tính của ảnh, hay lựu lại ảnh thành một tệp, thì fig sẽ giúp chúng ta thực hiện điều đó.

-          Dòng 05: Vẽ biểu đồ của mô hình dự đoán mà chúng ta có được từ Chương trình 5.1. Biểu đồ của chúng ta là đường thẳng màu đỏ (Prediction)

-          Dòng 06: Biểu đồ các dữ liệu chúng ta có để làm tập dữ liệu huấn luyện (Training Data)

-          Dòng 07: hàm legend để chỉ vị trí mà các nhãn của các biểu đồ chúng ta xây dựng (có giá trị trong 0,...,10). Hãy xem thêm phần phụ lục.

-          Dòng 08: Đặt tiêu đề cho trục hoành

-          Dòng 09: Đặt tiêu đề cho trục tung

-          Dòng 10: Đặt tiêu đề cho đồ thị

Chương trình sẽ cho đồ thị (sau khi chạy dòng 12 duDoan_fig()):

5.5 Hàm chi phí sau số các bước lặp

Để quan sát sự thay đổi của hàm chi phí, sau các bước lặp, chúng ta sẽ sử dụng các giá trị tính được sau mỗi bước lặp của thuật toán ở Chương trình 5.1

def chiPhi_fig():     fig, ax = pyplot.subplots()     ax.plot(np.arange(soLanLap), J_chiphi, 'r')     ax.set_xlabel('So Lan Lap')     ax.set_ylabel('Ham Chi Phi')     ax.set_title('Ham Chi Phi vs. So Lan Lap')     pyplot.show() chiPhi_fig()

Chương trình 5.5: Hàm chi phí cho tập dữ liệu.

Chương trình 5.5 sẽ cho đồ thị:

5.6 Kết luận

·         Cần thêm nhận xét vào đây

Tài liệu tham khảo:

1.       Andrew Ng:  Machine Learning: https://www.coursera.org/learn/machine-learning

2.       http://ufldl.stanford.edu/tutorial/supervised/LinearRegression/

3.       http://cs229.stanford.edu/notes/cs229-notes1.pdf

Read More