Python机器学习-数据预处理（二）

http://sklearn.apachecn.org/cn/0.19.0/modules/preprocessing.html#preprocessing

保证特征之间的差异一样

2.1、缺失值处理

统计缺失值的个数

null_counts = loans.isnull().sum()

删除整个记录里任何一个变量有缺失值的记录
一般不建议使用

dropna=titanic_df.dropna()
dropna.info()

填充

import numpy as np
from sklearn.preprocessing import Imputer# 策略有 mean，most_frequent,median
imp=Imputer(missing_values='NaN',strategy='mean',axis=0)
imp.fit([[1,2],[np.nan,3],[7,6]])# fit 求得第一列特征值为4，第二列特征值为11/3
X=[[np.nan,2],[6,np.nan],[7,6]]
print(imp.transform(X))# 求均值
age_mean=round(titanic_df['Age'].mean())
# 均值填充
titanic_df['Age'].fillna(age_mean,inplace=True)
titanic_df.Age.describe()

2.1.2、字符型数据的处理

映射成数值型来替换，百分比的转成float
mapping_dict = {"emp_length": {"10+ years": 10,"9 years": 9,"8 years": 8,"7 years": 7,"6 years": 6,"5 years": 5,"4 years": 4,"3 years": 3,"2 years": 2,"1 year": 1,"< 1 year": 0,"n/a": 0}
}
loans = loans.drop(["last_credit_pull_d", "earliest_cr_line", "addr_state", "title"], axis=1)
loans["int_rate"] = loans["int_rate"].str.rstrip("%").astype("float")
loans["revol_util"] = loans["revol_util"].str.rstrip("%").astype("float")
loans = loans.replace(mapping_dict)

2.2、数据的标准化

所有函数都封装在sklearn.preprocessing

StandarScaler：缩放至0均值，1标准差
MinMaxScaler：缩放至[0,1]，也可以指定范围feature_range。
MaxAbsScaler：缩放至[-1,1]，无偏移。
RobustScaler：缩放有异常值的特征(有个别数特大或特小)

MinMaxScaler

from sklearn import preprocessingscaler=preprocessing.MinMaxScaler(feature_range=(0,1))   # 将样本的值缩放到0-1之间
scaler.fit(iris.data)
data=scaler.transform(iris.data)# 两个代码也可以合成一句
# data=scaler.fit_transform(iris.data)
target=iris.target
MaxAbsScaler：缩放至[-1,1]，无偏移。（稀疏矩阵推荐使用）

y为稀疏矩阵,使用MaxAbsScaler

y=np.array([0]*95+[0.0,20,0,10,-10])
y=y.reshape(-1,1)scaler=preprocessing.MaxAbsScaler(copy=True)
z=scaler.fit_transform(y)
z[-10:]

RobustScaler：缩放有异常值的特征(有个别数特大或特小)

# x为一个具有异常值的特征
x=np.array([10,1000,0,0,-30,0,20,0,10,0,0,-10])
x=x.reshape(-1,1)
# RobustScaler
robustscaler=preprocessing.RobustScaler(with_centering=True,with_scaling=True,quantile_range=(25.0,75.0),copy=True)
print(robustscaler.fit_transform(x))

2.3、数据正则化（归一化）

正则化是缩放单个样本以具有单位范数的过程。正则化有时也叫归一化。如果计划使用二次形式（如点积或任何其他核函数）来量化任何样本间的相似度，则此过程非常有用。

常用的是L2范数

from sklearn import preprocessingX=[[1.,-1.,2.],[2.,0.,0.],[0.,1.,-1.]]# 使用normalize函数
X_normalize=preprocessing.normalize(X,norm='l2')
print(X_normalize)# 使用Normalizer类
normalizer=preprocessing.Normalizer(norm='l1')
normalizer.fit(X)
normalizer.transform(X)

2.4、特征的二值化（不常用）

将数值特征用阙值过滤得到布尔值的过程。

X=[[1.,-1.,2.],[2.,0.,0.],[0.,1.,-1.]]
binarizer=preprocessing.Binarizer().fit(X)
binarizer
binarizer.transform(X)# 设定一个阙值
binarizer=preprocessing.Binarizer(threshold=1.1)
binarizer.transform(X)

2.5、分类特征的编码（独热编码）

机器学习中，特征经常不是数值型的而是分类型，（性别），如果分别用0和1来表示，数字就有运算的功能，性别就会变得有序了，不利于训练。为了解决这个问题，使用独热编码。

（1）、使用pandas进行独热编码

data : array-like, Series, or DataFrame：输入的数据
prefix : string, list of strings, or dict of strings, default None：get_dummies转换后，列名的前缀
columns : list-like, default None：指定需要实现类别转换的列名
dummy_na : bool, default False：增加一列表示空缺值，如果False就忽略空缺值
drop_first : bool, default False：获得k中的k-1个类别值，去除第一个

原文：https://blog.csdn.net/u010665216/article/details/78635664

import pandas as pd
# 把Pclass进行独热编码，保存为新数据对象，prefix参数设置独热编码后的变量前缀Pclass_onehot=pd.get_dummies(titanic_df.Pclass,prefix='Pclass')
# 拼接，并删除原来数据
titanic_df = pd.concat([titanic_df, Pclass_onehot], axis=1)
titanic_df = cars.drop("Pclass", axis=1)
Pclass_onehot.head()

from sklearn import preprocessing
X=[[0,0,3],[1,1,0],[0,2,1],[0,0,3]]
onehot=preprocessing.OneHotEncoder()onehot.fit_transform(X).toarray()  # 将稀疏矩阵转化为普通矩阵array([[1., 0., 1., 0., 0., 0., 0., 1.],[0., 1., 0., 1., 0., 1., 0., 0.],[1., 0., 0., 0., 1., 0., 1., 0.],[1., 0., 1., 0., 0., 0., 0., 1.]])# 如果训练集有丢失的分类特征值，必须显示地设置n_values
encoder=preprocessing.OneHotEncoder(n_values=[2,4,4])
encoder.fit_transform(X).toarray()array([[1., 0., 1., 0., 0., 0., 0., 0., 0., 1.],[0., 1., 0., 1., 0., 0., 1., 0., 0., 0.],[1., 0., 0., 0., 1., 0., 0., 1., 0., 0.],[1., 0., 1., 0., 0., 0., 0., 0., 0., 1.]])

2.6、生成多项式的特征

在机器学习中，通过增加一些输入数据的非线性特征来增加模型的复杂程度，一个简单通用的办法就是使用多项式特征，这可以获得特征的更高次数和互相间关系的项。
增加复杂度，解决欠拟合问题（支持向量机中的核函数：低维到高维）

直接用 X1,X2X1,X2 线性不可分割，使用多项式 X21+X22−1=0X12+X22−1=0 ，就可以分割

import numpy as np
from sklearn.preprocessing import PolynomialFeatures
X=np.arange(6).reshape(3,2)# 生成平方项
ploy=PolynomialFeatures(2)
print(X)
print(ploy.fit_transform(X))[[0 1]
[2 3]
[4 5]][[ 1.  0.  1.  0.  0.  1.]
[ 1.  2.  3.  4.  6.  9.]
[ 1.  4.  5. 16. 20. 25.]]# X 的特征已经从(X1,X2) (X1,X2) 转换为(1,X1,X2,X21,X1X2,X22) (1,X1,X2,X12,X1X2,X22)
# 在一些情况，只需要特征间的交互项，就可以通过设置 interaction_only=True 来得到
# X 的特征已经从(X1,X2)转换为(1,X1,X2,X1X2,)
ploy2=PolynomialFeatures(2,interaction_only=True)
print(ploy2.fit_transform(X))

2.7、样本不均衡的方案

1、下采样：多的选择跟少的一样多

# 拆开表格，分为X、y,Class 为y（预测值）
X=data.ix[:,data.columns !='Class']
y=data.ix[:,data.columns == 'Class']# 下采样,找出 1 的数量和对应的索引值
number_records_fraud=len(data[data.Class==1])
fraud_indices=np.array(data[data.Class==1].index)# 0的索引值
normal_indices = data[data.Class == 0].index# 随机选择跟1一样多的数据，参数（数据，个数，是否代替）再转成array。
random_normal_indices = np.random.choice(normal_indices ,number_records_fraud,replace =False)
random_normal_indices = np.array(random_normal_indices)# 两个索引值合并到一起
under_sample_indices = np.concatenate([fraud_indices,random_normal_indices])
# 根据索引提取新的数据
under_sample_data = data.iloc[under_sample_indices,:]X_undersample = under_sample_data.ix[:,under_sample_data.columns !='Class']
y_undersample = under_sample_data.ix[:, under_sample_data.columns == 'Class']# 可视化
print("Percentage of normal transactions: ", len(under_sample_data[under_sample_data.Class == 0])/len(under_sample_data))print("Percentage of fraud transactions: ", len(under_sample_data[under_sample_data.Class == 1])/len(under_sample_data))
print("Total number of transactions in resampled data: ", len(under_sample_data))

2、过采样：让少的数据再生成一部分数据，跟多的一样多

数据洗牌（打乱）:shuffle

np.random.shuffle(data)# 洗牌，返回的是indexshuffled_index = np.random.permutation(admissions.index)
#print shuffled_index

训练数据、测试数据的切分

# from sklearn.cross_validation import train_test_split
from sklearn.model_selection import train_test_split
#整体数据切分
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size = 0.3, random_state = 0)print("Number transactions train dataset: ", len(X_train))
print("Number transactions test dataset: ", len(X_test))
print("Total number of transactions: ", len(X_train)+len(X_test))# 下采样数据的切分
X_train_undersample, X_test_undersample,
y_train_undersample, y_test_undersample =
train_test_split(X_undersample,y_undersample,test_size = 0.3,random_state = 0)print("")
print("Number transactions train dataset: ", len(X_train_undersample))
print("Number transactions test dataset: ", len(X_test_undersample))
print("Total number of transactions: ", len(X_train_undersample)+len(X_test_undersample))

设置不同权重项