Python: Tách tập dữ liệu của bạn với train_test_split() của scikit-learning

Các khóa học qua video:
Python SQL Server PHP C# Lập trình C Java HTML5-CSS3-JavaScript
Học trên YouTube <76K/tháng. Đăng ký Hội viên
Viết nhanh hơn - Học tốt hơn
Giải phóng thời gian, khai phóng năng lực
Tách tập dữ liệu của bạn với train_test_split() của scikit-learning

Mục lục bài viết:


Một trong những khía cạnh chính của học máy có giám sát là đánh giá và xác nhận mô hình. Khi bạn đánh giá hiệu suất dự đoán của mô hình của mình, điều cần thiết là quá trình này phải không thiên vị. Sử dụng train_test_split() từ thư viện khoa học dữ liệu scikit-learning, bạn có thể chia tập dữ liệu của mình thành các tập con để giảm thiểu khả năng sai lệch trong quá trình đánh giá và xác nhận của bạn.

Trong hướng dẫn này, bạn sẽ học:

  • Tại sao bạn cần chia nhỏ tập dữ liệu của mình trong học máy được giám sát
  • Tập hợp con nào của tập dữ liệu bạn cần để đánh giá không thiên vị về mô hình của bạn
  • Cách sử dụng train_test_split() để chia nhỏ dữ liệu của bạn
  • Cách kết hợp train_test_split() với các phương pháp dự đoán

Ngoài ra, bạn sẽ nhận được thông tin về các công cụ liên quan từ sklearn.model_selection.

Tầm quan trọng của việc phân tách dữ liệu

Học máy có giám sát là việc tạo ra các mô hình ánh xạ chính xác các đầu vào đã cho (các biến độc lập hoặc các yếu tố dự đoán) với các đầu ra nhất định (các biến phụ thuộc hoặc các phản hồi).

Cách bạn đo độ chính xác của mô hình phụ thuộc vào loại vấn đề bạn đang cố gắng giải quyết. Trong phân tích hồi quy, bạn thường sử dụng các hệ số xác địnhlỗi root-mean-squaresai số tuyệt đối trung bình, hoặc số lượng tương tự. Đối với các bài toán phân loại, bạn thường áp dụng độ chính xácđộ chính xác và độ thu hồiđiểm F1 và các chỉ số liên quan.

Các giá trị số được chấp nhận để đo độ chính xác khác nhau giữa các trường. Bạn có thể tìm thấy giải thích chi tiết từ Statistics By JimQuora, và nhiều tài nguyên khác.

Điều quan trọng nhất cần hiểu là bạn thường cần đánh giá khách quan để sử dụng đúng các biện pháp này, đánh giá hiệu suất dự đoán của mô hình của bạn và xác nhận mô hình.

Điều này có nghĩa là bạn không thể đánh giá hiệu suất dự đoán của một mô hình với cùng dữ liệu mà bạn đã sử dụng để đào tạo. Bạn cần đánh giá mô hình với dữ liệu mới mà mô hình chưa từng thấy trước đây. Bạn có thể thực hiện điều đó bằng cách chia nhỏ tập dữ liệu của mình trước khi sử dụng.

Các tập tào tạo, xác thực, kiểm tra

Tách tập dữ liệu của bạn là điều cần thiết để đánh giá không thiên vị về hiệu suất dự đoán. Trong hầu hết các trường hợp, chỉ cần chia ngẫu nhiên tập dữ liệu của bạn thành ba tập con là đủ:

  1. Tập đào tạo được áp dụng để đào tạo hoặc phù hợp với mô hình của bạn. Ví dụ: bạn sử dụng tập đào tạo để tìm trọng số hoặc hệ số tối ưu cho hồi quy tuyến tínhhồi quy logistic hoặc mạng nơ-ron.
  2. Tập xác thực được sử dụng để đánh giá mô hình không thiên vị trong quá trình điều chỉnh siêu tham số. Ví dụ: khi bạn muốn tìm số lượng nơ-ron tối ưu trong mạng nơ-ron hoặc hạt nhân tốt nhất cho máy vectơ hỗ trợ, bạn kiểm tra với các giá trị khác nhau. Đối với mỗi cài đặt siêu tham số được xem xét, bạn điều chỉnh mô hình với tập đào tạo và đánh giá hiệu suất của nó với tập xác thực.
  3. Tập kiểm tra là cần thiết để đánh giá không khách quan về mô hình cuối cùng. Bạn không nên sử dụng nó để khớp hoặc xác thực.

Trong những trường hợp ít phức tạp hơn, khi bạn không phải điều chỉnh các siêu tham số, bạn chỉ có thể làm việc với các tập đào tạo và kiểm tra.

Underfitting và Overfitting

Việc chia nhỏ một tập dữ liệu cũng có thể quan trọng để phát hiện xem mô hình của bạn có gặp phải một trong hai vấn đề rất phổ biến, được gọi là thiếu trang bị và trang bị thừa hay không:

  1. Việc trang bị thiếu (underfitting) thường là hậu quả của việc một mô hình không thể đóng gói các mối quan hệ giữa các dữ liệu. Ví dụ, điều này có thể xảy ra khi cố gắng biểu diễn các quan hệ phi tuyến với một mô hình tuyến tính. Những bộ mẫu thiếu trang bị có thể sẽ có hiệu suất kém với cả tập đào tạo và tập kiểm tra.
  2. Overfitting (trang bị thừa) thường diễn ra khi một mô hình có cấu trúc quá phức tạp và học được cả các mối quan hệ hiện có giữa dữ liệu và nhiễu. Những mô hình như vậy thường có khả năng tổng quát hóa không tốt. Mặc dù chúng hoạt động tốt với dữ liệu đào tạo, chúng thường mang lại hiệu suất kém với dữ liệu không nhìn thấy (kiểm tra).

Bạn có thể tìm thấy giải thích chi tiết hơn về trang bị thiếu và trang bị thừa trong Hồi quy tuyến tính bằng Python.

Điều kiện tiên quyết để sử dụng train_test_split()

Bây giờ bạn hiểu sự cần thiết phải chia nhỏ tập dữ liệu để thực hiện đánh giá mô hình không thiên vị và xác định trang bị thiếu hoặc trang bị quá mức, bạn đã sẵn sàng tìm hiểu cách chia tập dữ liệu của riêng mình.

Bạn sẽ sử dụng phiên bản 0.23.1 của scikit-learning, hoặc sklearn. Nó có nhiều gói cho khoa học dữ liệu và máy học, nhưng đối với hướng dẫn này, bạn sẽ tập trung vào gói model_selection, cụ thể là về hàm train_test_split().

Bạn có thể cài đặt sklearn với pip install:

$ python -m pip install -U "scikit-learn==0.23.1"

Nếu bạn sử dụng Anaconda, thì có thể bạn đã cài đặt nó. Tuy nhiên, nếu bạn muốn sử dụng một môi trường mới, hãy đảm bảo rằng bạn có phiên bản được chỉ định hoặc sử dụng Miniconda, sau đó bạn có thể cài đặt sklearn từ Anaconda Cloud với conda install:

$ conda install -c anaconda scikit-learn=0.23

Bạn cũng sẽ cần NumPy, nhưng bạn không cần phải cài đặt riêng nó. Bạn nên sử dụng nó với sklearn nếu bạn chưa cài đặt nó. Nếu bạn muốn làm mới kiến ​​thức NumPy của mình, hãy xem tài liệu chính thức hoặc xem Look Ma, No For-Loops: Array Programming With NumPy.

Ứng dụng của train_test_split()

Bạn cần import train_test_split() và NumPy trước khi có thể sử dụng chúng, vì vậy bạn có thể bắt đầu với các câu lệnh import:

>>> import numpy as np
>>> from sklearn.model_selection import train_test_split

Bây giờ bạn đã import cả hai rồi, bạn có thể sử dụng chúng để chia dữ liệu thành các tập đào tạo và tập kiểm tra. Bạn sẽ phân chia đầu vào và đầu ra cùng một lúc, chỉ với một lệnh gọi hàm duy nhất.

Với train_test_split(), bạn cần cung cấp các trình tự mà bạn muốn tách cũng như bất kỳ đối số tùy chọn nào. Nó trả về danh sách các mảng NumPy, các chuỗi khác hoặc ma trận thưa thớt SciPy nếu thích hợp:

sklearn.model_selection.train_test_split(*arrays, **options) -> list

arrays là chuỗi danh sách , mảng NumPyDataFrames gấu trúc hoặc các đối tượng giống mảng tương tự chứa dữ liệu bạn muốn tách. Tất cả các đối tượng này cùng nhau tạo nên tập dữ liệu và phải có cùng độ dài.

Trong các ứng dụng học máy được giám sát, bạn thường sẽ làm việc với hai trình tự như sau:

  1. Một mảng hai chiều với các đầu vào (x)
  2. Mảng một chiều với các kết quả đầu ra (y)

options là các đối số từ khóa tùy chọn mà bạn có thể sử dụng để có được hành vi mong muốn:

  • train_size là số xác định kích thước của tập đào tạo. Nếu bạn cung cấp một giá trị float, thì nó phải nằm giữa 0.0 và 1.0 và sẽ xác định phần chia sẻ của tập dữ liệu được sử dụng để kiểm tra. Nếu bạn cung cấp một giá trị int, thì nó sẽ đại diện cho tổng số mẫu đào tạo. Giá trị mặc định là None.
  • test_size là số xác định kích thước của tập kiểm tra. Nó rất giống với train_size. Bạn nên cung cấp một trong hai train_size oặc test_size. Nếu cả hai đều không được đưa ra, thì phần mặc định của tập dữ liệu sẽ được sử dụng để kiểm tra là 0.25 hay 25%.
  • random_state là đối tượng điều khiển sự ngẫu nhiên trong quá trình tách. Nó có thể là một số int hoặc một đối tượng của RandomState. Giá trị mặc định là None.
  • shuffle là đối tượng Boolean (mặc định là True) xác định xem có xáo trộn tập dữ liệu trước khi áp dụng phân tách hay không.
  • stratify là một đối tượng giống mảng, nếu không phải là None thì nó sẽ xác định cách sử dụng phân chia phân tầng.

Bây giờ đã đến lúc thử chia nhỏ dữ liệu! Bạn sẽ bắt đầu bằng cách tạo một tập dữ liệu đơn giản để làm việc. Tập dữ liệu sẽ chứa các đầu vào trong mảng hai chiều x và đầu ra trong mảng một chiều y:

>>> x = np.arange(1, 25).reshape(12, 2)
>>> y = np.array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])
>>> x
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16],
       [17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y
array([0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0])

Để lấy dữ liệu của bạn, bạn sử dụng arange(), nó rất thuận tiện để tạo mảng dựa trên phạm vi số. Bạn cũng sử dụng .reshape() để sửa đổi hình dạng của mảng được trả về arange() và nhận cấu trúc dữ liệu hai chiều.

Bạn có thể tách cả tập dữ liệu đầu vào và đầu ra bằng một lệnh gọi hàm duy nhất:

>>> x_train, x_test, y_train, y_test = train_test_split(x, y)
>>> x_train
array([[15, 16],
       [21, 22],
       [11, 12],
       [17, 18],
       [13, 14],
       [ 9, 10],
       [ 1,  2],
       [ 3,  4],
       [19, 20]])
>>> x_test
array([[ 5,  6],
       [ 7,  8],
       [23, 24]])
>>> y_train
array([1, 1, 0, 1, 0, 1, 0, 1, 0])
>>> y_test
array([1, 0, 0])

Cho hai chuỗi, như x và y ở đây, train_test_split() thực hiện tách và trả về bốn chuỗi (trong trường hợp này là mảng NumPy) theo thứ tự sau:

  1. x_train: Phần đào tạo của dãy số đầu tiên (x)
  2. x_test: Phần kiểm tra của chuỗi đầu tiên (x)
  3. y_train: Phần đào tạo của chuỗi thứ hai (y)
  4. y_test: Phần kiểm tra của chuỗi thứ hai (y)

Bạn có thể nhận được kết quả khác với những gì bạn thấy ở đây. Điều này là do việc chia nhỏ tập dữ liệu là ngẫu nhiên theo mặc định. Kết quả khác nhau mỗi khi bạn chạy hàm. Tuy nhiên, đây thường không phải là điều bạn muốn.

Đôi khi, để làm cho các kiểm tra của bạn có thể tái tạo, bạn cần một phân tách ngẫu nhiên với cùng một đầu ra cho mỗi lệnh gọi hàm. Bạn có thể làm điều đó với tham số random_state. Giá trị của random_state không quan trọng — nó có thể là bất kỳ số nguyên không âm nào. Bạn có thể sử dụng một đối tượng của numpy.random.RandomState để thay thế, nhưng đó là một cách tiếp cận phức tạp hơn.

Trong ví dụ trước, bạn đã sử dụng tập dữ liệu có mười hai quan sát (hàng) và nhận được một mẫu đào tạo có chín hàng và một mẫu kiểm tra có ba hàng. Đó là bởi vì bạn đã không chỉ định kích thước mong muốn của các tập đào tạo và kiểm tra. Theo mặc định, 25% mẫu được chỉ định cho tập kiểm tra. Tỷ lệ này nói chung là ổn cho nhiều ứng dụng, nhưng không phải lúc nào nó cũng là thứ bạn cần.

Thông thường, bạn sẽ muốn xác định kích thước của tập kiểm tra (hoặc đào tạo) một cách rõ ràng và đôi khi bạn thậm chí sẽ muốn kiểm tra với các giá trị khác nhau. Bạn có thể làm điều đó với các tham số train_size hoặc test_size.

Sửa đổi code để bạn có thể chọn kích thước của tập kiểm tra và nhận được kết quả có thể lặp lại:

>>> x_train, x_test, y_train, y_test = train_test_split(
...     x, y, test_size=4, random_state=4
... )
>>> x_train
array([[17, 18],
       [ 5,  6],
       [23, 24],
       [ 1,  2],
       [ 3,  4],
       [11, 12],
       [15, 16],
       [21, 22]])
>>> x_test
array([[ 7,  8],
       [ 9, 10],
       [13, 14],
       [19, 20]])
>>> y_train
array([1, 1, 0, 0, 1, 0, 1, 1])
>>> y_test
array([0, 1, 0, 0])

Với thay đổi này, bạn sẽ nhận được một kết quả khác với trước đây. Trước đó, bạn đã có một tập đào tạo với chín mục và bộ kiểm tra với ba mục. Bây giờ, nhờ đối số test_size=4, tập đào tạo có tám mục và tập kiểm tra có bốn mục. Bạn sẽ nhận được kết quả tương tự test_size=0.33 vì 33% của mười hai là xấp xỉ bốn.

Có một sự khác biệt rất quan trọng giữa hai ví dụ cuối cùng: Bây giờ bạn nhận được cùng một kết quả mỗi khi bạn chạy hàm. Điều này là do bạn đã sửa trình tạo số ngẫu nhiên với random_state=4.

Hình dưới đây cho thấy những gì đang xảy ra khi bạn gọi train_test_split():

mmst-train-test-split-1

Các mẫu của tập dữ liệu được xáo trộn ngẫu nhiên và sau đó được chia thành các tập đào tạo và kiểm tra theo kích thước bạn đã xác định.

Bạn có thể thấy rằng y có sáu số không và sáu số một. Tuy nhiên, tập kiểm tra có ba số không trong số bốn mục. Nếu bạn muốn (gần đúng) giữ nguyên tỷ lệ của các giá trị y thông qua các tập đào tạo và kiểm tra, thì bạn hãy truyền stratify=y. Điều này sẽ cho phép tách phân tầng:

>>> x_train, x_test, y_train, y_test = train_test_split(
...     x, y, test_size=0.33, random_state=4, stratify=y
... )
>>> x_train
array([[21, 22],
       [ 1,  2],
       [15, 16],
       [13, 14],
       [17, 18],
       [19, 20],
       [23, 24],
       [ 3,  4]])
>>> x_test
array([[11, 12],
       [ 7,  8],
       [ 5,  6],
       [ 9, 10]])
>>> y_train
array([1, 0, 1, 0, 1, 0, 0, 1])
>>> y_test
array([0, 0, 1, 1])

Bây giờ y_train và y_test có cùng tỷ lệ số không và số một như mảng y ban đầu.

Phân chia phân tầng là mong muốn trong một số trường hợp, như khi bạn đang phân loại một tập dữ liệu không cân bằng, một tập dữ liệu có sự khác biệt đáng kể về số lượng mẫu thuộc các lớp riêng biệt.

Cuối cùng, bạn có thể tắt xáo trộn dữ liệu và phân chia ngẫu nhiên bằng shuffle=False:

>>> x_train, x_test, y_train, y_test = train_test_split(
...     x, y, test_size=0.33, shuffle=False
... )
>>> x_train
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12],
       [13, 14],
       [15, 16]])
>>> x_test
array([[17, 18],
       [19, 20],
       [21, 22],
       [23, 24]])
>>> y_train
array([0, 1, 1, 0, 1, 0, 0, 1])
>>> y_test
array([1, 0, 1, 0])

Bây giờ bạn có một phần tách trong đó hai phần ba mẫu đầu tiên trong mảng x và mảng y ban đầu được gán cho tập đào tạo và một phần ba cuối cùng cho tập kiểm tra. Không xáo trộn. Không có ngẫu nhiên.

Học máy được giám sát với train_test_split()

Bây giờ đã đến lúc train_test_split() hành động khi giải quyết các vấn đề học tập có giám sát. Bạn sẽ bắt đầu với một vấn đề hồi quy nhỏ có thể được giải quyết bằng hồi quy tuyến tính trước khi xem xét một vấn đề lớn hơn. Bạn cũng sẽ thấy rằng bạn cũng có thể sử dụng train_test_split() để phân loại.

Ví dụ tối giản về hồi quy tuyến tính

Trong ví dụ này, bạn sẽ áp dụng những gì bạn đã học để giải quyết một vấn đề hồi quy nhỏ. Bạn sẽ học cách tạo tập dữ liệu, chia chúng thành các tập con đào tạo và kiểm tra, đồng thời sử dụng chúng để hồi quy tuyến tính.

Như mọi khi, bạn sẽ bắt đầu bằng cách import các gói, hàm hoặc lớp cần thiết. Bạn sẽ cần NumPy LinearRegression và train_test_split():

>>> import numpy as np
>>> from sklearn.linear_model import LinearRegression
>>> from sklearn.model_selection import train_test_split

Bây giờ bạn đã import mọi thứ mình cần, bạn có thể tạo hai mảng nhỏ x và y để đại diện cho các quan sát và sau đó chia chúng thành các tập đào tạo và kiểm tra giống như bạn đã làm trước đây:

>>> x = np.arange(20).reshape(-1, 1)
>>> y = np.array([5, 12, 11, 19, 30, 29, 23, 40, 51, 54, 74,
...               62, 68, 73, 89, 84, 89, 101, 99, 106])
>>> x
array([[ 0],
       [ 1],
       [ 2],
       [ 3],
       [ 4],
       [ 5],
       [ 6],
       [ 7],
       [ 8],
       [ 9],
       [10],
       [11],
       [12],
       [13],
       [14],
       [15],
       [16],
       [17],
       [18],
       [19]])
>>> y
array([  5,  12,  11,  19,  30,  29,  23,  40,  51,  54,  74,  62,  68,
        73,  89,  84,  89, 101,  99, 106])
>>> x_train, x_test, y_train, y_test = train_test_split(
...     x, y, test_size=8, random_state=0
... )

Tập dữ liệu của bạn có hai mươi quan sát hoặc cặp x-y. Bạn chỉ định đối số test_size=8, do đó, tập dữ liệu được chia thành tập đào tạo với mười hai quan sát và tập kiểm tra với tám quan sát.

Bây giờ bạn có thể sử dụng tập đào tạo để phù hợp với mô hình:

>>> model = LinearRegression().fit(x_train, y_train)
>>> model.intercept_
3.1617195496417523
>>> model.coef_
array([5.53121801])

LinearRegression tạo đối tượng đại diện cho mô hình, trong khi .fit() đào tạo hoặc chỉnh sửa mô hình và trả về. Với hồi quy tuyến tính, phù hợp với mô hình có nghĩa là xác định các giá trị chặn (model.intercept_) và độ dốc (model.coef_) tốt nhất của đường hồi quy.

Mặc dù bạn có thể sử dụng x_train và y_train để kiểm tra độ vừa vặn, nhưng đây không phải là cách tốt nhất. Ước tính không thiên vị về hiệu suất dự đoán của mô hình của bạn dựa trên dữ liệu kiểm tra:

>>> model.score(x_train, y_train)
0.9868175024574795
>>> model.score(x_test, y_test)
0.9465896927715023

.score() trả về hệ số xác định, hoặc R ², cho dữ liệu được truyền. Tối đa của nó là 1. Giá trị R ² càng cao thì càng phù hợp. Trong trường hợp này, dữ liệu đào tạo mang lại hệ số cao hơn một chút. Tuy nhiên, R ² được tính toán với dữ liệu kiểm tra là một thước đo không thiên vị về hiệu suất dự đoán của mô hình của bạn.

Trên biểu đồ nó trông giống như sau:

mmst-train-test-split-2

Các chấm màu xanh lá cây đại diện cho các cặp x-y được sử dụng để đào tạo. Đường màu đen, được gọi là đường hồi quy ước tính, được xác định bởi kết quả của việc điều chỉnh mô hình: điểm chặn và độ dốc. Vì vậy, nó chỉ phản ánh vị trí của các chấm màu xanh lá cây.

Các chấm trắng đại diện cho tập kiểm tra. Bạn sử dụng chúng để ước tính hiệu suất của mô hình (đường hồi quy) với dữ liệu không được sử dụng để đào tạo.

Ví dụ về hồi quy

Bây giờ bạn đã sẵn sàng chia một tập dữ liệu lớn hơn để giải quyết vấn đề hồi quy. Bạn sẽ sử dụng tập dữ liệu giá nhà nổi tiếng ở Boston, được đưa vào trong tập dữ liệu sklearn. Tập dữ liệu này có 506 mẫu, 13 biến đầu vào và các giá trị nội bộ là đầu ra. Bạn có thể lấy nó bằng load_boston().

Đầu tiên, ta cần import train_test_split() và load_boston():

>>> from sklearn.datasets import load_boston
>>> from sklearn.model_selection import train_test_split

Bây giờ bạn đã nhập cả hai hàm, bạn có thể lấy dữ liệu để làm việc:

>>> x, y = load_boston(return_X_y=True)

Như bạn có thể thấy, load_boston() với đối số return_X_y=True trả về một bộ giá trị có hai mảng NumPy:

  1. Một mảng hai chiều với các đầu vào
  2. Mảng một chiều với các đầu ra

Bước tiếp theo là tách dữ liệu theo cách giống như trước:

>>> x_train, x_test, y_train, y_test = train_test_split(
...     x, y, test_size=0.4, random_state=0
... )

Bây giờ bạn có các bộ đào tạo và kiểm tra. Dữ liệu đào tạo được chứa trong x_train và y_train, trong khi dữ liệu để kiểm tra nằm trong x_test và y_test.

Khi bạn làm việc với các tập dữ liệu lớn hơn, thường sẽ thuận tiện hơn khi vượt qua kích thước đào tạo hoặc kiểm tra dưới dạng một tỷ lệ. test_size=0.4 có nghĩa là khoảng 40 phần trăm mẫu sẽ được gán cho dữ liệu kiểm tra và 60 phần trăm còn lại sẽ được gán cho dữ liệu đào tạo.

Cuối cùng, bạn có thể sử dụng tập đào tạo (x_train và y_train) để phù hợp với mô hình và tập kiểm tra (x_test và y_test) để đánh giá không thiên vị về mô hình. Trong ví dụ này, bạn sẽ áp dụng ba thuật toán hồi quy nổi tiếng để tạo các mô hình phù hợp với dữ liệu của bạn:

  1. Hồi quy tuyến tính với LinearRegression()
  2. Tăng cường Gradient với GradientBoostingRegressor()
  3. Rừng ngẫu nhiên với RandomForestRegressor()

Quá trình này khá giống với ví dụ trước:

  1. Nhập các lớp bạn cần.
  2. Tạo các đối tượng mô hình bằng cách sử dụng các lớp này.
  3. Điều chỉnh các phiên bản mô hình với .fit() sử dụng tập đào tạo.
  4. Đánh giá mô hình với .score() sử dụng tập kiểm tra.

Đây là mã thực hiện theo các bước được mô tả ở trên cho cả ba thuật toán hồi quy:

>>> from sklearn.linear_model import LinearRegression
>>> model = LinearRegression().fit(x_train, y_train)
>>> model.score(x_train, y_train)
0.7668160223286261
>>> model.score(x_test, y_test)
0.6882607142538016

>>> from sklearn.ensemble import GradientBoostingRegressor
>>> model = GradientBoostingRegressor(random_state=0).fit(x_train, y_train)
>>> model.score(x_train, y_train)
0.9859065238883613
>>> model.score(x_test, y_test)
0.8530127436482149

>>> from sklearn.ensemble import RandomForestRegressor
>>> model = RandomForestRegressor(random_state=0).fit(x_train, y_train)
>>> model.score(x_train, y_train)
0.9811695664860354
>>> model.score(x_test, y_test)
0.8325867908704008

Bạn đã sử dụng tập dữ liệu đào tạo và kiểm tra của mình để phù hợp với ba mô hình và đánh giá hiệu suất của chúng. Thước đo độ chính xác với .score() là hệ số xác định. Nó có thể được tính toán bằng tập đào tạo hoặc kiểm tra. Tuy nhiên, như bạn đã học, điểm số thu được với tập kiểm tra đại diện cho một ước tính không thiên vị về hiệu suất.

Như đã đề cập trong tài liệu, bạn có thể cung cấp các đối số tùy chọn tới LinearRegression()GradientBoostingRegressor() và RandomForestRegressor().GradientBoostingRegressor() và RandomForestRegressor() sử dụng tham số random_state cho cùng một lý do mà train_test_split() thực thi: để xử lý tính ngẫu nhiên trong các thuật toán và đảm bảo khả năng tái lập.

Đối với một số phương thức, bạn cũng có thể cần mở rộng tính năng. Trong những trường hợp như vậy, bạn nên điều chỉnh tỷ lệ với dữ liệu đào tạo và sử dụng chúng để biến đổi dữ liệu kiểm tra.

Ví dụ về phân loại

Bạn có thể sử dụng train_test_split() để giải quyết các vấn đề phân loại giống như cách bạn làm để phân tích hồi quy. Trong học máy, các vấn đề phân loại liên quan đến việc đào tạo một mô hình để áp dụng các nhãn hoặc phân loại, các giá trị đầu vào và sắp xếp tập dữ liệu của bạn thành các danh mục.

Trong hướng dẫn Hồi quy logistic với Python, bạn sẽ tìm thấy một ví dụ về tác vụ nhận dạng chữ viết tay. Ví dụ này cung cấp một minh chứng khác về việc chia nhỏ dữ liệu thành các tập đào tạo và kiểm tra để tránh sai lệch trong quá trình đánh giá.

Các chức năng xác thực khác

Gói sklearn.model_selection cung cấp rất nhiều chức năng liên quan đến việc lựa chọn và xác thực mô hình, bao gồm những điều sau:

  • Xác thực chéo
  • Đường cong học tập
  • Điều chỉnh siêu tham số

Xác thực chéo là một tập hợp các kỹ thuật kết hợp các thước đo về hiệu suất dự đoán để có được các ước tính mô hình chính xác hơn.

Một trong những phương pháp xác thực chéo được sử dụng rộng rãi là xác thực chéo k- lần. Trong đó, bạn chia tập dữ liệu của mình thành k (thường là năm hoặc mười) tập con, hoặc các phần gấp (fold), có kích thước bằng nhau và sau đó thực hiện các quy trình đào tạo và kiểm tra k lần. Mỗi lần, bạn sử dụng một nếp gấp khác nhau làm tập kiểm tra và tất cả các nếp gấp còn lại làm bộ đào tạo. Điều này cung cấp k số đo về hiệu suất dự đoán và sau đó bạn có thể phân tích giá trị trung bình và độ lệch chuẩn của chúng.

Bạn có thể thực hiện qua xác nhận với KFoldStratifiedKFoldLeaveOneOut, và một vài lớp khác và các hàm từ sklearn.model_selection.

Một đường cong học tập, đôi khi được gọi là một đường cong đào tạo, cho biết cách số điểm dự đoán của đào tạo và xác nhận bộ phụ thuộc vào số lượng mẫu đào tạo. Bạn có thể sử dụng learning_curve() để có được sự phụ thuộc này, có thể giúp bạn tìm kích thước tối ưu của tập đào tạo, chọn siêu tham số, so sánh các mô hình, v.v.

Điều chỉnh siêu tham số, còn được gọi là tối ưu hóa siêu tham số, là quá trình xác định bộ siêu tham số tốt nhất để xác định mô hình học máy của bạn. sklearn.model_selection cung cấp cho bạn một số tùy chọn cho mục đích này, bao gồm GridSearchCVRandomizedSearchCVvalidation_curve(), và một số khác. Việc chia nhỏ dữ liệu của bạn cũng rất quan trọng để điều chỉnh siêu tham số.

Phần kết luận

Bây giờ bạn đã biết tại sao và làm thế nào để sử dụng train_test_split() từ sklearn. Bạn đã học được rằng, để ước tính khách quan về hiệu suất dự đoán của các mô hình học máy, bạn nên sử dụng dữ liệu chưa được sử dụng để điều chỉnh mô hình. Đó là lý do tại sao bạn cần chia tập dữ liệu của mình thành các tập con đào tạo, kiểm tra và trong một số trường hợp có cả xác thực.

Trong hướng dẫn này, bạn đã học cách:

  • Sử dụng train_test_split() để nhận bộ đào tạo và kiểm tra
  • Kiểm soát kích thước của các tập hợp con bằng các tham số train_size và test_size
  • Xác định mức độ ngẫu nhiên của các phần tách của bạn với tham số random_state
  • Nhận các phân chia phân tầng với tham số stratify
  • Sử dụng train_test_split() như một phần của quy trình học máy được giám sát

Bạn cũng đã thấy rằng module sklearn.model_selection cung cấp một số công cụ khác để xác thực mô hình, bao gồm xác thực chéo, đường cong học tập và điều chỉnh siêu tham số.

» Tiếp: Nhận dạng khuôn mặt với dưới 25 dòng mã Python
« Trước: Hồi quy tuyến tính trong Python
Các khóa học qua video:
Python SQL Server PHP C# Lập trình C Java HTML5-CSS3-JavaScript
Học trên YouTube <76K/tháng. Đăng ký Hội viên
Viết nhanh hơn - Học tốt hơn
Giải phóng thời gian, khai phóng năng lực
Copied !!!