机器学习之Sklearn详解
  • skleran库之数据预处理
skleran库之数据预处理
算法基础 . 2020/03/10发布 . shanyonggang_web . 我要评论 . 330阅读

sklearn数据预处理用到的包为sklearn.preprocessing,主要针对特征值进行操作的,sklearn.preprocessing软件包提供了几个常用的实用函数和转换器类

数据规范化

对于数据规范化,一般按照如下情况进行选择:

  • 在分类、聚类算法中,需要使用距离来度量相似性的时候、或者使用PCA技术进行降维的时候,StandardScaler表现更好。
  • 在不涉及距离度量、协方差计算、数据不符合正太分布的时候,可以使用MinMaxScaler。比如图像处理中,将RGB图像转换为灰度图像后将其值限定在[0 255]的范围。

数据标准化

将数据转换成均值为0,方差为1的标准正太分布,标准化可以规范数据,但不适用于稀疏数据,因为会破坏其数据结果。标准化的过程为两步:去均值的中心化(均值变为0);方差的规模化(方差变为1)。即每一列减去该列的均值再除以该列的方差,主要为scale类,具体如下:

所需要的类说明:sklearn.preprocessing.scale(X, axis=0, with_mean=True, with_std=True, copy=True),其中:

  • x,需要标准化的特征数据
  • axis,需要标准化的方向,0表示列,1表示行,默认为0
  • with_mean,是否去均值的中心化,默认为True
  • with_std,是否方差规模化,默认为True。
  • copy,是否需要copy数据

例如:

# 数据标准化标准正太分布
import numpy as np
from sklearn import preprocessing
X_train = np.array([[ 1., -1.,  2.],
                    [ 2.,  0.,  0.],
                    [ 0.,  1., -1.]])
X_scaled = preprocessing.scale(X_train)

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

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

preprocessing模块还提供了一个实用程序类StandardScaler,例如:

scaler = preprocessing.StandardScaler().fit(X_train)   
scaler.mean_
# array([1.        , 0.        , 0.33333333])
scaler.scale_
# array([0.81649658, 0.81649658, 1.24721913])
scaler.transform(X_train)  

数据归一化

归一化可以将稀疏的数据进行规范化,而且不会破坏其数据结构。归一化有两种,一种是归一化到[0,1]区间,另一种是归一化到[-1,1]区间内,这样是为了对付那些标准差相当小的特征并且保留下稀疏数据中的0值。主要为MinMaxScaler类,具体如下:

[0,1]归一化:

  • 对应的类:sklearn.preprocessing.MinMaxScaler(feature_range=(0, 1), copy=True),其中feature_range:要归一化的范围,copy:是否拷贝数据。
  • 类的方法:
  1. fit_transform(self, X, y=None, **fit_params) 将数据传入并转化,一般传入特征数据X即可,目标数据Y不需要转化。
  2. inverse_transform(self, X) 将数据的归一化去除,变回原来的数据。
  • 计算公式:
  1. X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
  2. X_scaled = X_std * (max - min) + min,其中max、min为sklearn.preprocessing.MinMaxScaler中参数feature的参数范围,一般默认是0、1。X.min(axis=0)表示列最小值

例如:

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.        ]]
min_max_scaler.scale_
# array([ 0.5       ,  0.5       ,  0.33...])
min_max_scaler.min_ 
# array([ 0.        ,  0.5       ,  0.33...])

[-1,1]归一化:

  • 对应的类:sklearn.preprocessing.MaxAbsScaler(copy=True)
  • 类的方法:fit_transform(self, X[, 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                # 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.])

分位数标准化

当含有较多的异常值的时候,普通的标准化不能很好的规范数据,所以要可以用分位数标准化,即用范围在第一分位数,第三分位数之间的数据的均值与方差来标准化数据,而不是所有的数据。所用到的类是RobustScaler,具体如下:

所需要的类说明:sklearn.preprocessing.RobustScaler(with_centering=True, with_scaling=True, quantile_range=(25.0, 75.0), copy=True)

  • with_centering:是否去中心化。
  • with_scaling:是否方差化。
  • quantile_range:分位数的范围,值为0-100之间。
  • copy:是否copy数据。

类方法:fit_transform(self, X[, y]) 传入数据并标准化。

例如:

import numpy as np
from sklearn.preprocessing import RobustScaler

x = np.random.normal(0, 1, [10, 1])  # 创建数据
x[0, 0] = 3  # 创建异常值
x_trans = RobustScaler().fit_transform(x)  # 标准化

print('x为:\n', x)
print('x_trans为:\n', x_trans)

二值化

特征二值化是阈值化数字特征以获得布尔值的过程

连续二值化:将数据二值化,当数据小于等于某个值转化为0,大于某个值转化为1,可以将数据简化,所用的类是Binarizer,具体如下:

类说明:sklearn.preprocessing.Binarizer(threshold=0.0, copy=True),其中:

  • threshold:二值化阈值,<=threshold转化为0,>threshold转化为1
  • copy:是否拷贝数据。

类的方法为:fit_transform(self, X, y=None, **fit_params) 传入数据并二值化,具体示例如下:

import numpy as np
from sklearn.preprocessing import Binarizer
X = [[ 1., -1.,  2.],
     [ 2.,  0.,  0.],
     [ 0.,  1., -1.]]
# 第一种方法
binarizer = preprocessing.Binarizer().fit(X)
binarizer.transform(X)
# 第二种方法(将fit和transform组合使用)
preprocessing.Binarizer().fit_transform(X)

离散二值化:相当于哑变量编码

类说明:sklearn.preprocessing.LabelBinarizer(neg_label=0, pos_label=1, sparse_output=False),其中:

  • neg_label:不属于该类的标签,默认为0。
  • pos_label:属于该类的标签,默认为1。
  • sparse_output:是否用稀疏矩阵格式输出,即索引加值的形式。

类的方法为:fit_transform(self, X, y=None, **fit_params) 传入数据并二值化

类的属性:LabelBinarizer().classes_ 用于查看二值化前离散特征原始值

例如:

import numpy as np
from sklearn.preprocessing import Binarizer,LabelBinarizer

x = ['ac','d','a','bd'] # 创建数据
transor=LabelBinarizer()    #创建转化器具
x_trans = transor.fit_transform(x)  # 二值化
print(x_trans)

哑变量on-hot编码:将离散数据转化成哑变量

类说明:sklearn.preprocessing.OneHotEncoder(n_values=None, categorical_features=None, categories=None, drop=None, sparse=True, dtype=<class ‘numpy.float64’>, handle_unknown=’error’),其中:

  • **n_values:可选值[None,'auto',int],用几个值(即几列0、1编码)来表示特征的离散值,默认是对单个特征,有几个离散值就有几个值对应。自己指定,如果学历分为[高,中,低],但是样本只有[高,低],为了把学历中也表示出来,就需要传入3。
  • **categorical_features:指定了对哪些训练特征(即那些列)进行编码,默认对所有训练特征都进行编码。也可以自己指定选择哪些特征,通过索引或者 bool 值来指定,例如对列[a,b,c]中的列[a,b]编码,则传入[a,b]。
  • categories:可选值['auto',list]。'auto'默认将特征的所有离散值转化。如果是list,则将保留categories[list]对应的离散值。一般默认就好。
  • drop:可选值[None,'first',list]。默认None表示将所有的离散值转化;'first',去掉第一个特征再将离散值转化,编码后全为0的表示第一个离散值;list:指定去除的离散值。建议默认就好。
  • **sparse:True返回稀疏矩阵,索引加值的矩阵。
  • dtype:数据类型。
  • handle_unknown:对空值怎么处理,‘error’ 表示报错,‘ignore’表示忽略。

类的方法:

  • fit_transform(self, X, y=None, **fit_params) 传入数据并二值化。
  • get_feature_names() 返回编码后的列的名字,形式为:特证名_离散值。
import numpy as np
from sklearn.preprocessing import OneHotEncoder

x = np.array([['a'],['b'],['a'],['c']]) # 创建数据
transor=OneHotEncoder(sparse=False)    #创建转化器具
x_trans = transor.fit_transform(x) # 二值化


print('x为:\n', x)
print('编码的后的列为:\n',transor.get_feature_names())
print('x_trans为:\n', x_trans)

pandas的哑变量编码

类说明:pandas.get_dummies(data, prefix=None, prefix_sep='_', dummy_na=False, columns=None, sparse=False, drop_first=False, dtype=None),其中:

  • data:传入的数据,数组、Series类或者dataframe类。
  • prefix:编码后列名的前缀,默认用特征名做为前缀,例如性别特征,编码后的列为[性别_男,性别_女]。如果要传入,长度要和特征数相同。
  • prefix_sep:编码后列名的间隔符,默认就好。
  • dummy_na:是否对NaNs类的数据进行单独的编码,否的话忽略NaNs数据。
  • sparse:是否输出稀疏矩阵,即index+值。
  • drop_first:是否去除第一个离散值再编码。
  • dtype:数据类型。
import pandas as pd

df=pd.DataFrame(data=[['a'],['b'],['c'],['a']],columns=['grade'])

df_dum=pd.get_dummies(df)
print(df_dum)

缺失值估算

由于各种原因,许多现实世界的数据集包含缺失值,通常将其编码为空白,NaN或其他占位符

单变量插补:即只根据特征自身来进行缺失值的补充

类说明:sklearn.impute.SimpleImputer(missing_values=nan, strategy=’mean’, fill_value=None, verbose=0, copy=True, add_indicator=False),其中:

  • missing_values:缺失值,用什么表示缺失值。默认是np.nan
  • 'strategy:插补缺失值的方法,'mean':均值;'median':中位数;'most_frequent':频数最高的数;'constant':用蚕食fill_value的值代替,默认为mean。
  •  fill_value:参数strategy='constant'时用来替换缺失值的值。
  • add_indicator:若为True则替换后对数据添加是否插补缺失值的标签。

类的方法:fit_transform(self, X, y=None, **fit_params) 传入数据补充缺失值

例如:

from sklearn.impute import SimpleImputer
import numpy as np

x=np.array([1,2,np.nan,10]).reshape(4,1)
imp=SimpleImputer(np.nan)
x_imp=imp.fit_transform(x)

print(x_imp)

 


  • 有疑问请在下方评论区留言,我会尽快回复。
  • Email私信我: 511248513@qq.com 或添加博主 微信

前一篇:已经是第一篇文章了!

后一篇:已经是最后一篇文章了!

本文作者:shanyonggang_web
发布时间:2020年3月10日 13:28
许可协议: 署名-非商业性使用 4.0 国际许可协议
知识共享许可协议     转载请保留原文链接及作者
正在加载今日诗词....
您的支持是博主写作最大的动力,如果您喜欢我的文章,感觉我的文章对您有帮助,请狠狠点击下面的


登录 后回复

当前暂无评论,点击登录来做第一个吃螃蟹的人吧!