Khám phá số liệu thống kê bằng python

Trong phần này, chúng tôi giới thiệu từ vựng học máy mà chúng tôi sử dụng trong suốt quá trình học scikit và đưa ra một ví dụ học tập đơn giản

học máy. cách đặt vấn đề¶

Nói chung, một vấn đề học tập xem xét một tập hợp n mẫu dữ liệu và sau đó cố gắng dự đoán các thuộc tính của dữ liệu chưa biết. Nếu mỗi mẫu có nhiều hơn một số và, ví dụ, một mục nhập đa chiều (còn gọi là dữ liệu đa biến), nó được cho là có một số thuộc tính hoặc tính năng

Các vấn đề học tập rơi vào một vài loại

Tập huấn luyện và tập kiểm tra

Học máy là học một số thuộc tính của một tập dữ liệu và sau đó kiểm tra các thuộc tính đó với một tập dữ liệu khác. Một thực tế phổ biến trong học máy là đánh giá một thuật toán bằng cách chia một tập dữ liệu thành hai. Chúng tôi gọi một trong những tập hợp đó là tập huấn luyện, trên đó chúng tôi tìm hiểu một số thuộc tính;

Đang tải tập dữ liệu mẫu¶

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
3 đi kèm với một vài bộ dữ liệu tiêu chuẩn, chẳng hạn như bộ dữ liệu mống mắt và chữ số để phân loại và bộ dữ liệu bệnh tiểu đường để hồi quy

Trong phần sau đây, chúng tôi bắt đầu trình thông dịch Python từ trình bao của chúng tôi và sau đó tải bộ dữ liệu

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
4 và
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
5. Quy ước công chứng của chúng tôi là
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
6 biểu thị dấu nhắc hệ vỏ trong khi
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
7 biểu thị dấu nhắc trình thông dịch Python

$ python
>>> from sklearn import datasets
>>> iris = datasets.load_iris()
>>> digits = datasets.load_digits()

Tập dữ liệu là một đối tượng giống như từ điển chứa tất cả dữ liệu và một số siêu dữ liệu về dữ liệu. Dữ liệu này được lưu trữ trong thành viên

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
8, là một mảng
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
9. Trong trường hợp các vấn đề được giám sát, một hoặc nhiều biến phản hồi được lưu trữ trong thành viên
>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])
0. Bạn có thể tìm thêm chi tiết về các bộ dữ liệu khác nhau trong phần dành riêng .

Chẳng hạn, trong trường hợp tập dữ liệu chữ số,

>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])
1 cấp quyền truy cập vào các tính năng có thể được sử dụng để phân loại các mẫu chữ số

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]

>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])
2 đưa ra sự thật cơ bản cho tập dữ liệu chữ số, đó là số tương ứng với mỗi hình ảnh chữ số mà chúng tôi đang cố gắng tìm hiểu

________số 8

Hình dạng của mảng dữ liệu

Dữ liệu luôn là mảng 2D, hình dạng

>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])
3, mặc dù dữ liệu gốc có thể có hình dạng khác. Trong trường hợp các chữ số, mỗi mẫu ban đầu là một hình ảnh có hình dạng
>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])
4 và có thể được truy cập bằng cách sử dụng

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
5

Ví dụ đơn giản về tập dữ liệu này minh họa cách bắt đầu từ vấn đề ban đầu, người ta có thể định hình dữ liệu để sử dụng trong scikit-learning.

Đang tải từ bộ dữ liệu bên ngoài

Để tải từ tập dữ liệu ngoài, vui lòng tham khảo tải tập dữ liệu ngoài .

Học hỏi và dự đoán¶

Trong trường hợp tập dữ liệu chữ số, nhiệm vụ là dự đoán, cho trước một hình ảnh, nó đại diện cho chữ số nào. Chúng tôi được cung cấp các mẫu của mỗi trong số 10 lớp có thể (các chữ số từ 0 đến 9) trên đó chúng tôi phù hợp với một công cụ ước tính để có thể dự đoán các lớp mà các mẫu không nhìn thấy thuộc về

Trong scikit-learning, một công cụ ước tính để phân loại là một đối tượng Python thực hiện các phương thức

>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])
5 và
>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])
6

Một ví dụ về công cụ ước tính là lớp

>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])
7, thực hiện phân loại vectơ hỗ trợ. Hàm tạo của công cụ ước tính lấy các tham số của mô hình làm đối số

Bây giờ, chúng tôi sẽ coi công cụ ước tính là một hộp đen

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
9

Lựa chọn các thông số của mô hình

Trong ví dụ này, chúng tôi đặt giá trị của

>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])
8 theo cách thủ công. Để tìm giá trị tốt cho các tham số này, chúng ta có thể sử dụng các công cụ như tìm kiếm theo lướixác thực chéo.

Phiên bản ước tính

>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])
9 (đối với bộ phân loại) lần đầu tiên được trang bị cho mô hình; . Điều này được thực hiện bằng cách chuyển tập huấn luyện của chúng ta sang phương thức
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
50. Đối với tập huấn luyện, chúng tôi sẽ sử dụng tất cả các hình ảnh từ tập dữ liệu của mình, ngoại trừ hình ảnh cuối cùng mà chúng tôi sẽ dự đoán. Chúng tôi chọn tập huấn luyện với cú pháp Python
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
51, cú pháp này tạo ra một mảng mới chứa tất cả trừ mục cuối cùng từ
>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])
1

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
5

Bây giờ bạn có thể dự đoán các giá trị mới. Trong trường hợp này, bạn sẽ dự đoán bằng hình ảnh cuối cùng từ

>>> digits.target
array([0, 1, 2, ..., 8, 9, 8])
1. Bằng cách dự đoán, bạn sẽ xác định hình ảnh từ tập huấn luyện phù hợp nhất với hình ảnh cuối cùng

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
7

Hình ảnh tương ứng là

Khám phá số liệu thống kê bằng python

Như bạn có thể thấy, đó là một nhiệm vụ đầy thách thức. Rốt cuộc, hình ảnh có độ phân giải kém. Bạn có đồng ý với bộ phân loại không?

Một ví dụ hoàn chỉnh về vấn đề phân loại này có sẵn dưới dạng ví dụ mà bạn có thể chạy và nghiên cứu. Nhận dạng chữ số viết tay .

Quy ước¶

công cụ ước tính scikit-learning tuân theo các quy tắc nhất định để làm cho hành vi của họ dễ dự đoán hơn. Những điều này được mô tả chi tiết hơn trong Bảng thuật ngữ thuật ngữ chung và các thành phần API .

Đúc kiểu¶

Trừ khi có quy định khác, đầu vào sẽ được chuyển thành

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
54

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
9

Trong ví dụ này,

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
55 là
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
56, được chuyển thành
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
54 bởi
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
58

Các mục tiêu hồi quy được chuyển thành

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
54 và các mục tiêu phân loại được duy trì

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
5

Ở đây,

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
90 đầu tiên trả về một mảng số nguyên, vì
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
91 (một mảng số nguyên) đã được sử dụng trong
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
50.
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
90 thứ hai trả về một mảng chuỗi, vì
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
94 là để khớp

Tinh chỉnh và cập nhật thông số¶

Có thể cập nhật siêu tham số của công cụ ước tính sau khi công cụ ước tính được tạo thông qua phương thức set_params() . Gọi

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
95 nhiều lần sẽ ghi đè lên những gì đã học được bởi bất kỳ
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
95 nào trước đó.

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
3

Ở đây, kernel mặc định

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
97 lần đầu tiên được thay đổi thành
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
98 qua
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
99 sau khi công cụ ước tính đã được xây dựng và được thay đổi trở lại thành
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
97 để điều chỉnh lại công cụ ước tính và đưa ra dự đoán thứ hai

Đa lớp vs. lắp nhiều nhãn¶

Khi sử dụng

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
51, nhiệm vụ học tập và dự đoán được thực hiện phụ thuộc vào định dạng của dữ liệu đích phù hợp với

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
0

Trong trường hợp trên, bộ phân loại phù hợp với mảng 1d của các nhãn đa lớp và do đó, phương thức

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
90 cung cấp các dự đoán đa lớp tương ứng. Nó cũng có thể phù hợp với một mảng 2d của các chỉ báo nhãn nhị phân

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
1

Ở đây, bộ phân loại là

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
95 trên biểu diễn nhãn nhị phân 2d của
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
54, sử dụng
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
55. Trong trường hợp này,
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
90 trả về một mảng 2d biểu thị các dự đoán đa nhãn tương ứng

Lưu ý rằng phiên bản thứ tư và thứ năm trả về tất cả các số 0, cho biết rằng chúng không khớp với nhãn nào trong ba nhãn

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
50 khi. Với đầu ra nhiều nhãn, tương tự như vậy, một phiên bản có thể được gán nhiều nhãn

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
2

Trong trường hợp này, trình phân loại phù hợp với các trường hợp từng được gán nhiều nhãn.

>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
58 được sử dụng để nhị phân hóa mảng 2d của nhiều nhãn thành
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
50 khi. Kết quả là,
>>> print(digits.data)
[[ 0.   0.   5. ..   0.   0.   0.]
 [ 0.   0.   0. ..  10.   0.   0.]
 [ 0.   0.   0. ..  16.   9.   0.]
 ...
 [ 0.   0.   1. ..   6.   0.   0.]
 [ 0.   0.   2. ..  12.   0.   0.]
 [ 0.   0.  10. ..  12.   1.   0.]]
90 trả về một mảng 2d với nhiều nhãn được dự đoán cho mỗi trường hợp