Hướng dẫn how do you split a dataset in python? - làm thế nào để bạn chia một tập dữ liệu trong python?

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à về việc tạo 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 dự đoán) cho các đầu ra đã cho (các biến phụ thuộc hoặc phản hồi).predictors) to the given outputs (dependent variables, or responses).

Cách bạn đo độ chính xác của mô hình của bạn phụ thuộc vào loại vấn đề mà 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 hệ số xác định, lỗi bình phương trung bình gốc, lỗi tuyệt đối trung bình hoặc số lượng tương tự. Đối với các vấn đề phân loại, bạn thường áp dụng độ chính xác, độ chính xác, thu hồi, điểm F1 và các chỉ số liên quan.

Các giá trị số có thể chấp nhận được đo độ chính xác thay đổi từ trường này sang trường khác. Bạn có thể tìm thấy những giải thích chi tiết từ số liệu thống kê của Jim, Quora và nhiều tài nguyên khác.

Điều quan trọng nhất để hiểu là bạn thường cần đánh giá không thiên vị để 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.unbiased evaluation to properly use these measures, assess the predictive performance of your model, and validate the model.

Điều này có nghĩa là bạn có thể đánh giá hiệu suất dự đoán của một mô hình với cùng một dữ liệu bạn đã sử dụng để đào tạo. Bạn cần đánh giá mô hình với dữ liệu mới đã được mô hình nhìn thấy trước đây. Bạn có thể thực hiện điều đó bằng cách phân tách bộ dữ liệu của bạn trước khi bạn sử dụng nó.fresh data that hasn’t been seen by the model before. You can accomplish that by splitting your dataset before you use it.

Điều kiện tiên quyết cho việc sử dụng $ conda install -c anaconda scikit-learn=0.23 7

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

Bạn sẽ sử dụng phiên bản 0.23,1 của Scikit-learn hoặc

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

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

$ conda install -c anaconda scikit-learn=0.23

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

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

$ conda install -c anaconda scikit-learn=0.23

Bạn có thể cài đặt

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

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

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

Nếu bạn sử dụng Anaconda, thì có lẽ 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, thì bạn có thể cài đặt

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

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

$ conda install -c anaconda scikit-learn=0.23

Bạn cũng sẽ cần Numpy, nhưng bạn không phải cài đặt riêng. Bạn sẽ nhận được nó cùng với

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

Áp dụng $ conda install -c anaconda scikit-learn=0.23 7

Bạn cần nhập

$ conda install -c anaconda scikit-learn=0.23

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

>>>

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

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

Với

$ conda install -c anaconda scikit-learn=0.23

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

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

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

1. Một mảng hai chiều với đầu vào (

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

   5)
2. Một mảng một chiều với đầu ra (

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

   6)

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

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

  8 là số xác định kích thước của tập huấn luyện. Nếu bạn cung cấp

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

  9, thì nó phải nằm giữa

  >>> 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])
  

  0 và

  >>> 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])
  

  1 và sẽ xác định tỷ lệ của bộ dữ liệu được sử dụng để thử nghiệm. Nếu bạn cung cấp

  >>> 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])
  

  2, thì nó sẽ đại diện cho tổng số mẫu đào tạo. Giá trị mặc định là

  >>> 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])
  

  3. is the number that defines the size of the training set. If you provide a

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

  9, then it must be between

  >>> 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])
  

  0 and

  >>> 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])
  

  1 and will define the share of the dataset used for testing. If you provide an

  >>> 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])
  

  2, then it will represent the total number of the training samples. The default value is

  >>> 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])
  

  3.

• >>> 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])
  

  4 là số xác định kích thước của tập kiểm tra. Nó rất giống với

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

  8. Bạn nên cung cấp

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

  8 hoặc

  >>> 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])
  

  4. Nếu không được đưa ra, thì chia sẻ mặc định của bộ dữ liệu sẽ được sử dụng để thử nghiệm là

  >>> 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])
  

  8 hoặc 25 phần trăm. is the number that defines the size of the test set. It’s very similar to

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

  8. You should provide either

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

  8 or

  >>> 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])
  

  4. If neither is given, then the default share of the dataset that will be used for testing is

  >>> 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])
  

  8, or 25 percent.

• >>> 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])
  

  9 là đối tượng kiểm soát ngẫu nhiên trong quá trình phân tách. Nó có thể là một

  >>> 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])
  

  2 hoặc một ví dụ là

  >>> 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])
  

  1. Giá trị mặc định là

  >>> 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])
  

  3. is the object that controls randomization during splitting. It can be either an

  >>> 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])
  

  2 or an instance of

  >>> 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])
  

  1. The default value is

  >>> 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])
  

  3.

• >>> 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])
  

  3 là đối tượng boolean (

  >>> 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])
  

  4 theo mặc định) xác định có nên xáo trộn tập dữ liệu trước khi áp dụng phân chia hay không. is the Boolean object (

  >>> 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])
  

  4 by default) that determines whether to shuffle the dataset before applying the split.

• >>> 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])
  

  5 là một đối tượng giống như mảng, nếu không phải là

  >>> 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])
  

  3, xác định cách sử dụng phân tách phân tầng. is an array-like object that, if not

  >>> 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])
  

  3, determines how to use a stratified split.

Bây giờ, thời gian để thử phân tách dữ liệu! Bạn sẽ bắt đầu bằng cách tạo một bộ dữ liệu đơn giản để làm việc. Bộ dữ liệu sẽ chứa các đầu vào trong mảng hai chiều

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

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

>>>

>>> 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])

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

Bây giờ bạn đã nhập cả, bạn có thể sử dụng chúng để chia dữ liệu thành các bộ đào tạo và bộ kiểm tra. Bạn sẽ phân chia đầu vào và đầu ra cùng một lúc, với một cuộc gọi chức năng 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])

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

1. Bây giờ bạn đã nhập cả, bạn có thể sử dụng chúng để chia dữ liệu thành các bộ đào tạo và bộ kiểm tra. Bạn sẽ phân chia đầu vào và đầu ra cùng một lúc, với một cuộc gọi chức năng duy nhất. The training part of the first sequence (

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

   5)
2. Với

   $ conda install -c anaconda scikit-learn=0.23
   

   7, bạn cần cung cấp các chuỗi mà bạn muốn chia cũng như bất kỳ đối số tùy chọn nào. Nó trả về một 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: The test part of the first sequence (

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

   5)

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

   4 là chuỗi danh sách, mảng numpy, gấu trúc dữ liệu hoặc các đối tượng giống như mảng tương tự giữ dữ liệu bạn muốn chia. Tất cả các đối tượng này cùng nhau tạo nên bộ dữ liệu và phải có cùng độ dài. The training part of the second sequence (

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

   6)
4. Trong các ứng dụng học máy được giám sát, bạn thường làm việc với hai chuỗi như vậy: The test part of the second sequence (

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

   6)

Một mảng hai chiều với đầu vào (

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

Một mảng một chiều với đầu ra (

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

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

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

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

>>> 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])

>>> 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])

>>> 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])

>>> 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])

>>> 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])

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

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

>>> 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])

>>> 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])

>>>

>>> 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 sự thay đổi này, bạn nhận được một kết quả khác với trước đây. Trước đó, bạn đã có một bộ đào tạo với chín mục và bộ thử nghiệm với ba mục. Bây giờ, nhờ cuộc tranh luận

>>> 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])

>>> 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])

Có một sự khác biệt rất quan trọng hơn 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 chức năng. Điều này là do bạn đã cố định trình tạo số ngẫu nhiên với

>>> 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])

Hình dưới đây cho thấy những gì diễn ra khi bạn gọi

$ conda install -c anaconda scikit-learn=0.23

Các mẫu của bộ dữ liệu được xáo trộn ngẫu nhiên và sau đó chia thành các bộ đà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

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

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

>>> 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])

>>>

>>> 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ờ

>>> 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])

>>> 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])

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

Các phân tách phân tầng được mong muốn trong một số trường hợp, như khi bạn phân loại một bộ dữ liệu mất cân bằng, một bộ dữ liệu có sự khác biệt đáng kể về số lượng mẫu thuộc về các lớp khác nhau.imbalanced dataset, a dataset with a significant difference in the number of samples that belong to distinct classes.

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

>>> 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])

>>>

>>> 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 sự phân chia trong đó hai phần ba mẫu đầu tiên trong các mảng

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

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

Học máy được giám sát với $ conda install -c anaconda scikit-learn=0.23 7

Bây giờ, thời gian để thấy

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

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 được cho đến nay để giải quyết một vấn đề hồi quy nhỏ. Bạn có thể học cách tạo bộ dữ liệu, chia chúng thành các tập hợp tập luyện và kiểm tra và sử dụng chúng cho hồi quy tuyến tính.

Như mọi khi, bạn sẽ bắt đầu bằng cách nhập các gói, chức năng hoặc lớp cần thiết. Bạn sẽ cần Numpy,

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

4 và

$ conda install -c anaconda scikit-learn=0.23

7:

>>>

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

Bây giờ bạn đã nhập mọi thứ bạn cần, bạn có thể tạo hai mảng nhỏ,

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

5 và

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

6, để thể hiện các quan sát và sau đó chia chúng thành các bộ đào tạo và thử nghiệm giống như bạn đã làm trước đây:

>>>

$ conda install -c anaconda scikit-learn=0.23

0

Bộ dữ liệu của bạn có hai mươi quan sát, hoặc ________ 35 -________ 36 cặp. Bạn chỉ định đối số

$ conda install -c anaconda scikit-learn=0.23

00, vì vậy bộ dữ liệu được chia thành một tập huấn luyện với mười hai quan sát và một bộ thử nghiệm với tám quan sát.

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

>>>

$ conda install -c anaconda scikit-learn=0.23

1

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

4 tạo ra đối tượng đại diện cho mô hình, trong khi

$ conda install -c anaconda scikit-learn=0.23

02 đào tạo, hoặc phù hợp với mô hình và trả về nó. 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ị đánh chặn tốt nhất (

$ conda install -c anaconda scikit-learn=0.23

03) và độ dốc (____104) của đường hồi quy.

Mặc dù bạn có thể sử dụng

>>> 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])

5 và

>>> 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])

9 để kiểm tra mức độ phù hợp, nhưng đây không phải là một thực hành tốt nhất. Mộ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 thử nghiệm:

>>>

$ conda install -c anaconda scikit-learn=0.23

2

$ conda install -c anaconda scikit-learn=0.23

07 Trả về hệ số xác định hoặc R², cho dữ liệu được truyền. Tối đa của nó là

$ conda install -c anaconda scikit-learn=0.23

08. Giá trị R² càng cao, phù hợp càng tốt. 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 thử nghiệm là một thước đo không thiên vị về hiệu suất dự đoán mô hình của bạn.coefficient of determination, or R², for the data passed. Its maximum is

$ conda install -c anaconda scikit-learn=0.23

08. The higher the R² value, the better the fit. In this case, the training data yields a slightly higher coefficient. However, the R² calculated with test data is an unbiased measure of your model’s prediction performance.

Đây là cách nó trông trên một biểu đồ:

Các chấm màu xanh lá cây đại diện cho ________ 35 -____ 36 cặp đượ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 sự phù hợp mô hình: đánh chặn và độ dốc. Vì vậy, nó chỉ phản ánh các vị trí của các chấm màu xanh lá cây.

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

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

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

>>> 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])

>>> 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])

>>> 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])

>>> 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])

$ conda install -c anaconda scikit-learn=0.23

>>> 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])

>>> 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])

>>> 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])

>>> 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])

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

>>> 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])

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

Các chức năng xác nhận khác

Gói

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

• Cross-validation
• Học đường
• Điều chỉnh siêu đồng tính

Xác thực chéo là một tập hợp các kỹ thuật kết hợp các biện pháp về hiệu suất dự đoán để 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 nhận chéo được sử dụng rộng rãi là xác thực chéo K gấp K. 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 hợp con, hoặc nếp gấp, 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 như bộ kiểm tra và tất cả các nếp gấp còn lại như tập huấn luyện. Điều này cung cấp các biện pháp K về hiệu suất dự đoán và sau đó bạn có thể phân tích độ lệch trung bình và độ lệch chuẩn của chúng.folds, of equal size and then perform the training and test procedures k times. Each time, you use a different fold as the test set and all the remaining folds as the training set. This provides k measures of predictive performance, and you can then analyze their mean and standard deviation.

Bạn có thể thực hiện xác thực chéo với

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

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

Một đường cong học tập, đôi khi được gọi là đường cong đào tạo, cho thấy điểm dự đoán của các bộ đào tạo và xác nhận phụ thuộc vào số lượng mẫu đào tạo. Bạn có thể sử dụng

$ conda install -c anaconda scikit-learn=0.23

Điều chỉnh hyperparameter, còn được gọi là tối ưu hóa hyperparameter, là quá trình xác định bộ siêu âm tốt nhất để xác định mô hình học máy của bạn.

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

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

$ conda install -c anaconda scikit-learn=0.23

Sự kết luận

Bây giờ bạn đã biết tại sao và làm thế nào để sử dụng

$ conda install -c anaconda scikit-learn=0.23

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

$ conda install -c anaconda scikit-learn=0.23

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

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

• Sử dụng

  $ conda install -c anaconda scikit-learn=0.23
  

  7 để được đào tạo và kiểm tra bộ

  $ conda install -c anaconda scikit-learn=0.23
  

  7 to get training and test sets
• Kiểm soát kích thước của các tập hợp con với các tham số

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

  8 và

  >>> 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])
  

  4

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

  8 and

  >>> 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])
  

  4
• Xác định tính ngẫu nhiên của phân tách của bạn với tham số

  >>> 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])
  

  9randomness of your splits with the

  >>> 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])
  

  9 parameter
• Thu được phân tách phân tầng với tham số

  >>> 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])
  

  5stratified splits with the

  >>> 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])
  

  5 parameter
• Sử dụng

  $ conda install -c anaconda scikit-learn=0.23
  

  7 như một phần của các thủ tục học máy được giám sátsupervised machine learning procedures

Bạn cũng đã thấy rằng mô-đun

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

Nếu bạn có câu hỏi hoặc nhận xét, sau đó xin vui lòng đặt chúng vào phần bình luận bên dưới.