sklearn-Preprocessing

最新推荐文章于 2023-07-01 11:04:43 发布

风吴痕

最新推荐文章于 2023-07-01 11:04:43 发布

阅读量2.4k

点赞数 1

分类专栏： sklearn 文章标签： sklearn

sklearn 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

参考：

1、http://scikit-learn.org/stable/

2、http://scikit-learn.org/stable/modules/preprocessing.html#preprocessing

4.3. Preprocessing data

sklearn.preprocessing软件包提供了几个常见的实用功能和变换器类，以将原始特征向量更改为更适合下行估计器的表示。
一般来说，学习算法受益于数据集的标准化。如果集合中存在一些异常值，则稳健的定标器或变压器更合适。比较不同缩放器对具有异常值的数据的影响，突出显示了包含边际异常值的数据集上的不同缩放器，变换器和归一化器的行为。

4.3.1. Standardization, or mean removal and variance scaling

数据集的标准化是在scikit学习中实现的许多机器学习估计器的常见要求;如果个别特征不是或多或少地看起来像标准正态分布的数据，那么它们的行为可能会很差：高斯和零均值和单位方差。

实际上，我们经常忽略分布的形状，只是通过去除每个特征的平均值将数据转换为中心，然后通过将非常数特征除以其标准偏差进行分类。（xi-mean(xi)）/var(xi)

例如，在学习算法的目标函数（例如支持向量机的RBF内核或线性模型的l1和l2定理器）中使用的许多元素假设所有特征都以零为中心并且具有相同顺序的方差。如果特征的方差大于其他数量级，则可能主导目标函数，使得估计器无法按预期正确地学习其他特征。

函数scale提供了一种快速简单的方法来在单个阵列数据集上执行此操作：

from sklearn import preprocessing
import numpy as np
X_train = np.array([[ 1., -1.,  2.],
                    [ 2.,  0.,  0.],
                    [ 0.,  1., -1.]])
X_scaled = preprocessing.scale(X_train)

print(X_scaled)
print(X_scaled.sum()) # 4.4408920985e-16 ~ 0
print(np.var(X_scaled)) # 1.0

Scaled数据具有零均值和单位方差：

preprocessing 模块还提供了一个实用程序类StandardScaler，它实现了Transformer API来计算训练集上的平均值和标准偏差，以便能够稍后在测试集上重新应用相同的变换。因此，此类适用于sklearn.pipeline.Pipeline:的早期步骤。管道：

>>> scaler = preprocessing.StandardScaler().fit(X_train)
>>> scaler
StandardScaler(copy=True, with_mean=True, with_std=True)

>>> scaler.mean_                                      
array([ 1. ...,  0. ...,  0.33...])

>>> scaler.scale_                                       
array([ 0.81...,  0.81...,  1.24...])

>>> scaler.transform(X_train)                           
array([[ 0.  ..., -1.22...,  1.33...],
       [ 1.22...,  0.  ..., -0.26...],
       [-1.22...,  1.22..., -1.06...]])

然后，可以使用scaler 实例对新数据进行转换，与在训练集上所做的相同：

>>> X_test = [[-1., 1., 0.]]
>>> scaler.transform(X_test)                
array([[-2.44...,  1.22..., -0.26...]])

可以通过with_mean=False或with_std=False传递给StandardScaler.的构造函数来禁止居中或缩放。

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

from sklearn import preprocessing
import numpy as np
X_train = np.array([[ 1., -1.,  2.],
                    [ 2.,  0.,  0.],
                    [ 0.,  1., -1.]])
X_test = [[-1., 1., 0.]]

X_scaled = preprocessing.scale(X_train)

print(X_scaled)
"""
[[ 0.         -1.22474487  1.33630621]
 [ 1.22474487  0.         -0.26726124]
 [-1.22474487  1.22474487 -1.06904497]]
"""

print(preprocessing.scale(X_test))
# [[ 0.  0.  0.]]

# -------------方式二-------------------------------

scaler = preprocessing.StandardScaler().fit(X_train)  # .fit(X_train)不能去除
print(scaler.transform(X_train))
"""
[[ 0.         -1.22474487  1.33630621]
 [ 1.22474487  0.         -0.26726124]
 [-1.22474487  1.22474487 -1.06904497]]
"""

print(scaler.transform(X_test))
# [[-2.44948974  1.22474487 -0.26726124]]

4.3.1.1. Scaling features to a range

选择标准化是将特征缩放到给定的最小值和最大值之间，通常在0和1之间，或者使得每个特征的最大绝对值被缩放到单位大小。这可以分别使用 MinMaxScaler or MaxAbsScaler来实现。
使用此缩放的目的包括对特征的非常小的标准偏差的鲁棒性，以及在稀疏数据中保留零条目。
以下是将玩具数据矩阵缩放到[0，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.        ]])

然后，transformer的相同实例可以应用于拟合调用的一些新的测试数据：将应用相同的缩放和移位操作以与在训练数据上执行的变换一致：

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

可以对scaler 属性进行内省，以了解训练数据上学到的转换的确切性质：

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

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

如果MinMaxScaler给出了一个显式的feature_range =（最小，最大），则该公式为

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

X_scaled = X_std * (max - min) + min

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

from sklearn import preprocessing
import numpy as np
X_train = np.array([[ 1., -1.,  2.],
                    [ 2.,  0.,  0.],
                    [ 0.,  1., -1.]])
X_test = np.array([[ -3., -1.,  4.]])

min_max_scaler = preprocessing.MinMaxScaler().fit(X_train) # .fit(X_train) 可以去除 不产生任何作用
X_train_minmax = min_max_scaler.fit_transform(X_train)
X_test_minmax = min_max_scaler.transform(X_test)
print(X_train_minmax)
"""
[[ 0.5         0.          1.        ]
 [ 1.          0.5         0.33333333]
 [ 0.          1.          0.        ]]
"""
print(X_test_minmax)
# [[-1.5         0.          1.66666667]]

# ---------------方式二-------------------------------

print(preprocessing.minmax_scale(X_train))
"""
[[ 0.5         0.          1.        ]
 [ 1.          0.5         0.33333333]
 [ 0.          1.          0.        ]]
"""
print(preprocessing.minmax_scale(X_test))
# [[ 0.  0.  0.]]

MaxAbsScaler以非常相似的方式工作，但通过划分每个特征中最大的最大值，训练数据位于[-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                # doctest +NORMALIZE_WHITESPACE^
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.])

与 scale一样，如果不想创建对象，模块还提供了 minmax_scale and maxabs_scale的便利函数。

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

from sklearn import preprocessing
import numpy as np
X_train = np.array([[ 1., -1.,  2.],
                    [ 2.,  0.,  0.],
                    [ 0.,  1., -1.]])
X_test = np.array([[ -3., -1.,  4.]])


max_abs_scaler = preprocessing.MaxAbsScaler().fit(X_train) # .fit(X_train)可以去除
X_train_maxabs = max_abs_scaler.fit_transform(X_train)
X_test_maxabs = max_abs_scaler.transform(X_test)
print(X_train_maxabs )
"""
[[ 0.5 -1.   1. ]
 [ 1.   0.   0. ]
 [ 0.   1.  -0.5]]
"""
print(X_test_maxabs  )
# [[-1.5 -1.   2. ]]


# ---------------方法二--------------------------------------

print(preprocessing.maxabs_scale(X_train))
"""
[[ 0.5 -1.   1. ]
 [ 1.   0.   0. ]
 [ 0.   1.  -0.5]]
"""
print(preprocessing.maxabs_scale(X_test))
# [[-1. -1.  1.]]

4.3.1.2. Scaling sparse data

居中的稀疏数据将破坏数据中的稀疏结构，因此很少这么做。然而，缩放稀疏输入是有意义的，特别是如果特征在不同的尺度上。

MaxAbsScaler and maxabs_scale专门用于缩放稀疏数据，是推荐的方法。然而，scale and StandardScaler可以接受scipy.sparse矩阵作为输入，只要将with_mean=False显式传递给构造函数即可。否则，ValueError将被提升为默认中心会破坏稀疏性，并且经常会无意中分配过多的内存而使执行崩溃。 RobustScaler不适应稀疏输入，但您可以在稀疏输入上使用transform 方法。

请注意，缩放器接受压缩稀疏行和压缩稀疏列格式（请参阅scipy.sparse.csr_matrix and scipy.sparse.csc_matrix）。任何其他稀疏输入将被转换为压缩稀疏行表示。为了避免不必要的内存复制，建议在上游选择CSR或CSC表示。

最后，如果预期中心数据足够小，则使用稀疏矩阵的数组方法将输入显式转换为数组是另一种选择。

4.3.1.3. Scaling data with outliers¶

如果您的数据包含许多异常值，则使用数据的均值和方差进行缩放可能无法正常工作。在这种情况下，您可以使用 robust_scale and RobustScaler作为替换替代。他们对数据的中心和范围使用更强大的估计。

缩放和美白

由于下游模型可以进一步对特征的线性独立性进行一些假设，因此有时不足以独立地集中和缩放特征。
为了解决这个问题，您可以使用whiten=True的 sklearn.decomposition.PCA or sklearn.decomposition.RandomizedPCA来进一步消除功能之间的线性关联。

在回归中缩放目标变量

scale and StandardScaler与1d阵列一起开箱即用。这对于缩放用于回归的目标/响应变量非常有用。

4.3.1.4. Centering kernel matrices

如果您有一个内核K的内核矩阵，它计算由函数 $phi$ 定义的特征空间中的点积，则 KernelCenterer可以转换内核矩阵，使其包含由 $phi$ 定义的特征空间中的内积，然后除去均值在那个空间。

4.3.2. Non-linear transformation

像 scalers一样， QuantileTransformer将每个功能放在相同的范围或分布中。然而，通过执行秩变换，它平滑了异常分布，并且比缩放方法更少受离群值的影响。然而，它确实扭曲了功能内和跨功能的相关性和距离。

QuantileTransformer and quantile_transform提供了基于分位数函数的非参数变换，将数据映射到0到1之间的均匀分布：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn import preprocessing
import numpy as np


iris = load_iris()
X, y = iris.data, iris.target
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)
d=np.percentile(X_train[:, 0], [0, 25, 50, 75, 100])
print(d)

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

这可以在具有类似评论的独立测试集上得到证实：

>>> np.percentile(X_test[:, 0], [0, 25, 50, 75, 100])
... 
array([ 4.4  ,  5.125,  5.75 ,  6.175,  7.3  ])
>>> np.percentile(X_test_trans[:, 0], [0, 25, 50, 75, 100])
... 
array([ 0.01...,  0.25...,  0.46...,  0.60... ,  0.94...])

也可以通过设置 output_distribution='normal'将变换后的数据映射到正态分布：

>>> quantile_transformer = preprocessing.QuantileTransformer(
...     output_distribution='normal', random_state=0)
>>> X_trans = quantile_transformer.fit_transform(X)
>>> quantile_transformer.quantiles_ 
array([[ 4.3...,   2...,     1...,     0.1...],
       [ 4.31...,  2.02...,  1.01...,  0.1...],
       [ 4.32...,  2.05...,  1.02...,  0.1...],
       ...,
       [ 7.84...,  4.34...,  6.84...,  2.5...],
       [ 7.87...,  4.37...,  6.87...,  2.5...],
       [ 7.9...,   4.4...,   6.9...,   2.5...]])

因此，输入的中值成为输出的平均值，以0为中心。正常输出被削减，使得输入的最小值和最大值分别对应于1e-7和1-1e-7分位数 - 不会变得无限大转型。

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn import preprocessing
import numpy as np


iris = load_iris()
X, y = iris.data, iris.target
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)
print(np.percentile(X_train[:, 0], [0, 25, 50, 75, 100]))
# [ 4.3  5.1  5.8  6.5  7.9]
print(np.percentile(X_train_trans[:, 0], [0, 25, 50, 75, 100]))
"""
[  9.99999998e-08   2.38738739e-01   5.09009009e-01   7.43243243e-01
   9.99999900e-01]
"""

print(np.percentile(X_test[:, 0], [0, 25, 50, 75, 100]))
# [ 4.4    5.125  5.75   6.175  7.3  ]
print(np.percentile(X_test_trans[:, 0], [0, 25, 50, 75, 100]))
"""
[ 0.01351351  0.25012513  0.47972973  0.6021021   0.94144144]
"""

# --------方式二------------------------------------------------------------------#

X_train_trans=preprocessing.quantile_transform(X_train,random_state=0)
print(np.percentile(X_train_trans[:, 0], [0, 25, 50, 75, 100]))
"""
[  9.99999998e-08   2.38738739e-01   5.09009009e-01   7.43243243e-01
   9.99999900e-01]
"""
X_test_trans=preprocessing.quantile_transform(X_test,random_state=0)
print(np.percentile(X_test_trans[:, 0], [0, 25, 50, 75, 100]))
"""
[  9.99999998e-08   2.53378378e-01   5.00000000e-01   7.39114114e-01
   9.99999900e-01]
"""

# ------------------------------------------------------------------------------#
# 转成 正态分布
quantile_transformer = preprocessing.QuantileTransformer(
     output_distribution='normal', random_state=0) # 变成正态分布
X_trans = quantile_transformer.fit_transform(X)

4.3.3. Normalization

规范化是将单个样本缩放为具有单位规范的过程。如果您计划使用二次形式（如点积或任何其他内核）来量化任何样本对的相似度，则此过程将非常有用。

这个假设是经常在文本分类和聚类上下文中使用的Vector Space Model 的基础。

函数normalize提供了一种快速简单的方法，可以在使用l1或l2规范的单个阵列数据集上执行此操作：

>>> X = [[ 1., -1.,  2.],
...      [ 2.,  0.,  0.],
...      [ 0.,  1., -1.]]
>>> X_normalized = preprocessing.normalize(X, norm='l2')

>>> X_normalized                                      
array([[ 0.40..., -0.40...,  0.81...],
       [ 1.  ...,  0.  ...,  0.  ...],
       [ 0.  ...,  0.70..., -0.70...]])

preprocessing 模块还提供了一个实用程序类 Normalizer，它使用Transformer API实现相同的操作（即使在这种情况下fit方法是无用的：该类是无状态的，因为该操作独立地对待样本）。

因此，此类适用于sklearn.pipeline.Pipeline:的早期步骤。管道：

>>> normalizer = preprocessing.Normalizer().fit(X)  # fit does nothing
>>> normalizer
Normalizer(copy=True, norm='l2')

然后，归一化器实例可以用作样本向量作为任何变压器：

>>> normalizer.transform(X)                            
array([[ 0.40..., -0.40...,  0.81...],
       [ 1.  ...,  0.  ...,  0.  ...],
       [ 0.  ...,  0.70..., -0.70...]])

>>> normalizer.transform([[-1.,  1., 0.]])             
array([[-0.70...,  0.70...,  0.  ...]])

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

from sklearn import  preprocessing

X = [[ 1., -1.,  2.],
     [ 2.,  0.,  0.],
     [ 0.,  1., -1.]]
X_normalized = preprocessing.normalize(X, norm='l2')
print(X_normalized)
"""
[[ 0.40824829 -0.40824829  0.81649658]
 [ 1.          0.          0.        ]
 [ 0.          0.70710678 -0.70710678]]
"""
print(preprocessing.normalize([[-1.,  1., 0.]], norm='l2'))
# [[-0.70710678  0.70710678  0.        ]]

# ——————————————————————————————————————————————————————————————————————#

normalizer = preprocessing.Normalizer().fit(X)  # fit does nothing  .fit(X)可以去除
print(normalizer.transform(X))
"""
[[ 0.40824829 -0.40824829  0.81649658]
 [ 1.          0.          0.        ]
 [ 0.          0.70710678 -0.70710678]]
"""
print(normalizer.transform([[-1.,  1., 0.]]))
"""
[[-0.70710678  0.70710678  0.        ]]
"""

稀疏输入

normalize and Normalizer接收来自scipy.sparse的密集数组和稀疏矩阵作为输入。
对于稀疏输入，将数据转换为压缩稀疏行表示（请参阅scipy.sparse.csr_matrix），然后再将其提供给高效的Cython例程。为了避免不必要的内存复制，建议在上游选择CSR表示。

4.3.4. Binarization

4.3.4.1. Feature binarization

特征二值化是数值特征阈值获取布尔值的过程。这对于根据多变量 Bernoulli distribution .来假设输入数据分布的下游概率估计器是有用的。例如，这是 sklearn.neural_network.BernoulliRBM的情况。

即使归一化计数（a.k.a.术语频率）或TF-IDF值特征在实践中经常表现稍好一些，文本处理社区也常常使用二进制特征值（可能简化概率推理）。
对于Normalizer，实用程序类Binarizer 旨在用于sklearn.pipeline.Pipeline. 的早期阶段。 fit 的方法什么都不做，因为每个样品都是独立于其他样品处理

>>> X = [[ 1., -1.,  2.],
...      [ 2.,  0.,  0.],
...      [ 0.,  1., -1.]]

>>> binarizer = preprocessing.Binarizer().fit(X)  # fit does nothing
>>> binarizer
Binarizer(copy=True, threshold=0.0)

>>> binarizer.transform(X)
array([[ 1.,  0.,  1.],
       [ 1.,  0.,  0.],
       [ 0.,  1.,  0.]])

可以调整二值化器的阈值：

>>> binarizer = preprocessing.Binarizer(threshold=1.1)
>>> binarizer.transform(X)
array([[ 0.,  0.,  1.],
       [ 1.,  0.,  0.],
       [ 0.,  0.,  0.]])

对于StandardScaler and Normalizer类，预处理模块提供了一个配套函数binarize，以便在不需要变压器API时使用。

稀疏输入

binarize and Binarizer 接受来自scipy.sparse的密集数组和稀疏矩阵作为输入。
对于稀疏输入，数据将转换为压缩稀疏行表示（请参阅scipy.sparse.csr_matrix）。为了避免不必要的内存复制，建议在上游选择CSR表示。

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

from sklearn import  preprocessing

X = [[ 1., -1.,  2.],
     [ 2.,  0.,  0.],
     [ 0.,  1., -1.]]

binarizer = preprocessing.Binarizer().fit(X)  # fit does nothing  .fit(X) 可以去除
print(binarizer.transform(X))
"""
[[ 1.  0.  1.]
 [ 1.  0.  0.]
 [ 0.  1.  0.]]
"""

binarizer = preprocessing.Binarizer(threshold=1.1)
print(binarizer.transform(X))
"""
[[ 0.  0.  1.]
 [ 1.  0.  0.]
 [ 0.  0.  0.]]
"""
print(binarizer.transform([[-1.,  1., 0.]]))
# [[ 0.  0.  0.]]


print(preprocessing.binarize(X,1.1))
"""
[[ 0.  0.  1.]
 [ 1.  0.  0.]
 [ 0.  0.  0.]]
"""

print(preprocessing.binarize([[-1.,  1., 0.]],1.1))
# [[ 0.  0.  0.]]

4.3.5. Encoding categorical features

通常，特征不是给以连续值，而是分类别。例如，一个人可以具有 ["male", "female"]， ["from Europe", "from US", "from Asia"] , ["uses Firefox", "uses Chrome", "uses Safari", "uses Internet Explorer"] .。这样的特征可以被有效地编码为整数，例如 ["male", "from US", "uses Internet Explorer"]可以表示为[0，1，3]，而 ["female", "from Asia", "uses Chrome"]将是[1，2，1]。

这样的整数表示不能直接与scikit学习估计器一起使用，因为这些估计值可以连续输入，并且会将类别解释为被排序，这通常是不需要的（即，该组浏览器是任意排序的）。

将分类功能转换为可与scikit学习估计器一起使用的功能的一种可能性是使用OneHotEncoder中实现的K或单热编码。该估计器将具有m个可能值的每个分类特征转换为m个二进制特征，只有一个活动。

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

from sklearn import preprocessing
import numpy as np

enc = preprocessing.OneHotEncoder()
enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])
"""说明
第一列 取值 0、1        转成one_hot 需 2列
第二列 取值 0、1、2     转成one_hot 需 3列
第三列 取值 0、1、2、3  转成one_hot 需 4列
最后每一行转成 one_hot 需 2+3+4=9列
"""

print(enc.transform([[1, 2, 3]]).toarray())
# [[ 0.  1.  0.  0.  1.  0.  0.  0.  1.]]
# 前2列 0,1 对应 1 ；中间3列 0,0,1 对应 2 ； 最后4列 0,0,0,1 对应 3

默认情况下，每个特征可以从数据集自动推断多少值。可以使用参数n_values来显式地指定它。我们的数据集中有两个性别，三个可能的大陆和四个网络浏览器。然后我们拟合估计器，并转换一个数据点。结果，前两个数字编码性别，下一组三个数字的大陆和最后四个网络浏览器。
请注意，如果训练数据有可能缺少分类功能，则必须明确设置n_value。例如，

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

from sklearn import preprocessing
import numpy as np

enc = preprocessing.OneHotEncoder()
enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])
"""说明
第一列 取值 0、1        转成one_hot 需 2列
第二列 取值 0、1、2     转成one_hot 需 3列
第三列 取值 0、1、2、3  转成one_hot 需 4列
最后每一行转成 one_hot 需 2+3+4=9列
"""

print(enc.transform([[1, 2, 3]]).toarray())
# [[ 0.  1.  0.  0.  1.  0.  0.  0.  1.]]
# 前2列 0,1 对应 1 ；中间3列 0,0,1 对应 2 ； 最后4列 0,0,0,1 对应 3

# ---------------------------------------------------------------------------

enc = preprocessing.OneHotEncoder(n_values=[2, 3, 4]) # 第一列2个特征，第二列3个特征，第3列4个特征
# Note that there are missing categorical values for the 2nd and 3rd
# features
enc.fit([[1, 2, 3], [0, 2, 0]])


print(enc.transform([[1, 0, 0]]).toarray())
# [[ 0.  1.  1.  0.  0.  1.  0.  0.  0.]]

# ---------------------------------------------------------------------------

enc = preprocessing.OneHotEncoder()
# Note that there are missing categorical values for the 2nd and 3rd
# features
enc.fit([[1, 2, 3], [0, 2, 0]])


print(enc.transform([[1, 0, 0]]).toarray())
# [[ 0.  1.  0.  1.  0.]]

See Loading features from dicts for categorical features that are represented as a dict, not as integers.

4.3.6. Imputation of missing values

由于各种原因，许多现实世界的数据集包含缺少的值，通常编码为空白，NaN或其他占位符。然而，这样的数据集与scikit学习估计器不兼容，假设数组中的所有值都是数字的，并且都具有并且具有含义。使用不完整数据集的基本策略是丢弃包含缺失值的整个行和/或列。然而，这是以丢失可能是有价值的数据（即使不完整）的代价。更好的策略是估算缺失值，即从数据的已知部分推断它们。

Imputer 类提供了使用缺失值所在的行或列的均值，中值或最常用值来估算缺失值的基本策略。这个类也允许不同的缺失值编码。
以下代码段演示了如何使用包含缺失值的列（轴0）的平均值来替换编码为np.nan的缺失值：

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

import numpy as np
from sklearn.preprocessing import Imputer

imp = Imputer(missing_values='NaN', strategy='mean', axis=0)
imp.fit([[1, 2], [np.nan, 3], [7, 6]])

X = [[np.nan, 2], [6, np.nan], [7, 6]]
print(imp.transform(X))
"""
[[ 4.          2.        ]
 [ 6.          3.66666667]
 [ 7.          6.        ]]
"""
print(imp.fit_transform([[1, 2], [np.nan, 3], [7, 6]]))
"""
[[ 1.  2.]
 [ 4.  3.]
 [ 7.  6.]]
"""

The Imputer class also supports sparse matrices:

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

import numpy as np
from sklearn.preprocessing import Imputer
import scipy.sparse as sp

X = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
imp = Imputer(missing_values=0, strategy='mean', axis=0)
imp.fit(X)

X_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
print(imp.transform(X_test))
"""
[[ 4.          2.        ]
 [ 6.          3.66666667]
 [ 7.          6.        ]]
"""
print(imp.fit_transform(X))
"""
[[ 1.  2.]
 [ 4.  3.]
 [ 7.  6.]]
"""

请注意，在这里，缺失值由0编码，因此隐式存储在矩阵中。因此，当比观察值更多的缺失值时，此格式是合适的。

Imputer可以在管道中用作构建支持插补的复合估计器的方法。See Imputing missing values before building an estimator.。

4.3.7. Generating polynomial features

通过考虑输入数据的非线性特征，增加模型的复杂性。一个简单而常用的方法是多项式特征，可以获得特征的高阶和交互项。它在 PolynomialFeatures :实现：

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

import numpy as np
from sklearn.preprocessing import PolynomialFeatures
X = np.arange(6).reshape(3, 2)

poly = PolynomialFeatures(2)
print(poly.fit_transform(X))
"""
[[  1.   0.   1.   0.   0.   1.]
 [  1.   2.   3.   4.   6.   9.]
 [  1.   4.   5.  16.  20.  25.]]
"""

The features of X have been transformed from $(X_1, X_2)$ to $(1, X_1, X_2, X_1^2, X_1X_2, X_2^2)$

在某些情况下，只需要功能之间的交互项，并且可以通过设置来获得interaction_only=True：

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

import numpy as np
from sklearn.preprocessing import PolynomialFeatures


X = np.arange(9).reshape(3, 3)

poly = PolynomialFeatures(degree=3, interaction_only=True)
print(poly.fit_transform(X))
"""
[[   1.    0.    1.    2.    0.    0.    2.    0.]
 [   1.    3.    4.    5.   12.   15.   20.   60.]
 [   1.    6.    7.    8.   42.   48.   56.  336.]]
"""

The features of X have been transformed from $(X_1, X_2, X_3)$ to $(1, X_1, X_2, X_3, X_1X_2, X_1X_3, X_2X_3, X_1X_2X_3)$ .

注意，当使用多项式Kernel函数时，kernel methods (e.g., sklearn.svm.SVC, sklearn.decomposition.KernelPCA) 中隐式使用。Kernel functions.
使用Polynomial interpolation参见Ridge回归的多项式插值。

4.3.8. Custom transformers

通常，您将需要将现有的Python函数转换为transformer ，以协助数据清理或处理。您可以使用FunctionTransformer从任意函数实现transformer。例如，要构建在管道中应用日志转换的变压器，请执行以下操作：

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

import numpy as np
from sklearn.preprocessing import FunctionTransformer

transformer = FunctionTransformer(np.log1p)
X = np.array([[0, 1], [2, 3]])
print(transformer.transform(X))
"""
[[ 0.          0.69314718]
 [ 1.09861229  1.38629436]]
"""

For a full code example that demonstrates using a FunctionTransformer to do custom feature selection, see Using FunctionTransformer to select columns

风吴痕

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
1
评论
sklearn-Preprocessing

参考：1、http://scikit-learn.org/stable/2、http://scikit-learn.org/stable/modules/preprocessing.html#preprocessing4.3. Preprocessing datasklearn.preprocessing软件包提供了几个常见的实用功能和变换器类，以将原始
复制链接

扫一扫