zoukankan      html  css  js  c++  java
  • preprocessing

    二、标准化(Standardization),或者去除均值和方差进行缩放

    公式为:(X-X_mean)/X_std 计算时对每个属性/每列分别进行.

    将数据按其属性(按列进行)减去其均值,然后除以其方差。最后得到的结果是,对每个属性/每列来说所有数据都聚集在0附近,方差值为1。

    首先说明下sklearn中preprocessing库里面的scale函数使用方法:

    sklearn.preprocessing.scale(X, axis=0, with_mean=True,with_std=True,copy=True)
    • X:数组或者矩阵
    • axis:int类型,初始值为0,axis用来计算均值 means 和标准方差 standard deviations. 如果是0,则单独的标准化每个特征(列),如果是1,则标准化每个观测样本(行)。
    • with_mean: boolean类型,默认为True,表示将数据均值规范到0
    • with_std: boolean类型,默认为True,表示将数据方差规范到1

    一个简单的例子

    假设现在我构造一个数据集X,然后想要将其标准化。下面使用不同的方法来标准化X:

    方法一:使用sklearn.preprocessing.scale()函数

    方法说明:

    • X.mean(axis=0)用来计算数据X每个特征的均值;
    • X.std(axis=0)用来计算数据X每个特征的方差;
    • preprocessing.scale(X)直接标准化数据X。

    将代码整理到一个文件中:

    from sklearn import preprocessing 
    import numpy as np
    X = np.array([[ 1., -1.,  2.],
                  [ 2.,  0.,  0.],
                  [ 0.,  1., -1.]])
    # calculate mean
    X_mean = X.mean(axis=0)
    # calculate variance 
    X_std = X.std(axis=0)
    # standardize X
    X1 = (X-X_mean)/X_std
    # use function preprocessing.scale to standardize X
    X_scale = preprocessing.scale(X)

    最后X_scale的值和X1的值是一样的,前面是单独的使用数学公式来计算,主要是为了形成一个对比,能够更好的理解scale()方法。

    方法2:sklearn.preprocessing.StandardScaler类

    该方法也可以对数据X进行标准化处理,实例如下:

    from sklearn import preprocessing 
    import numpy as np
    X = np.array([[ 1., -1.,  2.],
                  [ 2.,  0.,  0.],
                  [ 0.,  1., -1.]])
    scaler = preprocessing.StandardScaler()
    X_scaled = scaler.fit_transform(X)

    这两个方法得到最后的结果都是一样的。


    三、将特征的取值缩小到一个范围(如0到1)

    除了上述介绍的方法之外,另一种常用的方法是将属性缩放到一个指定的最大值和最小值(通常是1-0)之间,这可以通过preprocessing.MinMaxScaler类来实现。

    使用这种方法的目的包括:

    • 1、对于方差非常小的属性可以增强其稳定性;
    • 2、维持稀疏矩阵中为0的条目。

    下面将数据缩至0-1之间,采用MinMaxScaler函数

    from sklearn import preprocessing 
    import numpy as np
    X = np.array([[ 1., -1.,  2.],
                  [ 2.,  0.,  0.],
                  [ 0.,  1., -1.]])
    min_max_scaler = preprocessing.MinMaxScaler()
    X_minMax = min_max_scaler.fit_transform(X)

    最后输出:

    array([[ 0.5       ,  0.        ,  1.        ],
           [ 1.        ,  0.5       ,  0.33333333],
           [ 0.        ,  1.        ,  0.        ]])

    测试用例:

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

    注意:这些变换都是对列进行处理。

    当然,在构造类对象的时候也可以直接指定最大最小值的范围:feature_range=(min, max),此时应用的公式变为:

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

    四、正则化(Normalization)

    正则化的过程是将每个样本缩放到单位范数(每个样本的范数为1),如果要使用如二次型(点积)或者其它核方法计算两个样本之间的相似性这个方法会很有用。

    该方法是文本分类和聚类分析中经常使用的向量空间模型(Vector Space Model)的基础.

    Normalization主要思想是对每个样本计算其p-范数,然后对该样本中每个元素除以该范数,这样处理的结果是使得每个处理后样本的p-范数(l1-norm,l2-norm)等于1。

    方法1:使用sklearn.preprocessing.normalize()函数

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

    方法2:sklearn.preprocessing.StandardScaler类

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

    两种方法都可以,效果是一样的。


    五、二值化(Binarization)

    特征的二值化主要是为了将数据特征转变成boolean变量。在sklearn中,sklearn.preprocessing.Binarizer函数可以实现这一功能。实例如下:

    >>> 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函数也可以设定一个阈值,结果数据值大于阈值的为1,小于阈值的为0,实例代码如下:

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

    六、缺失值处理

    由于不同的原因,许多现实中的数据集都包含有缺失值,要么是空白的,要么使用NaNs或者其它的符号替代。这些数据无法直接使用scikit-learn分类器直接训练,所以需要进行处理。幸运地是,sklearn中的Imputer类提供了一些基本的方法来处理缺失值,如使用均值、中位值或者缺失值所在列中频繁出现的值来替换。

    下面是使用均值来处理的实例:

    >>> 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]])
    Imputer(axis=0, copy=True, missing_values='NaN', strategy='mean', verbose=0)
    >>> X = [[np.nan, 2], [6, np.nan], [7, 6]]
    >>> print(imp.transform(X))                           
    [[ 4.          2.        ]
     [ 6.          3.666...]
     [ 7.          6.        ]]

    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)
    Imputer(axis=0, copy=True, missing_values=0, strategy='mean', verbose=0)
    >>> X_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
    >>> print(imp.transform(X_test))                      
    [[ 4.          2.        ]
     [ 6.          3.666...]
     [ 7.          6.        ]]



    # ***coding:utf8***
    import numpy as np
    import pandas as pd
    from sklearn import preprocessing
    from sklearn.preprocessing import Imputer
    feature=pd.read_csv('C:UsersjiejiaoDesktop\feature3.csv')
    feature=feature.drop(['name','occupation'],axis=1)
    # preprocessing.scale or scaler=preprocessing.StandarScaler()+scaler.fit_transform()
    # 标准化,从此均值0,方差1
    feature_mean=feature.mean()
    feature_std=feature.std()
    feature_scale=(feature-feature_mean)/feature_std
    feature_scaled=preprocessing.scale(feature)
    # print feature_scale-feature_scaled
    # preprocessing.scale(x)=(x-x.mean)/x.std
    feature_scaled1=preprocessing.StandardScaler().fit(feature)
    scaler=preprocessing.StandardScaler()
    feature_scaled1=scaler.fit_transform(feature)
    # print feature_scaled-feature_scaled1
    # scaler=preprocessing.StandardScaler()
    # preprocessing.scale()=scaler.fit_transform()

    # 缩放到0~1,这些都是列变换
    X=np.array([
    [1.,-1.,2.],
    [2.,0.,0.],
    [0.,1.,-1.]
    ])
    min_max_scaler=preprocessing.MinMaxScaler()
    X_minMax=min_max_scaler.fit_transform(X)
    # print X_minMax

    # 缩放到-1~1除以每列最大值
    max_abs_scaler=preprocessing.MaxAbsScaler()
    feature_maxabs=max_abs_scaler.fit_transform(feature)
    # print feature_maxabs


    # 正则化,每行范数变成1,NORM默认是2,也可以选1,是1范数,2范数的意思
    X = [[ 1., -1., 2.],
    [ 2., 0., 0.],
    [ 0., 1., -1.]]
    X_normalized=preprocessing.normalize(X,norm='l2')
    # print X_normalized
    # 同样的
    normalizer=preprocessing.Normalizer()
    X_normalized1=normalizer.fit_transform(X)
    # print X_normalized1-X_normalized

    # 二值化binarization
    binarizer=preprocessing.Binarizer(threshold=1.2)
    X_binarized=binarizer.fit_transform(X)
    # print X_binarized
    #

    # 独热编码onehot encoder:可以将分类特征转化成数值特征
    enc=preprocessing.OneHotEncoder()
    enc.fit([[0,0,3],[1,1,0],[0,2,1],[1,0,2]])
    # print enc.transform([[0,1,3]]).toarray()

    # Imputer缺失值处理,用fit的性质去补transform的缺失值
    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)

    # 增加多项式特征
    from sklearn.preprocessing import PolynomialFeatures
    x=np.arange(6).reshape(3,2)
    poly=PolynomialFeatures(2)
    print poly.fit_transform(x)
    # 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)
    # In some cases, only interaction terms among features are required, and it can be gotten with the setting interaction_only=True:
    xx=np.arange(9).reshape(3, 3)
    poly = PolynomialFeatures(degree=3, interaction_only=True)
    poly.fit_transform(xx)
    # 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).


  • 相关阅读:
    Hadoop 学习笔记 (十) hadoop2.2.0 生产环境部署 HDFS HA Federation 含Yarn部署
    hadoop 2.x 安装包目录结构分析
    词聚类
    Hadoop 学习笔记 (十一) MapReduce 求平均成绩
    Hadoop 学习笔记 (十) MapReduce实现排序 全局变量
    Hadoop 学习笔记 (九) hadoop2.2.0 生产环境部署 HDFS HA部署方法
    Visual Studio Code 快捷键大全(Windows)
    Eclipse安装教程 ——史上最详细安装Java &Python教程说明
    jquery操作select(取值,设置选中)
    $.ajax 中的contentType
  • 原文地址:https://www.cnblogs.com/jojo123/p/6770340.html
Copyright © 2011-2022 走看看