Chuẩn hóa dữ liệu 0 thành 1 Python

6. 3. 1. 1. Chia tỷ lệ các đối tượng thành một phạm vi

Một tiêu chuẩn hóa thay thế là chia tỷ lệ các đối tượng nằm giữa một giá trị tối thiểu và tối đa nhất định, thường là từ 0 đến 1 hoặc sao cho giá trị tuyệt đối tối đa của mỗi đối tượng được chia tỷ lệ theo kích thước đơn vị. Điều này có thể đạt được bằng cách sử dụng hoặc , tương ứng

Động lực để sử dụng tỷ lệ này bao gồm tính mạnh mẽ đối với độ lệch chuẩn rất nhỏ của các tính năng và bảo toàn các mục nhập bằng 0 trong dữ liệu thưa thớt

Dưới đây là một ví dụ để chia tỷ lệ ma trận dữ liệu đồ chơi thành phạm vi

>>> min_max_scaler.scale_
array([0.5       , 0.5       , 0.33...])

>>> min_max_scaler.min_
array([0.        , 0.5       , 0.33...])

________số 8_______

Sau đó, phiên bản tương tự của máy biến áp có thể được áp dụng cho một số dữ liệu thử nghiệm mới không nhìn thấy trong cuộc gọi phù hợp. các hoạt động thay đổi tỷ lệ và thay đổi tương tự sẽ được áp dụng để phù hợp với quá trình chuyển đổi được thực hiện trên dữ liệu tàu

>>> X_test = np.array([[-3., -1.,  4.]])
>>> X_test_minmax = min_max_scaler.transform(X_test)
>>> X_test_minmax
array([[-1.5       ,  0.        ,  1.66666667]])

Có thể xem xét các thuộc tính của bộ chia tỷ lệ để tìm về bản chất chính xác của phép biến đổi đã học được trên dữ liệu huấn luyện

>>> min_max_scaler.scale_
array([0.5       , 0.5       , 0.33...])

>>> min_max_scaler.min_
array([0.        , 0.5       , 0.33...])

Nếu được đưa ra một

>>> min_max_scaler.scale_
array([0.5       , 0.5       , 0.33...])

>>> min_max_scaler.min_
array([0.        , 0.5       , 0.33...])

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

hoạt động theo cách rất giống nhau, nhưng chia tỷ lệ theo cách mà dữ liệu đào tạo nằm trong phạm vi

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

Đây là cách sử dụng dữ liệu đồ chơi từ ví dụ trước với bộ chia tỷ lệ này

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> max_abs_scaler = preprocessing.MaxAbsScaler()
>>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
>>> X_train_maxabs
array([[ 0.5, -1. ,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -0.5]])
>>> X_test = np.array([[ -3., -1.,  4.]])
>>> X_test_maxabs = max_abs_scaler.transform(X_test)
>>> X_test_maxabs
array([[-1.5, -1. ,  2. ]])
>>> max_abs_scaler.scale_
array([2.,  1.,  2.])

6. 3. 1. 2. Chia tỷ lệ dữ liệu thưa thớt

Căn giữa dữ liệu thưa thớt sẽ phá hủy cấu trúc thưa thớt trong dữ liệu và do đó hiếm khi là một việc hợp lý để làm. Tuy nhiên, có thể hợp lý khi chia tỷ lệ các đầu vào thưa thớt, đặc biệt nếu các tính năng ở các tỷ lệ khác nhau

được thiết kế đặc biệt để mở rộng quy mô dữ liệu thưa thớt và là cách được đề xuất để thực hiện việc này. Tuy nhiên, có thể chấp nhận ma trận

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

Lưu ý rằng bộ chia tỷ lệ chấp nhận cả định dạng Hàng thưa được nén và Cột thưa được nén (xem

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

Cuối cùng, nếu dự kiến ​​dữ liệu trung tâm đủ nhỏ, thì việc chuyển đổi rõ ràng đầu vào thành một mảng bằng cách sử dụng phương pháp

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> max_abs_scaler = preprocessing.MaxAbsScaler()
>>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
>>> X_train_maxabs
array([[ 0.5, -1. ,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -0.5]])
>>> X_test = np.array([[ -3., -1.,  4.]])
>>> X_test_maxabs = max_abs_scaler.transform(X_test)
>>> X_test_maxabs
array([[-1.5, -1. ,  2. ]])
>>> max_abs_scaler.scale_
array([2.,  1.,  2.])

6. 3. 1. 3. Mở rộng dữ liệu với giá trị ngoại lai

Nếu dữ liệu của bạn chứa nhiều giá trị ngoại lệ, việc chia tỷ lệ bằng cách sử dụng giá trị trung bình và phương sai của dữ liệu có thể không hoạt động tốt. Trong những trường hợp này, bạn có thể sử dụng thay thế thả vào. Nó sử dụng các ước tính mạnh mẽ hơn cho trung tâm và phạm vi dữ liệu của bạn

Người giới thiệu

Thảo luận thêm về tầm quan trọng của việc định tâm và chia tỷ lệ dữ liệu có sẵn trên Câu hỏi thường gặp này. Tôi có nên chuẩn hóa/chuẩn hóa/chia tỷ lệ lại dữ liệu không?

Mở rộng quy mô so với làm trắng

Đôi khi, việc căn giữa và chia tỷ lệ các đối tượng địa lý một cách độc lập là không đủ, vì mô hình xuôi dòng có thể đưa ra thêm một số giả định về tính độc lập tuyến tính của các đối tượng địa lý

Để giải quyết vấn đề này, bạn có thể sử dụng với

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> max_abs_scaler = preprocessing.MaxAbsScaler()
>>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
>>> X_train_maxabs
array([[ 0.5, -1. ,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -0.5]])
>>> X_test = np.array([[ -3., -1.,  4.]])
>>> X_test_maxabs = max_abs_scaler.transform(X_test)
>>> X_test_maxabs
array([[-1.5, -1. ,  2. ]])
>>> max_abs_scaler.scale_
array([2.,  1.,  2.])

6. 3. 1. 4. Ma trận hạt nhân định tâm

Nếu bạn có ma trận hạt nhân của hạt nhân \(K\) tính toán tích vô hướng trong một không gian đối tượng (có thể ngầm định) . Nói cách khác, tính toán ma trận Gram ở giữa được liên kết với hạt nhân nửa xác định dương \(\phi(\cdot)\), a can transform the kernel matrix so that it contains inner products in the feature space defined by \(\phi\) followed by the removal of the mean in that space. In other words, computes the centered Gram matrix associated to a positive semidefinite kernel \(K\) .

công thức toán học

Bây giờ chúng ta có thể xem công thức toán học vì chúng ta có trực giác. Đặt \(K\) là một ma trận nhân có dạng _______14_______6 được tính từ \(X\), a data matrix of shape

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> max_abs_scaler = preprocessing.MaxAbsScaler()
>>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
>>> X_train_maxabs
array([[ 0.5, -1. ,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -0.5]])
>>> X_test = np.array([[ -3., -1.,  4.]])
>>> X_test_maxabs = max_abs_scaler.transform(X_test)
>>> X_test_maxabs
array([[-1.5, -1. ,  2. ]])
>>> max_abs_scaler.scale_
array([2.,  1.,  2.])

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> max_abs_scaler = preprocessing.MaxAbsScaler()
>>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
>>> X_train_maxabs
array([[ 0.5, -1. ,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -0.5]])
>>> X_test = np.array([[ -3., -1.,  4.]])
>>> X_test_maxabs = max_abs_scaler.transform(X_test)
>>> X_test_maxabs
array([[-1.5, -1. ,  2. ]])
>>> max_abs_scaler.scale_
array([2.,  1.,  2.])

\[K(X, X) = \phi(X). \phi(X)^{T}\]

\(\phi(X)\) là ánh xạ hàm của \(X\) to a Hilbert space. A centered kernel \(\tilde{K}\) được định nghĩa là.

\[\tilde{K}(X, X) = \tilde{\phi}(X). \tilde{\phi}(X)^{T}\]

ở đâu \(\tilde{\phi}(X)\) kết quả từ việc định tâm \ . in the Hilbert space.

Do đó, người ta có thể tính toán \(\tilde{K}\) bằng cách ánh xạ \( . Tuy nhiên, hạt nhân thường được sử dụng vì chúng cho phép một số phép tính đại số tránh tính toán rõ ràng ánh xạ này bằng cách sử dụng using the function \(\phi(\cdot)\) and center the data in this new space. However, kernels are often used because they allows some algebra calculations that avoid computing explicitly this mapping using \(\phi(\cdot)\) . Thật vậy, người ta có thể ngầm định tâm như trong Phụ lục B trong.

\[\tilde{K} = K - 1_{\text{n}_{samples}} K - K 1_{\text{n}_{samples}} + 1_{\text{n}_{samples}}

\(1_{\text{n}_{samples}}\) là ma trận của

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> max_abs_scaler = preprocessing.MaxAbsScaler()
>>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
>>> X_train_maxabs
array([[ 0.5, -1. ,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -0.5]])
>>> X_test = np.array([[ -3., -1.,  4.]])
>>> X_test_maxabs = max_abs_scaler.transform(X_test)
>>> X_test_maxabs
array([[-1.5, -1. ,  2. ]])
>>> max_abs_scaler.scale_
array([2.,  1.,  2.])

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

\[K_{test}(X, Y) = \phi(Y). \phi(X)^{T}\]

\(Y\) là tập dữ liệu thử nghiệm của hình dạng

>>> from sklearn.datasets import load_iris
>>> from sklearn.model_selection import train_test_split
>>> X, y = load_iris(return_X_y=True)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
>>> quantile_transformer = preprocessing.QuantileTransformer(random_state=0)
>>> X_train_trans = quantile_transformer.fit_transform(X_train)
>>> X_test_trans = quantile_transformer.transform(X_test)
>>> np.percentile(X_train[:, 0], [0, 25, 50, 75, 100]) 
array([ 4.3,  5.1,  5.8,  6.5,  7.9])

>>> from sklearn.datasets import load_iris
>>> from sklearn.model_selection import train_test_split
>>> X, y = load_iris(return_X_y=True)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
>>> quantile_transformer = preprocessing.QuantileTransformer(random_state=0)
>>> X_train_trans = quantile_transformer.fit_transform(X_train)
>>> X_test_trans = quantile_transformer.transform(X_test)
>>> np.percentile(X_train[:, 0], [0, 25, 50, 75, 100]) 
array([ 4.3,  5.1,  5.8,  6.5,  7.9])

\[\tilde{K}_{test}(X, Y) = K_{test} - 1'_{\text{n}_{samples}} K - K_{test} 1_{\text{n}_

\(1'_{\text{n}_{samples}}\) là một ma trận có dạng

>>> from sklearn.datasets import load_iris
>>> from sklearn.model_selection import train_test_split
>>> X, y = load_iris(return_X_y=True)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
>>> quantile_transformer = preprocessing.QuantileTransformer(random_state=0)
>>> X_train_trans = quantile_transformer.fit_transform(X_train)
>>> X_test_trans = quantile_transformer.transform(X_test)
>>> np.percentile(X_train[:, 0], [0, 25, 50, 75, 100]) 
array([ 4.3,  5.1,  5.8,  6.5,  7.9])

Người giới thiệu

[]

B. Scholkopf, A. Smola và K. R. Müller, “Phân tích thành phần phi tuyến như một vấn đề giá trị riêng của hạt nhân. ” Thần kinh tính toán 10. 5 (1998). 1299-1319

6. 3. 2. 1. Ánh xạ tới phân phối đồng nhất

cung cấp một phép biến đổi phi tham số để ánh xạ dữ liệu thành một phân phối đồng nhất với các giá trị từ 0 đến 1

>>> from sklearn.datasets import load_iris
>>> from sklearn.model_selection import train_test_split
>>> X, y = load_iris(return_X_y=True)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
>>> quantile_transformer = preprocessing.QuantileTransformer(random_state=0)
>>> X_train_trans = quantile_transformer.fit_transform(X_train)
>>> X_test_trans = quantile_transformer.transform(X_test)
>>> np.percentile(X_train[:, 0], [0, 25, 50, 75, 100]) 
array([ 4.3,  5.1,  5.8,  6.5,  7.9])

Đặc điểm này tương ứng với chiều dài đài hoa tính bằng cm. Sau khi chuyển đổi lượng tử được áp dụng, các mốc đó tiếp cận gần với các phân vị được xác định trước đó

>>> np.percentile(X_train_trans[:, 0], [0, 25, 50, 75, 100])
.. 
array([ 0.00.. ,  0.24...,  0.49...,  0.73...,  0.99.. ])

Điều này có thể được xác nhận trên một bộ thử nghiệm độc lập với các nhận xét tương tự

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

6. 3. 2. 2. Ánh xạ tới phân phối Gaussian

Trong nhiều tình huống lập mô hình, tính quy tắc của các tính năng trong tập dữ liệu là mong muốn. Biến đổi lũy thừa là một họ các phép biến đổi tham số, đơn điệu nhằm mục đích ánh xạ dữ liệu từ bất kỳ phân phối nào đến gần với phân phối Gaussian nhất có thể để ổn định phương sai và giảm thiểu độ lệch

hiện đang cung cấp hai phép biến đổi năng lượng như vậy, phép biến đổi Yeo-Johnson và phép biến đổi Box-Cox

Phép biến đổi Yeo-Johnson được cho bởi

\[\begin{split}x_i^{(\lambda)} = \begin{cases} [(x_i + 1)^\lambda - 1] / \lambda & \text{if } \lambda \neq 0, x_i \

trong khi biến đổi Box-Cox được đưa ra bởi

\[\begin{split}x_i^{(\lambda)} = \begin{cases} \dfrac{x_i^\lambda - 1}{\lambda} & \text{if } \lambda \neq 0, \\[

Box-Cox chỉ có thể được áp dụng cho dữ liệu xác thực nghiêm ngặt. Trong cả hai phương pháp, phép biến đổi được tham số hóa bởi \(\lambda\) , được xác định thông qua ước tính khả năng xảy ra tối đa. Dưới đây là một ví dụ về việc sử dụng Box-Cox để ánh xạ các mẫu được rút ra từ phân phối chuẩn logic sang phân phối chuẩn.

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

Mặc dù ví dụ trên đặt tùy chọn

>>> from sklearn.datasets import load_iris
>>> from sklearn.model_selection import train_test_split
>>> X, y = load_iris(return_X_y=True)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
>>> quantile_transformer = preprocessing.QuantileTransformer(random_state=0)
>>> X_train_trans = quantile_transformer.fit_transform(X_train)
>>> X_test_trans = quantile_transformer.transform(X_test)
>>> np.percentile(X_train[:, 0], [0, 25, 50, 75, 100]) 
array([ 4.3,  5.1,  5.8,  6.5,  7.9])

>>> from sklearn.datasets import load_iris
>>> from sklearn.model_selection import train_test_split
>>> X, y = load_iris(return_X_y=True)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
>>> quantile_transformer = preprocessing.QuantileTransformer(random_state=0)
>>> X_train_trans = quantile_transformer.fit_transform(X_train)
>>> X_test_trans = quantile_transformer.transform(X_test)
>>> np.percentile(X_train[:, 0], [0, 25, 50, 75, 100]) 
array([ 4.3,  5.1,  5.8,  6.5,  7.9])

Dưới đây là các ví dụ về Box-Cox và Yeo-Johnson được áp dụng cho các phân phối xác suất khác nhau. Lưu ý rằng khi áp dụng cho một số phân phối nhất định, các phép biến đổi lũy thừa đạt được kết quả rất giống Gaussian, nhưng với những phân phối khác, chúng không hiệu quả. Điều này nhấn mạnh tầm quan trọng của việc trực quan hóa dữ liệu trước và sau khi chuyển đổi

Cũng có thể ánh xạ dữ liệu thành phân phối chuẩn bằng cách sử dụng bằng cách đặt

>>> np.percentile(X_train_trans[:, 0], [0, 25, 50, 75, 100])
.. 
array([ 0.00.. ,  0.24...,  0.49...,  0.73...,  0.99.. ])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

Do đó, trung vị của đầu vào trở thành trung vị của đầu ra, có tâm là 0. Đầu ra bình thường được cắt bớt sao cho giá trị tối thiểu và tối đa của đầu vào — tương ứng với các lượng tử 1e-7 và 1 - 1e-7 — không trở thành vô hạn khi chuyển đổi

6. 3. 4. 1. Danh mục không thường xuyên

hỗ trợ tổng hợp các danh mục không thường xuyên thành một đầu ra duy nhất cho từng tính năng. Các tham số để cho phép thu thập các danh mục không thường xuyên là

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

1. >>> X_scaled.mean(axis=0)
   array([0., 0., 0.])
   
   >>> X_scaled.std(axis=0)
   array([1., 1., 1.])
   

   39 là số nguyên lớn hơn hoặc bằng 1 hoặc là số float trong khoảng

   >>> X_scaled.mean(axis=0)
   array([0., 0., 0.])
   
   >>> X_scaled.std(axis=0)
   array([1., 1., 1.])
   

   42. Nếu

   >>> X_scaled.mean(axis=0)
   array([0., 0., 0.])
   
   >>> X_scaled.std(axis=0)
   array([1., 1., 1.])
   

   39 là một số nguyên, các danh mục có số lượng nhỏ hơn

   >>> X_scaled.mean(axis=0)
   array([0., 0., 0.])
   
   >>> X_scaled.std(axis=0)
   array([1., 1., 1.])
   

   39 sẽ được coi là không thường xuyên. Nếu

   >>> X_scaled.mean(axis=0)
   array([0., 0., 0.])
   
   >>> X_scaled.std(axis=0)
   array([1., 1., 1.])
   

   39 là số thực, các danh mục có số lượng nhỏ hơn phần này trong tổng số mẫu sẽ được coi là không thường xuyên. Giá trị mặc định là 1, có nghĩa là mọi danh mục được mã hóa riêng

2. >>> X_scaled.mean(axis=0)
   array([0., 0., 0.])
   
   >>> X_scaled.std(axis=0)
   array([1., 1., 1.])
   

   40 là

   >>> X_scaled.mean(axis=0)
   array([0., 0., 0.])
   
   >>> X_scaled.std(axis=0)
   array([1., 1., 1.])
   

   34 hoặc bất kỳ số nguyên nào lớn hơn 1. Tham số này đặt giới hạn trên cho số lượng tính năng đầu ra cho từng tính năng đầu vào.

   >>> X_scaled.mean(axis=0)
   array([0., 0., 0.])
   
   >>> X_scaled.std(axis=0)
   array([1., 1., 1.])
   

   40 bao gồm tính năng kết hợp các danh mục không thường xuyên

Trong ví dụ sau, các danh mục,

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

Bằng cách đặt handle_unknown thành

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

sử dụng 'không thường xuyên' làm tên tính năng không thường xuyên

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

Khi

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

1. Nếu hỗ trợ danh mục không thường xuyên không được định cấu hình hoặc không có danh mục không thường xuyên trong quá trình đào tạo, các cột được mã hóa một lần cho tính năng này sẽ là tất cả các số không. Trong phép biến đổi nghịch đảo, một hạng mục chưa biết sẽ được ký hiệu là

   >>> X_scaled.mean(axis=0)
   array([0., 0., 0.])
   
   >>> X_scaled.std(axis=0)
   array([1., 1., 1.])
   

   34

2. Nếu có một danh mục không thường xuyên trong quá trình đào tạo, danh mục không xác định sẽ được coi là không thường xuyên. Trong biến đổi nghịch đảo, 'infrequent_sklearn' sẽ được sử dụng để đại diện cho danh mục không thường xuyên

Các danh mục không thường xuyên cũng có thể được định cấu hình bằng cách sử dụng

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

Nếu cả

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

Nếu có các danh mục không thường xuyên có cùng số lượng ở điểm cắt của

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

6. 3. 5. 1. K-bin rời rạc

rời rạc các tính năng thành các ngăn

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

Theo mặc định, đầu ra được mã hóa một lần nóng thành một ma trận thưa thớt (Xem ) và điều này có thể được định cấu hình bằng tham số

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> max_abs_scaler = preprocessing.MaxAbsScaler()
>>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
>>> X_train_maxabs
array([[ 0.5, -1. ,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -0.5]])
>>> X_test = np.array([[ -3., -1.,  4.]])
>>> X_test_maxabs = max_abs_scaler.transform(X_test)
>>> X_test_maxabs
array([[-1.5, -1. ,  2. ]])
>>> max_abs_scaler.scale_
array([2.,  1.,  2.])

• tính năng 1. \({[-\infty, -1), [-1, 2), [2, \infty)}\)

• tính năng 2. \({[-\infty, 5), [5, \infty)}\)

• tính năng 3. \({[-\infty, 14), [14, \infty)}\)

Dựa trên các khoảng thời gian bin này,

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

Tập dữ liệu kết quả chứa các thuộc tính thứ tự có thể được sử dụng thêm trong một

Sự rời rạc hóa tương tự như việc xây dựng biểu đồ cho dữ liệu liên tục. Tuy nhiên, biểu đồ tập trung vào việc đếm các tính năng rơi vào các ngăn cụ thể, trong khi sự rời rạc tập trung vào việc gán giá trị tính năng cho các ngăn này

thực hiện các chiến lược tạo thùng khác nhau, có thể được chọn bằng tham số

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

Xin lưu ý rằng người ta có thể chỉ định các thùng tùy chỉnh bằng cách chuyển một cuộc gọi có thể xác định chiến lược rời rạc tới. Chẳng hạn, chúng ta có thể sử dụng chức năng Pandas

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

ví dụ

6. 3. 5. 2. Nhị phân tính năng

Tính năng nhị phân hóa tính năng là quá trình tạo ngưỡng cho các tính năng số để nhận các giá trị boolean. Điều này có thể hữu ích cho các công cụ ước tính xác suất xuôi dòng đưa ra giả định rằng dữ liệu đầu vào được phân phối theo phân phối Bernoulli đa biến. Ví dụ, đây là trường hợp của

Cộng đồng xử lý văn bản cũng thường sử dụng các giá trị tính năng nhị phân (có thể để đơn giản hóa lý luận xác suất) ngay cả khi số đếm được chuẩn hóa (a. k. a. thuật ngữ tần số) hoặc các tính năng có giá trị TF-IDF thường hoạt động tốt hơn một chút trong thực tế

Đối với , lớp tiện ích có nghĩa là được sử dụng trong giai đoạn đầu của. Phương pháp

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> max_abs_scaler = preprocessing.MaxAbsScaler()
>>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
>>> X_train_maxabs
array([[ 0.5, -1. ,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -0.5]])
>>> X_test = np.array([[ -3., -1.,  4.]])
>>> X_test_maxabs = max_abs_scaler.transform(X_test)
>>> X_test_maxabs
array([[-1.5, -1. ,  2. ]])
>>> max_abs_scaler.scale_
array([2.,  1.,  2.])

>>> X_train = np.array([[ 1., -1.,  2.],
..                     [ 2.,  0.,  0.],
..                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

Có thể điều chỉnh ngưỡng của bộ nhị phân

>>> X_test = np.array([[-3., -1.,  4.]])
>>> X_test_minmax = min_max_scaler.transform(X_test)
>>> X_test_minmax
array([[-1.5       ,  0.        ,  1.66666667]])

Đối với lớp, mô-đun tiền xử lý cung cấp chức năng đồng hành được sử dụng khi không cần API biến áp

Lưu ý rằng tương tự như khi

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

Đầu vào thưa thớt

và chấp nhận cả ma trận giống như mảng dày đặc và ma trận thưa thớt từ scipy. thưa thớt như đầu vào

Đối với đầu vào thưa thớt, dữ liệu được chuyển đổi thành biểu diễn Hàng thưa được nén (xem

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))

X_scaled = X_std * (max - min) + min

6. 3. 7. 1. Các đặc trưng của đa thức

Một phương pháp đơn giản và phổ biến để sử dụng là các tính năng đa thức, có thể nhận được các thuật ngữ tương tác và bậc cao của tính năng. Nó được thực hiện trong

>>> X_test = np.array([[-3., -1.,  4.]])
>>> X_test_minmax = min_max_scaler.transform(X_test)
>>> X_test_minmax
array([[-1.5       ,  0.        ,  1.66666667]])

Các tính năng của X đã được chuyển đổi từ \((X_1, X_2)\) thành . .

Trong một số trường hợp, chỉ cần có các điều khoản tương tác giữa các tính năng và có thể nhận được điều khoản đó bằng cài đặt

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> X_test = np.array([[-3., -1.,  4.]])
>>> X_test_minmax = min_max_scaler.transform(X_test)
>>> X_test_minmax
array([[-1.5       ,  0.        ,  1.66666667]])

Các tính năng của X đã được chuyển đổi từ \((X_1, X_2, X_3)\) thành \((1, X_1, X_2, X_3, X_1X_2, X_1X_3, X_2X_3, X_1X_2X_3)\).

Lưu ý rằng các tính năng đa thức được sử dụng hoàn toàn trong các phương thức kernel (e. g. , , ) khi sử dụng đa thức

Xem hồi quy Ridge bằng cách sử dụng các tính năng đa thức đã tạo

6. 3. 7. 2. Máy biến áp spline

Một cách khác để thêm các thuật ngữ phi tuyến tính thay vì đa thức thuần túy của các tính năng là tạo các hàm cơ sở spline cho từng tính năng với. Các spline là các đa thức từng phần, được tham số hóa bởi bậc đa thức của chúng và vị trí của các nút thắt. Các thực hiện một cơ sở B-spline, cf. các tài liệu tham khảo dưới đây

Ghi chú

Việc xử lý từng tính năng riêng biệt, tôi. e. nó sẽ không cung cấp cho bạn các điều khoản tương tác

Một số ưu điểm của spline so với đa thức là

• B-splines rất linh hoạt và mạnh mẽ nếu bạn giữ mức độ thấp cố định, thường là 3 và điều chỉnh một cách cẩn thận số lượng nút thắt. Đa thức sẽ cần một mức độ cao hơn, dẫn đến điểm tiếp theo

• B-splines không có hành vi dao động ở các ranh giới như có đa thức (mức độ càng cao thì càng tệ). Đây được gọi là hiện tượng Runge

• B-splines cung cấp các tùy chọn tốt cho phép ngoại suy vượt ra ngoài ranh giới, tôi. e. vượt quá phạm vi của các giá trị được trang bị. Hãy xem tùy chọn

  >>> from sklearn.datasets import make_classification
  >>> from sklearn.linear_model import LogisticRegression
  >>> from sklearn.model_selection import train_test_split
  >>> from sklearn.pipeline import make_pipeline
  >>> from sklearn.preprocessing import StandardScaler
  
  >>> X, y = make_classification(random_state=42)
  >>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
  >>> pipe = make_pipeline(StandardScaler(), LogisticRegression())
  >>> pipe.fit(X_train, y_train)  # apply scaling on training data
  Pipeline(steps=[('standardscaler', StandardScaler()),
                  ('logisticregression', LogisticRegression())])
  
  >>> pipe.score(X_test, y_test)  # apply scaling on testing data, without leaking training data.
  0.96
  

  01

• B-splines tạo ma trận đặc trưng với cấu trúc dải. Đối với một đối tượng địa lý, mỗi hàng chỉ chứa

  >>> from sklearn.datasets import make_classification
  >>> from sklearn.linear_model import LogisticRegression
  >>> from sklearn.model_selection import train_test_split
  >>> from sklearn.pipeline import make_pipeline
  >>> from sklearn.preprocessing import StandardScaler
  
  >>> X, y = make_classification(random_state=42)
  >>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
  >>> pipe = make_pipeline(StandardScaler(), LogisticRegression())
  >>> pipe.fit(X_train, y_train)  # apply scaling on training data
  Pipeline(steps=[('standardscaler', StandardScaler()),
                  ('logisticregression', LogisticRegression())])
  
  >>> pipe.score(X_test, y_test)  # apply scaling on testing data, without leaking training data.
  0.96
  

  02 phần tử khác không, xuất hiện liên tiếp và thậm chí là dương. Điều này dẫn đến một ma trận có các thuộc tính số tốt, e. g. một số điều kiện thấp, trái ngược hoàn toàn với ma trận đa thức, có tên là ma trận Vandermonde. Số điều kiện thấp rất quan trọng đối với các thuật toán ổn định của các mô hình tuyến tính

Đoạn mã sau hiển thị các splines đang hoạt động

>>> X_test = np.array([[-3., -1.,  4.]])
>>> X_test_minmax = min_max_scaler.transform(X_test)
>>> X_test_minmax
array([[-1.5       ,  0.        ,  1.66666667]])

Khi

>>> X_scaled.mean(axis=0)
array([0., 0., 0.])

>>> X_scaled.std(axis=0)
array([1., 1., 1.])

>>> from sklearn.datasets import make_classification
>>> from sklearn.linear_model import LogisticRegression
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.pipeline import make_pipeline
>>> from sklearn.preprocessing import StandardScaler

>>> X, y = make_classification(random_state=42)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
>>> pipe = make_pipeline(StandardScaler(), LogisticRegression())
>>> pipe.fit(X_train, y_train)  # apply scaling on training data
Pipeline(steps=[('standardscaler', StandardScaler()),
                ('logisticregression', LogisticRegression())])

>>> pipe.score(X_test, y_test)  # apply scaling on testing data, without leaking training data.
0.96

Thật thú vị, a của

>>> from sklearn.datasets import make_classification
>>> from sklearn.linear_model import LogisticRegression
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.pipeline import make_pipeline
>>> from sklearn.preprocessing import StandardScaler

>>> X, y = make_classification(random_state=42)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
>>> pipe = make_pipeline(StandardScaler(), LogisticRegression())
>>> pipe.fit(X_train, y_train)  # apply scaling on training data
Pipeline(steps=[('standardscaler', StandardScaler()),
                ('logisticregression', LogisticRegression())])

>>> pipe.score(X_test, y_test)  # apply scaling on testing data, without leaking training data.
0.96

>>> from sklearn.datasets import make_classification
>>> from sklearn.linear_model import LogisticRegression
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.pipeline import make_pipeline
>>> from sklearn.preprocessing import StandardScaler

>>> X, y = make_classification(random_state=42)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
>>> pipe = make_pipeline(StandardScaler(), LogisticRegression())
>>> pipe.fit(X_train, y_train)  # apply scaling on training data
Pipeline(steps=[('standardscaler', StandardScaler()),
                ('logisticregression', LogisticRegression())])

>>> pipe.score(X_test, y_test)  # apply scaling on testing data, without leaking training data.
0.96

>>> from sklearn.datasets import make_classification
>>> from sklearn.linear_model import LogisticRegression
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.pipeline import make_pipeline
>>> from sklearn.preprocessing import StandardScaler

>>> X, y = make_classification(random_state=42)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
>>> pipe = make_pipeline(StandardScaler(), LogisticRegression())
>>> pipe.fit(X_train, y_train)  # apply scaling on training data
Pipeline(steps=[('standardscaler', StandardScaler()),
                ('logisticregression', LogisticRegression())])

>>> pipe.score(X_test, y_test)  # apply scaling on testing data, without leaking training data.
0.96

>>> from sklearn.datasets import make_classification
>>> from sklearn.linear_model import LogisticRegression
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.pipeline import make_pipeline
>>> from sklearn.preprocessing import StandardScaler

>>> X, y = make_classification(random_state=42)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
>>> pipe = make_pipeline(StandardScaler(), LogisticRegression())
>>> pipe.fit(X_train, y_train)  # apply scaling on training data
Pipeline(steps=[('standardscaler', StandardScaler()),
                ('logisticregression', LogisticRegression())])

>>> pipe.score(X_test, y_test)  # apply scaling on testing data, without leaking training data.
0.96

ví dụ

Người giới thiệu

• Eilers, P. , & Mác, B. (1996). Làm mịn linh hoạt với B-splines và Penalties. thống kê. Khoa học. 11 (1996), không. 2, 89–121

• Perperoglou, A. , Sauerbrei, W. , Abrahamowicz, M. et al. Đánh giá về thủ tục chức năng spline trong R. BMC Med Res Methodol 19, 46 (2019)