sklearn中的数据预处理

**

sklearn中preprocessing数据预处理

**

1.数据无量纲化
1.1归一化：

#归一化，将数据压缩，默认是[0,1]
from sklearn.preprocessing import MinMaxScaler
import pandas as pd
import numpy as np

data = [[-1,2],[-0.5,6],[0,10],[1,18]]
print(type(data)) #list

data1 = pd.DataFrame(data)
print(data1)
print(type(data1)) #pandas.core.frame.DataFrame

data2 = np.array(data)
print(data2)
print(type(data2)) #numpy.ndarray

#实现归一化
scaler = MinMaxScaler() #实例化
scaler = scaler.fit(data) #fit,在这里本质是生成min()和max()
result = scaler.transform(data) #通过接口导出结果
print(result)

#或者一步到位
result_ = scaler.fit_transform(data) #训练和导出结果一步达成
print(result_)

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

#使用MinMaxScaler的参数feature_range实现将数据归一化到[0,1]以外的范围中
data = [[-1,2],[-0.5,6],[0,10],[1,18]]
scaler_ = MinMaxScaler(feature_range=[5,10])
result1 = scaler_.fit_transform(data)
print(result1)

#当X中的特征数量非常多的时候，fit会报错并表示，数据量太大了我计算不了
#此时使用partial_fit作为训练接口
#scaler = scaler.partial_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))
X_nor
#逆转归一化
X_returned = X_nor * (X.max(axis=0) - X.min(axis=0)) + X.min(axis=0)
X_returned

1.2标准化

#标准化 使得数据服从均值为0，方差为1的正态分布
from sklearn.preprocessing import StandardScaler

data = [[-1,2],[-0.5,6],[0,10],[1,18]]
scaler = StandardScaler() #实例化
scaler.fit(data) #fit，本质是生成均值和方差

print(scaler.mean_)  #查看原始数据均值的属性mean_
print(scaler.var_)   #查看原始数据方差的属性var_

x_std = scaler.transform(data) #通过接口导出结果
print(x_std)     #导出的结果是一个数组
print(type(x_std)) #numpy.ndarray
print(x_std.mean(),x_std.std()) #均值为0 方差为1

#或者使用fit_transform(data)一步达成
scaler1 = scaler.fit_transform(data)

#使用inverse_transform逆转标准化
data_ = scaler.inverse_transform(x_std)

2.缺失值处理

#preprocessing.SimpleImputer:对缺失数据处理
import pandas as pd
from sklearn.impute import SimpleImputer

data = pd.read_csv(r'data.csv', index_col = 0) #数据第一列为索引，如果不加index_col=0，则会在原数据前再加一列索引
#data中第0列表示第一个特征列
#print(data)
print(data.head()) #将第一行作为索引，为填入数字时默认输出前五行
print(data.info()) #查看数据基本情况
'''
<class 'pandas.core.frame.DataFrame'>
Int64Index: 891 entries, 1 to 891
Data columns (total 4 columns):
Sex         891 non-null object
Age         714 non-null float64
Embarked    889 non-null object
Survived    891 non-null int64
dtypes: float64(1), int64(1), object(2)
memory usage: 34.8+ KB
None
'''
#取出年龄
Age = data.loc[:,'Age'].values.reshape(-1,1) 
#data.loc[:,'Age']包含一列索引、一列值;'.values'取出值;'.reshape(-1,1)'转换维度，sklearn中特征矩阵必须是二维的
print(Age[:20]) #输出前20行

#用三种不同策略填补缺失值
imp_mean = SimpleImputer() #实例化。默认均值填补
imp_median = SimpleImputer(strategy='median') #用中位数填补
imp_0 = SimpleImputer(strategy='constant', fill_value=0) #用常量0填充

imp_mean = imp_mean.fit_transform(Age) #fit_transform一步完成调试结果
imp_median = imp_median.fit_transform(Age)
imp_0 = imp_0.fit_transform(Age)

print(imp_mean[:20])
print(imp_median[:20])
print(imp_0[:20])

#在这里我们使用中位数填补Age
data.loc[:,'Age'] = imp_median
print(data.info())
'''
<class 'pandas.core.frame.DataFrame'>
Int64Index: 891 entries, 1 to 891
Data columns (total 4 columns):
Sex         891 non-null object
Age         891 non-null float64
Embarked    889 non-null object
Survived    891 non-null int64
dtypes: float64(1), int64(1), object(2)
memory usage: 34.8+ KB
None
'''

#使用众数填补Embarked
Embarked = data.loc[:,'Embarked'].values.reshape(-1,1)
imp_mode = SimpleImputer(strategy = 'most_frequent')
data.loc[:,'Embarked'] = imp_mode.fit_transform(Embarked)
print(data.info())

用Pandas和Numpy进行填补其实更加简单

import pandas as pd
data = pd.read_csv(r"C:\work\learnbetter\micro-class\week 3 
Preprocessing\Narrativedata.csv",index_col=0)
data.head()
data.loc[:,"Age"] = data.loc[:,"Age"].fillna(data.loc[:,"Age"].median())
#.fillna 在DataFrame里面直接进行填补
data.dropna(axis=0,inplace=True)
#.dropna(axis=0)删除所有有缺失值的行，.dropna(axis=1)删除所有有缺失值的列
#参数inplace，为True表示在原数据集上进行修改，为False表示生成一个复制对象，不修改原数据，默认False

3.处理分类型特征：编码与哑变量
3.1分类标签转换为分类数值

#preprocessing.LabelEncoder 标签专用，能够将分类标签转换为分类数值
#也同样可以采用preprocessing.LabelBinarizer对标签做哑变量处理，但是只能做0和1
import pandas as pd
from sklearn.preprocessing import LabelEncoder

data = pd.read_csv(r'data.csv', index_col=0)
y = data.iloc[:,-1] #要输入的是标签，不是特征矩阵，所以允许是一维

LabelEncoder = LabelEncoder() #实例化
le = LabelEncoder.fit(y) #导入数据
label = le.transform(y) #transform接口调取结果
print(le.classes_) #属性.classes_ 查看标签中究竟有多少个类别
print(label) #查看获取的结果label

#也可以直接fit_transform一步到位
#le = le.fit_transform(y)

#使用inverse_transform可以逆转
label_inverse = le.inverse_transform(label)
print(label_inverse)

data.iloc[:,-1] = label #让标签等于我们运行出来的结果
print(data.head())

#还有一种最简洁的写法!!!!!!!!!!
data.iloc[:,-1] = LabelEncoder().fit_transform(data.iloc[:,-1])                                                       

3.2将分类特征转换为分类数据

#preprocessing.OrdinalEncoder:特征专用，能够将分类特征转换为分类数据
from sklearn.preprocessing import OrdinalEncoder
import pandas as pd
from sklearn.impute import SimpleImputer

data = pd.read_csv(r'data.csv', index_col = 0)
#先将缺失值填补
Age = data.loc[:,'Age'].values.reshape(-1,1)
imp_mode = SimpleImputer(strategy = 'median')
data.loc[:,'Age'] = imp_mode.fit_transform(Age)

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


print(OrdinalEncoder().fit(data.iloc[:,0:-1]).categories_) #输出当前特征数据的类别

data.loc[:,'Sex'] = OrdinalEncoder().fit_transform(data.loc[:,'Sex'].values.reshape(-1,1))#loc[]需要改变维度，iloc[]好像并不需要
data.loc[:,'Embarked'] = OrdinalEncoder().fit_transform(data.loc[:,'Embarked'].values.reshape(-1,1))
print(data.head(20))

3.3独热编码&&哑变量

'''
独热编码&&哑变量：
在一些数据中，如体重(>45kg,>90kg,>135kg)，各个取值之间有联系,且是可以计算的，比如135kg-45kg=90kg;
而在另一类数据中，如舱门(S,C,Q)，如果直接转化为[0,1,2],这三个数字在算法看来，是连续可以计算的，有着
相加相乘的联系，所以给算法传递了一些不准确的信息，这会影响建模。

解决方法：
   将(S,C,Q)由[0,1,2] 转变为 [[1,0,0],[0,1,0],[0,0,1]]
这样三个取值没有计算性质，是‘有你就没我’的不等概念，这就是独热编码，将特征转换为哑变量。
'''
import pandas as pd
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder

data = pd.read_csv(r'data.csv', index_col = 0)

#先对缺失值进行填补
Age = data.loc[:,'Age'].values.reshape(-1,1)
imp_mode = SimpleImputer(strategy = 'median')
data.loc[:,'Age'] = imp_mode.fit_transform(Age)

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

sex = data.iloc[:,0] #需要编码的两列隔开了，如果在一起就可以直接一起编码
enc = OneHotEncoder(categories='auto').fit(sex) #categories='auto'让计算机自己识别，在后续版本中默认是'auto'
result1 = enc.transform(sex).toarray()

print(result1)
print(enc.get_feature_names())#在编码成一串0和1之后，可以调用这个接口查看分别表示什么 

embarked = data.iloc[:,2]
enc = OneHotEncoder(categories='auto').fit(embarked) 
result2 = enc.transform(embarked).toarray()

print(result2)
print(enc.get_feature_names())


#将转换后的哑变量合并到原数据之中
#axis=1,表示跨行进行合并，也就是将两表左右相连，如果axis=1，就是将两表上下相连
newdata = pd.concat([data,pd.DataFrame(result1)],axis=1)
newdata = pd.concat([newdata,pd.DataFrame(result2)],axis=1)
print(newdata.head())

#删除原数据
newdata.drop(['Sex','Embarked'], axis=1, inplace=True) #axis=1跨行删除，即删除列；inplace=True 将原数据覆盖
print(newdata.head())

#对数据的列进行重新命名
#命名根据enc.get_feature_names()返回的值进行命名
newdata.columns = ['Age','Survived','female','male','Embarked_C','Embarked_Q','Embarked_S']

print(newdata.head())

4 处理连续型特征：二值化与分段
4.1二值化与分段

#处理连续型特征：二值化与分段
#sklearn.preprocessing.Binarizer
#根据阈值将数据二值化，用于处理连续性变量。大于阈值的映射为1，小于阈值的映射为0；
import pandas as pd
from sklearn.preprocessing import Binarizer
from sklearn.impute import SimpleImputer

data = pd.read_csv(r'data.csv', index_col=0)

#先将缺失值填补
Age = data.loc[:,'Age'].values.reshape(-1,1)
imp_mode = SimpleImputer(strategy = 'median')
data.loc[:,'Age'] = imp_mode.fit_transform(Age)

#将年龄二值化
X = data.iloc[:,1].values.reshape(-1,1)

transformer = Binarizer(threshold=30).fit_transform(X)
print(transformer)

#再将数据导入原始数据
data.iloc[:,1] = transformer
print(data.head())

4.2分箱

#preprocessing.KBinsDiscretizer 分箱处理
'''
这是将连续型变量划分为分类变量的类，能够将连续型变量排序后按顺序分箱后编码。总共包含三个重要参数：
1.n_bins:每个特征中分箱的个数，默认5，一次会被运用到所有导入的特征;
2.encode:编码的方式，默认“onehot”
    "onehot"：做哑变量，之后返回一个稀疏矩阵，每一列是一个特征中的一个类别，含有该类别
的样本表示为1，不含的表示为0;
    “ordinal”：每个特征的每个箱都被编码为一个整数，返回每一列是一个特征，每个特征下含
有不同整数编码的箱的矩阵;
    "onehot-dense"：做哑变量，之后返回一个密集数组;
3.strategy:用来定义箱宽的方式，默认"quantile"
    "uniform"：表示等宽分箱，即每个特征中的每个箱的最大值之间的差为(特征.max() - 特征.min())/(n_bins);
    "quantile"：表示等位分箱，即每个特征中的每个箱内的样本数量都相同;
    "kmeans"：表示按聚类分箱，每个箱中的值到最近的一维k均值聚类的簇心得距离都相同;
    
'''
import pandas as pd
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import KBinsDiscretizer

data = pd.read_csv(r'data.csv', index_col=0)

#先将缺失值填补
Age = data.loc[:,'Age'].values.reshape(-1,1)
imp_mode = SimpleImputer(strategy = 'median')
data.loc[:,'Age'] = imp_mode.fit_transform(Age)

#分箱
X = data.iloc[:,1].values.reshape(-1,1) 

est = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='uniform')
transformer1 = est.fit_transform(X)
print(transformer1[:20]) #输出前20个

#查看转换后分的箱：变成了一列中的三箱
num = set(est.fit_transform(X).ravel())
print(num)

est = KBinsDiscretizer(n_bins=3, encode='onehot', strategy='uniform')
#查看转换后分的箱：变成了哑变量
transformer2 = est.fit_transform(X).toarray() #注意！！！！！此处要加.toarray()
print(transformer2[:20])