Supervised Learning (Thực hành – Phần 2)

Trong phần 1, tôi đã giới thiệu tổng quan về phương pháp học có giám sát và thực hành với mô hình k-Nearest Neighbors, trong phần này chúng ta sẽ đi tiếp với các mô hình Linear, Naive BayesDecision Tree.

1. Mô hình Linear

Là mô hình phổ biến nhất, cổ xưa nhất trong học thuật cũng như thực hành trong vài thập kỷ trở lại đây. Biểu diễn mô hình bởi công thức như sau:

ŷ = w[0] * x[0] + w[1] * x[1] + ... + w[p] * x[p] + b

Trong đó:

ŷ: Giá trị dự đoán (predictor)

x[]: Các biến số đầu vào, quy định các tính năng (features). Với single feature thì ta có mô hình: ŷ = w[0] * x[0] + b

w[]: Các hệ số, khi vẽ thành biểu đồ thì ta thấy hệ số này quy định độ dốc của đường tuyến tính

b: Giá trị bù thêm (intercept offset)

Mục tiêu của mô hình Linear là học để tìm ra giá trị các hệ số w[] và b. Ví dụ về single feature linear dưới đây:

Input:

mglearn.plots.plot_linear_regression_wave()

Output:

w[0]: 0.393906 b: -0.031804

Biểu đồ như sau:

So sánh với mô hình kNN thì có vẻ single feature linear khá đơn giản, thuần túy, không khớp với training data, còn bỏ sót khá nhiều data point. Tuy nhiên khi số features tăng lên thì sức mạnh, độ chính xác của mô hình tuyến tính Linear sẽ được thể hiện rõ nét. Cũng tương tự như mô hình kNN, chúng ta có Linear Regression và Linear Classification.

a. Linear Regression

Có khá nhiều mô hình hồi quy tuyến tính, các mô hình khác nhau ở chỗ các trọng số w và b được dạy học như thế nào và làm thế nào để kiểm soát độ phức tạp của mô hình. Chúng ta sẽ chỉ đi các mô hình phổ biến.

Linear Regression OLS:

Mô hình cổ điển, tìm các trọng số w và b bằng cách tối thiểu hóa hàm mất mát (loss function) – mean squared error của hiệu số giữa giá trị predictor ŷ và giá trị thực tế trong training set.

Dưới đây là đoạn code demo viết trên python:

Input:

import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
X, y = mglearn.datasets.make_wave(n_samples=60)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
lr = LinearRegression().fit(X_train, y_train)
mglearn.plots.plot_linear_regression_wave()
print("X.shape {}".format(X.shape))
print("lr.coef_: {}".format(lr.coef_))
print("lr.intercept_: {}".format(lr.intercept_))
print("Training set score: {:.2f}".format(lr.score(X_train, y_train)))
print("Test set score: {:.2f}".format(lr.score(X_test, y_test)))print("Test set score: {:.2f}".format(lr.score(X_test, y_test)))print("Test set score: {:.2f}".format(lr.score(X_test, y_test)))

Output:

w[0]: 0.393906

b: -0.031804

X.shape (60, 1)

lr.coef_: [0.39390555]

lr.intercept_: -0.031804343026759746

Training set score: 0.67

Test set score: 0.66

Chú ý: coef_ chính là giá trị w, intercept chính là giá trị b.

Kết quả training và test đều xấp xỉ 0.67 là rất thấp, chứng tỏ mô hình single feature này bị underfitting. Tiếp theo chúng ta thử với lượng dữ liệu lớn hơn.

Input:

import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
X, y = mglearn.datasets.load_extended_boston()
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
lr = LinearRegression().fit(X_train, y_train)
print("X.shape {}".format(X.shape))
print("lr.coef_: {}".format(lr.coef_))
print("lr.intercept_: {}".format(lr.intercept_))
print("Training set score: {:.2f}".format(lr.score(X_train, y_train)))
print("Test set score: {:.2f}".format(lr.score(X_test, y_test)))

Output:

w[0]: 0.393906

b: -0.031804

X.shape (506, 104)

lr.coef_: [-5.11126504e+02 4.02559787e+00 -9.45778613e+01 1.34720251e+01 3.48176257e+01 6.03611391e+01 3.49707471e+01 2.94114542e+00 3.14525465e+00 8.20792132e+01 1.24254396e+01 3.86676075e+01 -9.38409521e-01 1.32936334e+01 7.60317098e+02 1.42274855e+03 2.29220565e+02 -7.79405429e+01 8.79429261e+01 1.39813973e+01 1.02565346e+02 7.52178879e+02 -1.82071934e+03 5.34143172e+02 -2.41122305e+01 1.11848898e+02 -4.38177813e+00 -1.23079894e+01 -3.63360790e+00 -5.64878037e+01 4.60395879e-01 8.18005986e+00 -2.06294404e+01 -3.49659791e+01 4.31717988e+01 -2.92220843e+00 1.45250942e+01 -3.24346333e+01 3.66984591e+01 -2.75859278e+00 6.27805740e+00 4.98379104e+01 6.55060318e+00 3.91047481e+01 -1.14826290e+01 -8.00990322e-01 -3.68662287e+00 3.36483260e+01 -1.49103502e+01 1.34720251e+01 -1.80244019e+01 -2.90956806e+01 -2.78115796e+00 -1.10315060e+01 1.15584830e+00 -8.37313259e-01 -7.89905136e+00 6.27950290e+00 -1.09538327e+01 -2.48389637e+01 -1.16316264e+01 -3.00228631e+00 6.83518378e+01 -1.76428626e+01 6.10371772e+01 -6.12936496e+01 -1.14748321e+01 2.09075528e+01 3.32421356e+01 -4.11743268e+01 -2.19312422e+01 -2.08881337e+01 -5.05858326e+01 -2.14714962e+01 -1.11593182e+01 -6.16458839e-01 -1.12569338e+00 -1.40290786e-01 3.17622544e+01 -2.57159897e+01 5.51837314e-01 -1.33768644e+01 -3.25170630e+01 5.20806824e+01 1.08614313e-01 -3.62670514e+01 -2.68217433e+01 -3.42720513e+01 1.41341012e+01 -6.56371258e+01 8.64151127e+01 -3.08281756e+01 3.61562583e+01 -2.56736318e+01 -1.69118913e+01 3.35683331e+01 -7.48792540e+01 -2.02885460e+01 3.35543349e+00 1.07705825e+01 3.50306579e+00 -5.10021527e+00 2.46929457e+00 2.55749022e+01] lr.intercept_: -34.707522103873316

Training set score: 0.94

Test set score: 0.78

Chúng ta thấy có sự khác nhau giữa training score và test score, dấu hiệu của overfitting khi mô hình quá phức tạp, có quá nhiều hệ số. Một trong những giải pháp thay thế Linear Regression truyền thống là Ridge Regression.

Ridge Regression

Ridge Regression về cơ bản cũng giống với Linear Regression truyền thống, vẫn sử dụng đến hàm mean square error nhưng có điểm khác là công thức tìm giá trị hệ số w thì bổ sung thêm ràng buộc để sao cho các hệ số w nhỏ nhất có thể đến mức gần bằng 0, nghĩa là các feature (x) ít có ảnh hưởng tới giá trị đầu ra. Ràng buộc này sử dụng công thức chuẩn hóa L2.

Input:

import matplotlib.pyplot as plt
from sklearn.linear_model import Ridge
from sklearn.model_selection import train_test_split
X, y = mglearn.datasets.load_extended_boston()
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
lr = Ridge().fit(X_train, y_train)
print("X.shape {}".format(X.shape))
print("lr.coef_: {}".format(lr.coef_))
print("lr.intercept_: {}".format(lr.intercept_))
print("Training set score: {:.2f}".format(lr.score(X_train, y_train)))
print("Test set score: {:.2f}".format(lr.score(X_test, y_test)))

Output:

X.shape (506, 104)

lr.coef_: [-1.66018119e+00 -1.41929759e+00 -5.37684614e-01 7.96954640e-01 7.74009379e-01 9.00801690e+00 -8.92776134e-02 -4.91574523e+00 4.70214703e+00 -5.75434742e-01 -1.03433773e+00 1.77375286e+00 -4.16912180e+00 -2.13431099e-01 3.34424596e-03 -1.04210767e+00 1.56638846e+00 -1.20451306e+00 -1.42821926e+00 -1.61322770e+00 -2.42136076e-01 -1.94292142e+00 -1.67700882e+00 -1.48142670e+00 -1.04731871e+00 -1.11313713e+00 1.49485608e+00 -1.32119098e+00 2.31624450e+00 5.36928772e-01 3.45017547e+00 -1.23455386e+00 -2.35995304e-01 -4.33677055e-01 5.38893908e-01 1.73276291e+00 -1.12104286e+00 -1.80935022e+00 2.88495662e+00 1.82746265e+00 6.32937278e-01 -3.47131888e+00 1.89615705e+00 -3.09731568e+00 1.29031258e+00 3.20064563e+00 -2.05596659e+00 8.12855686e-01 -3.32761682e+00 7.96954640e-01 -5.86013095e+00 -3.57189492e+00 1.58982272e+00 -1.86216410e+00 3.61069409e+00 3.83871054e+00 2.09210783e-01 1.45641163e+00 -3.71898439e+00 -2.43728264e+00 -2.82695659e+00 -1.89357431e+00 -1.00515836e+00 -1.36445946e+00 -1.05970963e+00 -2.79742388e+00 -5.76463641e-01 -8.21276002e-01 1.80618447e+01 -7.76371306e-01 2.51323314e+00 -8.74200296e+00 -9.28927450e+00 -6.35833636e+00 9.81331630e+00 -8.34429422e+00 2.04363934e+00 -2.70371191e+00 3.56231644e+00 4.88560092e-01 -3.63645437e+00 -9.62975567e-01 -5.15644035e+00 9.99195084e-01 -1.06904595e+00 -3.30865649e+00 2.01128756e-01 -4.78203750e+00 -1.26479048e-01 8.78662293e-03 5.62854157e-01 2.54344334e+00 2.60329865e+00 -8.37207151e+00 9.28661900e-01 2.01937829e+00 -7.97643825e-01 -7.26085189e+00 1.76650958e+00 -1.81787063e+00 -6.69991765e-01 2.79044443e-01 -4.99596454e+00 1.12372028e+01] lr.intercept_: 19.772508539375153

Training set score: 0.87

Test set score: 0.81

Ridge Regression cho training score thấp hơn Linear Regression truyền thống nhưng điểm test thực tế lại cao hơn. Bởi vì Ridge đã loại bớt được số lượng các hệ số w, giảm bớt độ phức tạp của mô hình, qua đó tránh được tình trạng overfitting, đạt được genelization với dữ liệu test.

Chúng ta nhận thấy có 01 mối quan hệ nghịch giữa việc giảm số lượng các hệ số w và điểm training score, càng tìm cách để giảm số lượng hệ số w để mô hình đơn giản hơn thì điểm training score càng tồi và ngược lại.  Do đó, trong mô hình Ridge có thêm một hệ số alpha để điều chỉnh. Tăng alpha sẽ làm giảm số lượng các hệ số w (hầu hết các hệ số w quy về giá trị 0) thì điểm training score càng thấp. Ví dụ:

Input: alpha = 10

ridge10 = Ridge(alpha=10).fit(X_train, y_train)
print("Training set score: {:.2f}".format(ridge10.score(X_train, y_train)))
print("Test set score: {:.2f}".format(ridge10.score(X_test, y_test)))

Output: alpha = 10

Training set score: 0.77

Test set score: 0.73

Input: alpha = 0.1

ridge10 = Ridge(alpha=0.1).fit(X_train, y_train)
print("Training set score: {:.2f}".format(ridge10.score(X_train, y_train)))
print("Test set score: {:.2f}".format(ridge10.score(X_test, y_test)))

Ouput: alpha = 0.1

Training set score: 0.92

Test set score: 0.82

Hình vẽ sau biểu diễn mối quan hệ giữa việc điều chỉnh hệ số alpha và số lượng các trọng số w.

Input:

plt.plot(lr.coef_, 's', label="Ridge alpha=1")
plt.plot(ridge10.coef_, '^', label="Ridge alpha=10")
plt.plot(ridge01.coef_, 'v', label="Ridge alpha=0.1")
plt.plot(lr.coef_, 'o', label="LinearRegression")
plt.xlabel("Coefficient index")
plt.ylabel("Coefficient magnitude")
plt.hlines(0, 0, len(lr.coef_))
plt.ylim(-25, 25)
plt.legend()

Output:

Một điểm cần chú ý nữa là số lượng training data càng nhiều thì độ chính xác của các mô hình sẽ càng cao. Hình vẽ sau so sánh kết quả giữa Ridge và Linear sau khi tăng số lượng training và testing data:

Input:

mglearn.plots.plot_ridge_n_samples()

Output:

Hình vẽ này cho thấy training score của Ridge là thấp hơn so với Linear bởi vì Ridge sử dụng chuẩn hóa nhưng testing score của Ridge lại cao hơn Linear, không xảy ra hiện tượng Overfitting như Linear. Với dữ liệu nhỏ hơn 400 thì mô hình Linear gần như là rất tồi. Tuy nhiên khi lượng dữ liệu ngày càng nhiều thì mô hình Linear ngày càng tiệm cận Ridge, lúc đó có vẻ công thức chuẩn hóa của Ridge không còn quan trọng nữa. Một điểm chú ý nữa là khi dữ liệu càng nhiều thì training score của Linear sẽ giảm vì rất khó để có một mô hình có thể Overfitting cho đống dữ liệu nhiều như này.

LASO REGRESSION

Một mô hình anh em với Ridge là Laso, thay vì Ridge sử dụng công thức chuẩn hóa L2 khi tìm hệ số w thì Laso sử dụng công thức chuẩn hóa L1. Sử dụng công thức chuẩn hóa L1 nhằm mục đích loại bớt feature ít ảnh hưởng tới đầu ra nghĩa là làm cho phần lớn các trọng số w = 0.

Công thức chuẩn hóa L1:

Thay vì sử dụng bình phương các trọng số w (chính là bj trong công thức) thì L1 sử dụng hàm abs, để giảm tối đa giá trị trọng số w.

Input:

import numpy as np
from sklearn.linear_model import Lasso
lasso = Lasso().fit(X_train, y_train)
print("X.shape {}".format(X.shape))
print("Training set score: {:.2f}".format(lasso.score(X_train, y_train)))
print("Test set score: {:.2f}".format(lasso.score(X_test, y_test)))
print("lasso.coef_: {}".format(lasso.coef_))
print("Number of features used: {}".format(np.sum(lasso.coef_ != 0)))

print("Number of features used: {}".format(np.sum(lasso.coef_ != 0)))

print("Number of features used: {}".format(np.sum(lasso.coef_ != 0)))

Output:

X.shape (506, 104) Training set score: 0.27 Test set score: 0.26

lasso.coef_: [-0. 0. -0. 0. -0. 0.
-0. 0. -0. -0. -0. 0.
-8.26069561 -0. 0. -0. 0. -0.
-0. -0. -0. -0. -0. -0.
-0. -0. 0. 0. 0. 0.
0. 0. 0. 0. 0. 0.
0. 0. -0. 0. -0. -0.
-0. -0. -0. -0. -0. -0.
-0. 0. 0. 0. 0. 0.
0. 0. 0. 0. -0. -0.
-0. -0. -0. -0. -0. -0.
-0. -0. 0. 0. 0. -0.
-0. -0. 0. -0. -0. -0.
-0. -0. -0.50971544 -0. -0. 0.
-0. -0. -0. 0. -0. -1.13009513
-0. -0. -0. -0. -0. -0.
-0. -0. -0. -0. -0. 0.
-0. -0. ]

Number of features used: 3

Chúng ta thấy một kết quả tồi tệ, xảy ra hiện tượng underfitting bởi Laso đã loại bỏ gần hết các feature, cho ra một mô hình quá đơn giản. Cúng giống như Ridge, Laso có một hệ số alpha để điều chỉnh, mặc định alpha = 1.0, để tránh hiện tượng underfitting, chúng ta sẽ điều chỉnh giảm alpha và tăng tham số mặc định max_iter.

Input:

lasso001 = Lasso(alpha=0.01, max_iter=100000).fit(X_train, y_train)
print("Training set score: {:.2f}".format(lasso001.score(X_train, y_train)))
print("Test set score: {:.2f}".format(lasso001.score(X_test, y_test)))
print("Number of features used: {}".format(np.sum(lasso001.coef_ != 0)))

Output:

Training set score: 0.89

Test set score: 0.80

Number of features used: 34

Kết luận: Trong thực tế, Ridge Regression sẽ là lựa chọn đầu tiên khi xét đến việc sử dụng Ridge hay Lasso. Tuy nhiên với bài toán có số lượng lớn dữ liệu và muốn giảm bớt các nhân tố thuộc tính ảnh hưởng đến kết quả đầu ra cho dễ hiểu thì chúng ta hay sử dụng Lasso hơn. Ngoài ra scikit-learn có lớp ElasticNet cho phép chúng ta sử dụng kết hợp cùng lúc 02 phương pháp Ridge và Lasso bằng cách cho phép điều chỉnh các trọng số sử dụng của chuẩn hóa L1 và L2.

Mô hình Linear cho bài toán phân loại (Linear model for classification)

Mô hình Linear Classification cũng được sử dụng trong bài toán phân loại. Biểu diễn công thức của mô hình cũng tương tự Linear Regression:

ŷ = w[0] * x[0] + w[1] * x[1] + … + w[p] * x[p] + b > 0

Tuy nhiên thay vì trả về con số tổng giá trị của các feature thì đầu ra sẽ được phân loại class là -1 nếu giá trị < 0, phân loại classs là +1 nếu giá trị > 0. Nếu như biểu đồ của Linear Regression thường được vẽ dưới dạng đường thẳng tuyến tính với single feature, dạng mặt phẳng hoặc nhiều mặt phẳng với nhiều thuộc tính multi features thì biểu đồ của Linear Classification biểu diễn dưới dạng các vùng biên ranh giới quyết định và các đường, mặt phẳng chia cắt các ranh giới đó chính là các đường mặt phẳng của Regression.

Có 02 mô hình Linear Classification chính:

  • Logistic Regression: sử dụng class linear_model.LogisticRegression
  • Linear Support Vector Machines: sử dụng class svm.LinearSVC

Ví dụ:

Input:

from sklearn.linear_model import LogisticRegression
from sklearn.svm import LinearSVC
import matplotlib.pyplot as plt
import mglearn

X,y = mglearn.datasets.make_forge()

fig, axes = plt.subplots(1,2, figsize=(10,3))

for model, ax in zip([LinearSVC(), LogisticRegression()], axes):
    clf = model.fit(X, y)
    mglearn.plots.plot_2d_separator(clf, X, fill=False, eps=0.5, ax=ax, alpha=.7)
    mglearn.discrete_scatter(X[:, 0], X[:, 1], y, ax=ax)
    ax.set_title("{}".format(clf.__class__.__name__))
    ax.set_xlabel("Feature 0")
    ax.set_ylabel("Feature 1")
axes[0].legend()

Output:

Cả 02 biểu đồ thể hiện đường kẻ chia ranh giới giữa 02 class 0 và 1. Ở dưới đường ranh giới là class 0, trên đường ranh giới là class 1. Cả 02 mô hình chúng ta thấy có đường biên ranh giới khá giống nhau do đều sử dụng chuẩn L2 regularization tương tự như thuật toán Ridge Regression.

Logistic và SVC có một tham số cho phép điều chỉnh điểm trade-off tối ưu hóa nhất bằng cách điều chỉnh hệ số của chuẩn L2 gọi là C, hệ số C càng cao thì càng tối thiểu hóa giá trị chuẩn hóa, càng dễ khớp với training data, khớp quá thì thành Overfitting, trong khi hệ số C càng thấp thì càng dễ triệt tiêu các trọng số C gây ra hiện tượng Underfitting. Ví dụ:

Input:

mglearn.plots.plot_linear_svc_regularization()

Output:

Chúng ta thấy khi C = 1000 có vẻ mô hình là khớp nhất so với training data, tuy nhiên vẫn bị sai mất 01 điểm. Nhìn chung mô hình Logistic và SVM đều bị hạn chế nếu lượng training data ít. Khi lượng training data nhiều lên thì sức mạnh của cả 02 thuật toán này mới được thể hiện. Sau đây, chúng ta sẽ thử với tập dữ liệu chẩn đoán ung thư của bệnh viện Boston, Mỹ:

Input:

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
cancer.data, cancer.target, stratify=cancer.target, random_state=42)
logreg = LogisticRegression().fit(X_train, y_train)
print("Training set score: {:.3f}".format(logreg.score(X_train, y_train)))
print("Test set score: {:.3f}".format(logreg.score(X_test, y_test)))

Output:

Training set score: 0.955

Test set score: 0.958

Chúng ta nhận thấy kết quả khá tốt với cả Training và Test data, tuy nhiên kết quả Training và Test khá giống nhau, có thể xảy ra hiện tượng underfitting. Chúng ta thử điều chỉnh tham số C để phân tích thêm:

Input:

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
cancer.data, cancer.target, stratify=cancer.target, random_state=42)

logreg = LogisticRegression().fit(X_train, y_train)

print("C=1.Training set score: {:.3f}".format(logreg.score(X_train, y_train)))
print("C=1.Test set score: {:.3f}".format(logreg.score(X_test, y_test)))

logreg100 = LogisticRegression(C=100).fit(X_train, y_train)
print("C=100.Training set score: {:.3f}".format(logreg100.score(X_train, y_train)))
print("C=100.Test set score: {:.3f}".format(logreg100.score(X_test, y_test)))

logreg001 = LogisticRegression(C=0.01).fit(X_train, y_train)
print("C=0.01.Training set score: {:.3f}".format(logreg001.score(X_train, y_train)))
print("C=0.01.Test set score: {:.3f}".format(logreg001.score(X_test, y_test)))

plt.plot(logreg.coef_.T, 'o', label="C=1")
plt.plot(logreg100.coef_.T, '^', label="C=100")
plt.plot(logreg001.coef_.T, 'v', label="C=0.001")
plt.xticks(range(cancer.data.shape[1]), cancer.feature_names, rotation=90)
plt.hlines(0, 0, cancer.data.shape[1])
plt.ylim(-5, 5)
plt.xlabel("Feature")
plt.ylabel("Coefficient magnitude")
plt.legend()

Output:

C=1.Training set score: 0.955

C=1.Test set score: 0.958

C=100.Training set score: 0.972

C=100.Test set score: 0.965

C=0.01.Training set score: 0.934

C=0.01.Test set score: 0.930

Hình vẽ trên cho thấy mối quan hệ giữa các feature với trọng số. Phần lớn các feature có giá trị bằng 0, bị triệt tiêu mức độ ảnh hưởng tới kết quả đầu ra. Các feature có giá trị khác 0 chứng tỏ là những thuộc tính ảnh hưởng lớn tới kết quả đầu ra, ví dụ như “texture error”, “mean radius”. Đồng thời thay đổi trọng số điều chỉnh C cũng cho kết quả khác nhau. Với trọng số C = 100 cho kết quả cao nhất chúng ta thấy khá nhiều feature có giá trị khác 0, mô hình có vẻ phức tạp vì có quá nhiều thuộc tính ảnh hưởng tới kết quả đầu ra. Trường hợp chúng ta muốn tiếp tục loại bớt sự ảnh hưởng của các thuộc tính thì có thể cấu hình sử dụng công thức chuẩn hóa L1.

Input:

for C, marker in zip([0.001, 1, 100], ['o', '^', 'v']):
lr_l1 = LogisticRegression(C=C, penalty="l1").fit(X_train, y_train)
print("Training accuracy of l1 logreg with C={:.3f}: {:.2f}".format(
C, lr_l1.score(X_train, y_train)))
print("Test accuracy of l1 logreg with C={:.3f}: {:.2f}".format(
C, lr_l1.score(X_test, y_test)))
plt.plot(lr_l1.coef_.T, marker, label="C={:.3f}".format(C))
plt.xticks(range(cancer.data.shape[1]), cancer.feature_names, rotation=90)
plt.hlines(0, 0, cancer.data.shape[1])
plt.xlabel("Feature")
plt.ylabel("Coefficient magnitude")
plt.ylim(-5, 5)
plt.legend(loc=3)

Output:

Training accuracy of l1 logreg with C=0.001: 0.91

Test accuracy of l1 logreg with C=0.001: 0.92

Training accuracy of l1 logreg with C=1.000: 0.96

Test accuracy of l1 logreg with C=1.000: 0.96

Training accuracy of l1 logreg with C=100.000: 0.99

Test accuracy of l1 logreg with C=100.000: 0.98

 

 

0 Comments