数据预处理

最新推荐文章于 2021-09-20 16:12:16 发布

小小蒲公英

最新推荐文章于 2021-09-20 16:12:16 发布

阅读量761

点赞数

CC 4.0 BY-SA版权

分类专栏： Python 机器学习

本文链接：https://blog.youkuaiyun.com/weixin_39777626/article/details/79935898

Python 同时被 2 个专栏收录

120 篇文章

订阅专栏

机器学习

44 篇文章

订阅专栏

二元化

模型原型

class sklearn.preprocessing.Binarizer(threshold=0.0,copy=True)
参数

threshold:指定属性阙值
copy:如果为True，则执行原地修改

方法

fit(X,[,y]):不做任何事，主要用于流水线Pipeline
transform(X[,y,copy]):将每一个样本的属性二元化
fit_transform(X[,y]):将每一个样本的属性二元化

示例

from sklearn.preprocessing import Binarizer
X=[
    [1,2,3,4,5],
    [5,4,3,2,1],
    [3,3,3,3,3],
    [1,1,1,1,1]
]
print('before transform:\n',X)
binarizer=Binarizer(threshold=2.5)
print('after transform:\n',binarizer.transform(X))

独热码

模型原型

class sklearn.preprocessing.OneHotEncoder(n_values=’auto’,categorical_features=’all’,dtype=/, sparse=True,handle_unknown=’error’)
参数

n_values:指定每个属性的上界
- ’auto’:自动从训练数据中推断属性值取值的上界
- 一个整数:指定所有属性取值的上界
- 一个整数的数组:依次指定每个属性的上界
categorical_features:指定哪些属性需要编码独热码
- ’all’
- 一个下标的数组:指定下标的属性将编码为独热码
- 一个mask:对应为True的属性将编码为独热码
dtype:指定独热码编码的数值类型（默认为np.float）
sparse:指定结果是否为稀疏
handle_unknown:如果进行数据转换时，遇到了某个集合类型的属性，但是该属性未列入categorical_features时的情形，可以指定为
- ’error’:抛出异常
- ‘ignore’:忽略

属性

activefeatures:激活特征
featureindices:原始数据的第i个属性对应转换后数据的
(featureindices[i],featureindices[i+1])之间的属性
n_values:存放每个属性取值的种类

方法

fit(X,[,y]):训练OneHotEncoder
transform(X[,y,copy]):对原始数据执行独热码编码
fit_transform(X[,y])

示例

from sklearn.preprocessing import OneHotEncoder
X=[
    [1,2,3,4,5],
    [5,4,3,2,1],
    [3,3,3,3,3],
    [1,1,1,1,1]
]
print('before transform:\n',X)
encoder=OneHotEncoder(sparse=False)
encoder.fit(X)
print('active_features_:\n',encoder.active_features_)
print('feature_indices_:\n',encoder.feature_indices_)
print('n_values_:\n',encoder.n_values_)
print('after transform:\n',encoder.transform([[1,2,3,4,5]]))

标准化

MinMaxScaler

模型原型

class sklearn.preprocessing.MinMaxScaler(feature_range=(0,1),copy=True)
参数

feature_range:指定预期变换后属性的取值范围
copy:如果为True，则执行原地修改

属性

min_:一个数组，给出每个属性的原始的最小值调整值
scale_:一个数组，给出每个属性的缩放倍数
data_min_
data_max_
data_range_

方法

fit(X,[,y]):计算每个属性的最大值，最小值，为后续的转换做准备
transform(X):执行属性标准化
fit_transform(X[,y])
inverse_transform(X):逆标准化，还原成原始数据
partial_fit(X[,y]):批量学习，学习部分数据

示例

from sklearn.preprocessing import MinMaxScaler
X=[
    [1,5,1,2,10],
    [2,6,3,2,7],
    [3,7,5,6,4],
    [4,8,7,8,1]
]
print('before transform:\n',X)
scaler=MinMaxScaler(feature_range=(0,2))
scaler.fit(X)
print('min_ :\n',scaler.min_)
print('scale_:\b',scaler.scale_)
print('data_max_:\n',scaler.data_max_)
print('sata_min_:\n',scaler.data_min_)
print('data_range_:\n',scaler.data_range_)
print('after transform:\n',scaler.transform(X))

MaxAbsScaler

模型原型

class sklearn.preprocessing.MaxAbsScaler(copy=True)
参数

copy:如果为True，则执行原地修改

属性

scale_:一个数组，给出每个属性的缩放倍数的倒数
maxabs:一个数组，给出每个属性的绝对值的最大值
n_samplesseen:一个整数，给出当前已经处理的样本的数量（用于分批训练）

方法

fit(X,[,y]):计算每个属性绝对值的最大值，为后续的转换做准备
transform(X):执行属性标准化
fit_transform(X[,y])
inverse_transform(X):逆标准化，还原成原始数据
partial_fit(X[,y]):批量学习，学习部分数据

示例

from sklearn.preprocessing import MaxAbsScaler
X=[
    [1,5,1,2,10],
    [2,6,3,2,7],
    [3,7,5,6,4],
    [4,8,7,8,1]
]
print('before transform:\n',X)
scaler=MaxAbsScaler()
scaler.fit(X)
print('scale_:\n',scaler.scale_)
print('max_abs_is:\n',scaler.max_abs_)
print('after transform:\n',scaler.transform(X))

StandardScaler

模型原型

class sklearn.preprocessing.StandardScaler(copy=True,with_mean=True,with_std=True)
参数

copy:如果为True，则执行原地修改
with_mean:如果为True，则缩放之前先将数据中心化（属性值减去均值）
with_std:如果为True，则缩放数据到单位方差

属性

scale_:一个数组，给出每个属性的缩放倍数的倒数
maxabs:一个数组，给出每个属性的绝对值的最大值
n_samplesseen:一个整数，给出当前已经处理的样本的数量（用于分批训练）

方法

fit(X,[,y]):计算每个属性方差和标准差，为后续的转换做准备
transform(X):执行属性标准化
fit_transform(X[,y])
inverse_transform(X):逆标准化，还原成原始数据
partial_fit(X[,y]):批量学习，学习部分数据

示例

from sklearn.preprocessing import StandardScaler
X=[
    [1,5,1,2,10],
    [2,6,3,2,7],
    [3,7,5,6,4],
    [4,8,7,8,1]
]
print('before transform:\n',X)
scaler=StandardScaler()
scaler.fit(X)
print('scale_:\n',scaler.scale_)
print('mean_:\n',scaler.mean_)
print('var_:\n',scaler.var_)
print('after transform:\n',scaler.transform(X))

正则化

模型原型

class sklearn.preprocessing.Normalizer(norm=’l2,copy=True)
参数

norm:指定正则化方法

l1:采用 $L_1$ 范数正则化
l2:采用 $L_2$ 范数正则化
max:采用 $L_∞$ 范数正则化

copy:如果为True，则执行原地修改

方法

fit(X,[,y]):不做任何事，主要用于流水线Pipeline
transform(X[,y,copy]):将每一个样本正则化为范数1
fit_transform(X[,y])

示例

from sklearn.preprocessing import Normalizer
X=[
    [1,2,3,4,5],
    [5,4,3,2,1],
    [1,3,5,2,4],
    [2,4,1,3,5]
]
print('before transform:\n',X)
normalizer=Normalizer(norm='l2')
print('after transform:\n',normalizer.transform(X))

过滤式特征选取

VarianceThreshold

模型原型

class sklearn.feature_selection.VarianceThreshold(threshold=0.0)
参数

threshold:指定预期变换后属性的取值范围,指定方差的阙值，低于此阙值将被剔除

属性

variances_:一个数组，分别为各属性的方差

方法

fit(X,[,y]):从样本数据中学习方差
transform(X):执行属性标准化,执行特征选择（删除低于阙值的属性）
fit_transform(X[,y])
get_support([indices])
- True:返回被选出的特征的下标
- False:返回一个布尔值组成的数组，该数组指示哪些特征被选中
inverse_transform(X):逆标准化，还原成原始数据

示例

from sklearn.feature_selection import VarianceThreshold
X=[
    [100,1,2,3],
    [100,4,5,6],
    [100,7,8,9],
    [101,11,12,13]
]
selector=VarianceThreshold(1)
selector.fit(X)
print('Variances is %s'%selector.variances_)
print('After transform is \n%s'%selector.transform(X))
print('The surport is %s'%selector.get_support(True))
print('After reverse transform is \n%s'%selector.inverse_transform(selector.transform(X)))

单变量特征提取

SelectKBest

模型原型

class sklearn.feature_selection.SelectKBest(score_func=,k=10)
参数

score_func:给出统计指标
- sklearn.feature_selection.f_regression:基于线性回归分析来计算统计指标。适用于回归问题
- sklearn.feature_selection.chi2:计算卡方统计量，适用于分类问题
- sklearn.feature_selection.f_classif:根据方差分析（ANOVA）的原理，以F-分布为依据，利用平方和与自由度所计算的祖居与组内均方估计出F值，适用于分类问题
k:指定要保留最佳的几个特征

属性

scores_
pvalues_:给出所有特征得分的p值

方法

fit(X,[,y]):从样本数据中学习统计指标得分
transform(X):执行特征选择
fit_transform(X[,y])
get_support([indices])
- True:返回被选出的特征的下标
- False:返回一个布尔值组成的数组，该数组指示哪些特征被选中
- inverse_transform(X):根据选出来的特征还原原始数据,但对于被删除的属性值全部用0代替

SelectPercentile

模型原型

class sklearn.feature_selection.SelectPercentile(score_func=,percentile=10)
参数

score_func:给出统计指标
- sklearn.feature_selection.f_regression:基于线性回归分析来计算统计指标。适用于回归问题
- sklearn.feature_selection.chi2:计算卡方统计量，适用于分类问题
- sklearn.feature_selection.f_classif:根据方差分析（ANOVA）的原理，以F-分布为依据，利用平方和与自由度所计算的祖居与组内均方估计出F值，适用于分类问题
percentile:指定要保留最佳的百分之几的特征

属性

scores_
pvalues_:给出所有特征得分的p值

方法

fit(X,[,y]):从样本数据中学习统计指标得分
transform(X):执行特征选择
fit_transform(X[,y])
get_support([indices])
- True:返回被选出的特征的下标
- False:返回一个布尔值组成的数组，该数组指示哪些特征被选中
inverse_transform(X):根据选出来的特征还原原始数据,但对于被删除的属性值全部用0代替

示例

from sklearn.feature_selection import SelectKBest,f_classif
X=[
    [1,2,3,4,5],
    [5,4,3,2,1],
    [3,3,3,3,3],
    [1,1,1,1,1]
]
y=[0,1,0,1]
print('before transform:\n',X)
selector=SelectKBest(score_func=f_classif,k=3)
selector.fit(X,y)
print('scores_:\n',selector.scores_)
print('pvalues_:',selector.pvalues_)
print('selected index:',selector.get_support(True))
print('after transform:\n',selector.transform(X))

包裹式特征选取

RFE

模型原型

class sklearn.feature_selection.RFE(estimator,n_features_to_select=None,step=1,estimator_params=None,verbose=0)
参数

estimator:一个学习器（通常使用SVM和广义线性模型作为estimator）
n_features_to_select:指定要选出几个特征
step:指定每次迭代要剔除权重最小的几个特征
- 大于等于1：指定每次迭代要剔除权重最小的特征的数量
- 在0.0~1.0：指定每次迭代要剔除权重最小的特征的比例
estimator_params:一个字典，用于设定estimator的参数
verbose

属性

nfeatures:给出了被选出的特征的数量
support_:一个数组，给出了被选择特征的mask
ranking_:特征排名

方法

fit(X,y):训练RFE模型
transform(X):执行特征选择
fit_transform(X,y):从样本数据中学习RFE模型，然后执行特征选择
get_support([indices])
inverse_transform(X)
predict(X)/predict_log_proba(X)/predict_proba(X):将X进行特征选择之后，在使用内部的estimator来预测
score(X,y):将X进行特征选择之后，在使用内部的estimator来评分

示例

from sklearn.feature_selection import RFE
from sklearn.svm import LinearSVC
from sklearn.datasets import load_iris
iris=load_iris()
X=iris.data
y=iris.target
estimator=LinearSVC()
selector=RFE(estimator=estimator,n_features_to_select=2)
selector.fit(X,y)
print('N_features %s'%selector.n_features_)
print('Support is %s'%selector.support_)
print('Ranking %s'%selector.ranking_)

特征提取对于预测性能的提升没有必然的联系

from sklearn.feature_selection import RFE
from sklearn.svm import LinearSVC
from sklearn import cross_validation
from sklearn.datasets import load_iris

#加载数据
iris=load_iris()
X,y=iris.data,iris.target

#特征提取
estimator=LinearSVC()
selector=RFE(estimator=estimator,n_features_to_select=2)
X_t=selector.fit_transform(X,y)

#切分测试集与验证集
X_train,X_test,y_train,y_test=cross_validation.train_test_split(X,y,test_size=0.25,random_state=0,stratify=y)
X_train_t,X_test_t,y_train_t,y_test_t=cross_validation.train_test_split(X_t,y,test_size=0.25,random_state=0,stratify=y)

#测试与验证
clf=LinearSVC()
clf_t=LinearSVC()
clf.fit(X_train,y_train)
clf_t.fit(X_train_t,y_train_t)
print('Original DataSet:test score=%s'%(clf.score(X_test,y_test)))
print('Selected DataSet:test score=%s'%(clf_t.score(X_test_t,y_test_t)))

RFECV

模型原型

class sklearn.feature_selection.RFECV(estimator,step=1,cv=None,scoring=None,estimator_params=None,verbose=0)
参数

estimator:一个学习器（通常使用SVM和广义线性模型作为estimator）
step:指定每次迭代要剔除权重最小的几个特征
- 大于等于1：指定每次迭代要剔除权重最小的特征的数量
- 在0.0~1.0：指定每次迭代要剔除权重最小的特征的比例
cv:决策力交叉验证策略
- None:使用默认的3折交叉验证
- 整数k:使用k折交叉验证
- 交叉验证生成器:直接使用该对象
- 可迭代对象:使用该可迭代对象迭代生成训练——测试集合
scoring
estimator_params:一个字典，用于设定estimator的参数
verbose

属性

n_features_:给出了被选出的特征的数量
support_:一个数组，给出了被选择特征的mask
ranking_:特征排名
grid_scores_

方法

fit(X,y):训练RFECV模型
transform(X):执行特征选择
fit_transform(X,y):从样本数据中学习RFE模型，然后执行特征选择
get_support([indices])
inverse_transform(X)
predict(X)/predict_log_proba(X)/predict_proba(X):将X进行特征选择之后，在使用内部的estimator来预测
score(X,y):将X进行特征选择之后，在使用内部的estimator来评分

示例

import numpy as np
from sklearn.feature_selection import RFECV
from sklearn.svm import LinearSVC
from sklearn.datasets import load_iris

iris=load_iris()
X=iris.data
y=iris.target
estimator=LinearSVC()
selector=RFECV(estimator=estimator,cv=3)
selector.fit(X,y)
print('N_features %s'%selector.n_features_)
print('Support is %s'%selector.support_)
print('Ranking %s'%selector.ranking_)
print('Grid Scores %s'%selector.grid_scores_)

嵌入式特征选取

模型原型

class sklearn.feature_selection.SelectFromModel(estimator,threshold=None,prefit=False)
参数

estimator:一个学习器
threshold:指定特征重要性的一个阙值
- 浮点数:指定阙值的绝对大小
- 字符串
  - ’mean’
  - ‘median’
  - ‘n*mean’:表示阙值为n倍的特征重要性的均值
- None
  - 阙值默认为’mean’
  - 如果estimator有一个penalty参数,且该参数设置为’l1’,则阙值默认为1e-5
prefit

属性

threshold_:存储了用于特征选取重要性的阙值

方法

fit(X,y)
transform(X):执行特征选择
fit_transform(X,y):从样本数据中学习RFE模型，然后执行特征选择
get_support([indices])
inverse_transform(X)
partial_fit(X,[,y]):只训练SelectFromModel模型一次

示例

import numpy as np
from sklearn.feature_selection import SelectFromModel
from sklearn.svm import LinearSVC
from sklearn.datasets import load_digits
digits=load_digits()
X=digits.data
y=digits.target
estimator=LinearSVC(penalty='l1',dual=False)
selector=SelectFromModel(estimator=estimator,threshold='mean')
selector.fit(X,y)
selector.transform(X)
print('Threshold %s'%selector.threshold_)
print('Support is \n%s'%selector.get_support(indices=True))

α和C参数与稀疏性的关系

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import LinearSVC
from sklearn.datasets import load_digits,load_diabetes
from sklearn.linear_model import Lasso

def test_Lasso(*data):
    X,y=data
    alphas=np.logspace(-2,2)
    zeros=[]
    for alpha in alphas:
        regr=Lasso(alpha=alpha)
        regr.fit(X,y)
        #计算零的个数
        num=0
        for ele in regr.coef_:
            if abs(ele)<1e-5:num+=1
        zeros.append(num)
    #绘图
    fig=plt.figure()
    ax=fig.add_subplot(1,1,1)
    ax.plot(alphas,zeros)
    ax.set_xlabel(r'$\alpha$')
    ax.set_ylabel('zeros in coef')
    ax.set_xscale('log')
    ax.set_ylim(0,X.shape[1]+1)
    ax.set_title('Sparsity In Lasso')
    plt.show()

def test_LinearSVC(*data):
    X,y=data
    Cs=np.logspace(-2,2)
    zeros=[]
    for C in Cs:
        clf=LinearSVC(C=C,penalty='l1',dual=False)
        clf.fit(X,y)
        #计算零的个数
        num=0
        for row in clf.coef_:
            for ele in row:
                if abs(ele)<1e-5:num+=1
        zeros.append(num)
    #绘图
    fig=plt.figure()
    ax=fig.add_subplot(1,1,1)
    ax.plot(Cs,zeros)
    ax.set_xlabel('C')
    ax.set_ylabel('zeros in coef')
    ax.set_xscale('log')
    ax.set_title('Sparsity In SVM')
    plt.show()

if __name__=='__main__':
    data=load_diabetes()
    test_Lasso(data.data,data.target)
    data=load_digits()
    test_LinearSVC(data.data,data.target)

学习器流水线（Pipeline）

模型原型

class sklearn.pipeline.Pipeline(steps)
参数

steps:列表的元素为(name,transform)元组,其中name是学习器的名字,用于输出和日志;transform是学习器，必须提供transform方法

属性

named_steps

方法

fit(X[,y]):启动流水线
transform(X):启动流水线
fit_transform(X[,y])
get_support([indices])
inverse_transform(X)
predict(X)/predict_log_proba(X)/predict_proba(X):将X进行特征选择之后，在使用内部的estimator来预测
score(X,y):将X进行特征选择之后，在使用内部的estimator来评分

示例（代码有问题，待处理）

from sklearn.svm import LinearSVC
from sklearn.datasets import load_digits
from sklearn import cross_validation
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline

def test_Pipeline(data):
    X_train,X_test,y_train,y_test=data
    steps= [('Linear_SVM',LinearSVC(C=1.0,penalty='l1',dual=False)), ('LogisticRegression',LogisticRegression(C=1))]
    pipeline=Pipeline(steps)
    pipeline.fit(X_train,y_train)
    print('Named steps:',pipeline.named_steps)
    print('Pipeline Score:',pipeline.score(X_test,y_test))

if __name__=='__main__':
    data=load_digits()
    X=data.data
    y=data.target
    test_Pipeline(cross_validation.train_test_split(X,y,test_size=0.25,random_state=0,stratify=y))

字典学习

DictionaryLearning

模型原型

class sklearn.decomposition.DictionsryLearning(n_components=None,alpha=1,max_iter=1000,tol=1e-08,fit_algorithm=’lars’,transform_algorithm=’omp’,transform_n_nonzero_coefs=None,transform_alpha=None,n_jobs=1,code_init=None,dict_init=None,verbose=False,split_sign=False,random_state=None)
参数

n_components:指定字典大小k
alpha:指定L1L1，正则化项的系数λ，它控制了稀疏性
max_iter
tol
fit_algorithm:指定求解算法
- ’lars’:least angle regression算法
- ‘cd’:coordinate descent算法
transform_algorithm:指定数据转换方法
- ’lasso_lars’:Lars算法
- ‘lasso_cd’:coordinate descent算法
- ‘lars’:least angle regression算法
- ‘omp’:正交匹配方法
- ‘threshold’:通过字典转换后的坐标中，小于transform_alpha的属性都设成0
transform_n_nonzero_coefs:指定每一列中非零元素的个数。只用于lars算法和omp算法
transform_alpha
- 如果算法为lasso_lars或者lasso_cd,则该参数指定了L1正则化项的系数
- 如果算法为threshold,则该参数指定了属性为0的阙值
- 如果算法为omp,则该参数指定了重构误差的阙值
n_jobs
code_init:指定初始编码
dict_init:指定初始字典
verbose
split_sign:是否拆分系数特征向量为其正向值和负向值的拼接
random_state

属性

components_:存放学到的字典
error_:存放每一轮迭代的误差
n_iter:存放迭代的次数

方法

fit(X,y)
transform(X)
fit_transform(

X,y)
示例

from sklearn.decomposition import DictionaryLearning
X=[
    [1,2,3,4,5],
    [6,7,8,9,10],
    [10,9,8,7,6],
    [5,4,3,2,1]
]
print('before transform:',X)
dct=DictionaryLearning(n_components=3)
dct.fit(X)
print('components is:\n',dct.components_)
print('after transform:\n',dct.transform(X))

MiniBatchDictionaryLearning

模型原型

class sklearn.decomposition.MiniBatchDictionaryLearning(n_components=None,alpha=1,n_iter=1000,fit_algorithm=’lars’, n_jobs=1,batch_size=3,shuffle=True,dict_init=None,transform_algorithm=’omp’,transform_n_nonzero_coefs=None, transform_alpha=None,verbose=False,split_sign=False,random_state=None)
参数

n_components:指定字典大小k
alpha:指定L1L1，正则化项的系数λ，它控制了稀疏性
n_iter
fit_algorithm:指定求解算法
- ’lars’:least angle regression算法
- ‘cd’:coordinate descent算法
n_jobs
batch_size:每次训练时的样本数量
shuffle:训练样本之前是否进行混洗
dict_init:初始字典
transform_algorithm:指定数据转换方法
- ’lasso_lars’:Lars算法
- ‘lasso_cd’:coordinate descent算法
- ‘lars’:least angle regression算法
- ‘omp’:正交匹配方法
- ‘threshold’:通过字典转换后的坐标中，小于transform_alpha的属性都设成0
transform_n_nonzero_coefs:指定每一列中非零元素的个数。只用于lars算法和omp算法
transform_alpha
- 如果算法为lasso_lars或者lasso_cd,则该参数指定了L1正则化项的系数
- 如果算法为threshold,则该参数指定了属性为0的阙值
- 如果算法为omp,则该参数指定了重构误差的阙值
verbose
split_sign:是否拆分系数特征向量为其正向值和负向值的拼接
random_state