数据预处理和特征工程

数据预处理：从数据中检测、纠正、删除损坏的不准确的或者不适用于模型记录的过程

           目的：让数据更加适应模型，匹配模型需求

特征工程：将原始数据转换为更能代表预测模型的潜在问题的特征工程。可以通过挑选最相关特征，提取特征以及创造特征来实现。其中创造特征又经常以将为的方式实现。

       问题：特征之间有相关性，特征和标签无关，特征太多或太少，或者干脆就无法表现出应有的数据现象或无法展示数据的真实面貌。

       目的：降低计算成本，提升模型上限

数据预处理 ：

数据无量钢化：将不同规格的数据转换为统一规格，或者是将不同分布的数据转换为某个特定分布的需求。

线性的无量纲化包括中心化处理（让所有的记录减去一个固定值）和缩放处理（除以一个固定值）

归一化（数据按最小值中心化，再按极差缩放，数据收敛到[0,1]之间）归一化后数据服从正态分布

           =       使用preprocessing.MinMaxScaler来实现这个功能。

from sklearn.preprocessing import MinMaxScaler
import pandas as pd

data = [[-1,2],[-0.5,6],[0,10],[1,18]]
pd.DataFrame(data)
scaler = MinMaxScaler()          # 实例化
scaler = scaler.fit(data)        # 本质是生成min(x)和max(x)
result = scaler.transform(data)  # 通过接口导出结果
print(result)

 

result_ = scaler.fit_transform(data)     # 相当于print上两行的内容
print(result_)

 

a = scaler.inverse_transform(result)         # 将归一化后的结果逆转
print(a)

 

# 使用MinMaxScaler的参数feature_range实现归一化到[0,1]以外的范围

 

 # 当x中特征向量非常多的时候，fit会报错并表示数据量太大了计算不了

# 这时使用partial_fit作为训练接口

# scaler = scaler.paratial_fit (data)

使用numpy实现归一化

import numpy as np
# 归一化
x = np.array([[-1,2],[-0.5,6],[0,10],[1,18]])
x_nor = (x - x.min(axis=0))/(x.max(axis=0)-x.min(axis=0))
# axis 是以列计算
print(x_nor)
# 逆转归一化
x_return = x_nor * (x.max(axis=0)-x.min(axis=0)) + x.min(axis=0)
print(x_return)

 

 标准化（数据按均值中心化后，再按标准差缩放）数据服从均值为0，方差为1。

              =        使用preprocessing.StandardScaler来实现这个功能。

from sklearn.preprocessing import StandardScaler

data = [[-1,2],[-0.5,6],[0,10],[1,18]]
scaler = StandardScaler()
a = scaler.fit_transform(data)   # fit本质是生成均值和方差
print(a)
b = scaler.inverse_transform(a)
print(b)

 

print(a.mean())     # 查看均值
print(a.std())      # 查看方差

MinMaxScaler 对异常值的敏感比较强，所以我们通常使用标准化 

处理缺失值

使用impute.SimpleImputer

参数 missing_values  告诉 SimpleImputer数据中缺失值长什么样，默认空值np.nan

        strategy 填补缺失值策略，默认是均值。

                 （数值型 mean 均值，median中值，

                    数值型和字符型  most_frequent众数，constant参考fill_value中的值） 

        fill_value 当参数strategy为constant时可用，可输入字符串或数字表示要填充的值。

        copy 默认为True 将创建特征矩阵的副本，反之则会将缺失值填补到原来的特征矩阵中。

import pandas as pd

data = pd.read_csv(r"F:\预处理数据\Narrativedata.csv",index_col=0)
# index_col=0 降第0列作为索引
data.head()

data.info()        # 探索数据

data.loc[:,"Age"]    # loc 使用索引的名字来进行切片

 

# 填补年龄

Age = data.loc[:,"Age"].values.reshape(-1,1)   # sklearn 中特征矩阵必须是二维 

Age[:10]

from sklearn.impute import SimpleImputer
imp_mean = SimpleImputer()        # 实例化，默认均值填补
imp_median = SimpleImputer(strategy="median")    # 用中位数填补
imp_0 = SimpleImputer(strategy="constant",fill_value=0)   # 用0填补

imp_mean = imp_mean.fit_transform(Age)
imp_median = imp_median.fit_transform(Age)
imp_0 = imp_0.fit_transform(Age)

imp_mean[:10]

imp_median[:10]

 

imp_0[:10]

 # 因为不想年龄出现小数，而且因为29.699和28比较接近，所以我们用中位数来填补

data.loc[:,"Age"] = imp_median
data.info()

 

# 使用众数填补Embarked 

Embarked = data.loc[:,"Embarked"].values.reshape(-1,1)
imp_mode = SimpleImputer(strategy = "most_frequent")
data.loc[:,"Embarked"] = imp_mode.fit_transform(Embarked)
data.info()

 使用numpy和pandas进行填补

import pandas as pd

data = pd.read_csv("F:\\预处理数据\\Narrativedata.csv")
data.loc[:,"Age"] = data.loc[:,"Age"].fillna(data.loc[:,"Age"].median())
# .fillna 在DataFrame里面直接进行填补
print(data.loc[:,"Age"])

 删掉缺失值的行

data.dropna(axis=0,inplace=True)

newdata = data.dropna(axis=0,inplace=False)

# .dropna(axis=0)删除所有确实值的行，axis=1删除所有缺失值的列
# inplace为True表示在原数据上进行修改，False表示生成一个复制对象，不修改原数据，默认为False

print(data.info())

 先把Age补充上在删除Embarked缺失的两行

 

所有的行都由891变成了889 

处理分类特征：编码与哑变量

处理文字进行编码，把文字转换成数字

标签专用preprocessing.LabelEncoder

from sklearn.preprocessing import LabelEncoder
y = data.iloc[:,-1]   
# 要输入的是标签，不是特征矩阵，所以可以一维
# 所有的行最后一列
le = LabelEncoder()
le = le.fit(y)
label = le.transform(y)

le.classes_     # 查看标签中有多少类别

label[0:20]

 

le.inverse_transform(label)[0:20]

data.iloc[:,-1] = label

data.head()

简单写法

from sklearn.preprocessing import LabelEncoder
data.iloc[:,-1] = LabelEncoder().fit_transform(data.iloc[:,-1])

特征专用 preprocessing.OrdinalEncoder ：将分类特征转换为分类数值

from sklearn.preprocessing import OrdinalEncoder
newdata = data.copy()      # 保留原始data
OrdinalEncoder().fit(newdata.iloc[:,1:-1]).categories_
# iloc[行，列] 取中间两列所有的行
# categories_ 查看有多少类别

 

newdata.iloc[:,1:-1] = OrdinalEncoder().fit_transform(newdata.iloc[:,1:-1])
newdata.head()

 

独热编码，创建哑变量 preprocessing.OneHotEncoder

特征中只能有一种，存在一种有你就没我的不等概念

”S“   [ 0,                                ”S"   [[1,0,0],

”Q“    1,        转换成              "Q"   [0,1,0],

”R“    2]                                 "C"   [0,0,1]]

from sklearn.preprocessing import OneHotEncoder
x = data.iloc[:,1:-1]
enc = OneHotEncoder(categories='auto').fit(x)
result = enc.transform(x).toarray()
# toarray 转化为一个数组
result
# 因为性别有两个类别，舱门有三个类别，所以输出有五个类别

# 还原
pd.DataFrame(enc.inverse_transform(result))

enc.get_feature_names()
# 返回每一个列的名字

# 把新的哑变量与原数据接起来
newdata = pd.concat([data,pd.DataFrame(result)],axis=1)
# axis=1 表示跨行进行合并，把表左右进行相连，axis=0，表上下相连
newdata.head()

 

# 把原先两列删掉
newdata.drop(["Sex","Embarked"],axis=1,inplace=True)
newdata.head()

 

# 改变列索引的名字
newdata.columns = ["Age","Survived",'female', 'male', 'C', 'Q', 'S']
newdata.head()

 

 处理连续性特征：二值化与分段

sklearn.preprocessing.Binarizer

二值化将特征值设为0或1，大于阈值为1，小于阈值为0

data1 = data.copy()
from sklearn.preprocessing import Binarizer    
x = data1.iloc[:,0].values.reshape(-1,1)
# 处理特征的必须是二维
transformer = Binarizer(threshold=30).fit_transform(x)
# threshold 阈值
data1.iloc[:,0] = transformer
data1.head()

 

 preprocessing.KBinsDiscretizer

将连续型变量划分为分类变量的类。将连续型变量排序后按顺序分箱后编码。

参数 n_bins 每个特征中分箱的个数，默认为5

        encode 默认onehot 做哑变量

                     ordinal 每个特征每个箱都被编码为一个整数，返回每一列是一个特征

        strategy用来定义箱宽

                    默认为quantile 等位分箱 每个特征中的每个箱内的样本数量相同

                    uniform 等宽分箱，每个特征中的每个箱最大值之间的差为

                                                        （特征.max()-特征.min())/(n_bins)

                    kmeans 聚类分箱每个箱中的值到最近的一维k均值聚类的簇心得到距离都相同

from sklearn.preprocessing import KBinsDiscretizer
x = data.iloc[:,0].values.reshape(-1,1)
est = KBinsDiscretizer(n_bins=3,encode='ordinal',strategy='uniform')
est.fit_transform(x)

 

set(est.fit_transform(x).ravel())
# ravel 降维  set 去掉重复

 

est = KBinsDiscretizer(n_bins=3,encode='onehot',strategy='uniform')
est.fit_transform(x).toarray()