数据预处理（二）

前言：主要是Preprocessing && impute这个模块的内容

一、数据无量纲化

无量纲化主要包括中心化（Zero-centere）处理和缩放处理（Scale）
优先使用标准化，效果不好再用归一化

（1）数据归一化（Min-Max Scaling）

1、用sklearn中，preprocessing.MinMaxScaler实现

# -*- coding:utf-8 -*-
import numpy as np
import pandas as pd
df = pd.read_csv(r"movies_metadata.csv", engine='python')
revenue = df.loc[:,"revenue"]   #用于实现归一化的数据
runtime = df.loc[:,"runtime"]   #用于实现归一化的数据
df1 = pd.concat([revenue,runtime],axis=1)   #将两个dataframe进行左右(axis=1)连接

### 实现归一化
from sklearn.preprocessing import MinMaxScaler
revenue = np.array(df1)
#revenue = revenue.reshape(-1,1)    如果revenue的数组只有一列，要进行增维，至少要二维才能进行后续操作
scaler = MinMaxScaler()
# scaler = MinMaxScaler(feature_range=[5,10])   #依然实例化,参数feature_range实现将数据归一化到[5,10]的范围中
scaler = scaler.fit(revenue)
result = scaler.transform(revenue)  #result为归一化后的数组

# result_ = scaler.fit_transform(revenue)   #训练和导出结果一步达成
# scaler.inverse_transform(result)    #将归一化后的结果逆转

re = pd.DataFrame(result)   #将result数组转化为dataframe方便查看
re.columns=['revenue','runtime']  #修改列名
# re.rename(columns={'0':'revenue','1':'runtime'},inplace=True)  #修改列名，不知道这个为什么没用用
print(re)
df.drop(['revenue','runtime'], axis=1, inplace=True)    #删除原数据列名为revenue和runtime的列
newDataframe = pd.concat([re,df],axis=1)    #将处理后的数据与原数据左右连接

2、使用numpy来实现归一化

import numpy as np
#归一化
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

（2）数据标准化（StandardScaler）

import numpy as np
import pandas as pd
df = pd.read_csv(r"movies_metadata.csv", engine='python')
revenue = df.loc[:,"revenue"]   #用于实现归一化的数据
runtime = df.loc[:,"runtime"]   #用于实现归一化的数据
df1 = pd.concat([revenue,runtime],axis=1)   #将两个dataframe进行左右(axis=1)连接

from sklearn.preprocessing import StandardScaler
data = np.array(df1)
scaler = StandardScaler()   #实例化
scaler.fit(data)    #fit，本质是生成均值和方差
scaler.mean_    #查看均值的属性mean_
scaler.var_     #查看方差的属性var_
x_std = scaler.transform(data)  #通过接口导出结果
x_std.mean()     #导出的结果是一个数组，用mean()查看均值
x_std.std()     #用std()查看方差
scaler.fit_transform(data)  #使用fit_transform(data)一步达成结果
scaler.inverse_transform(x_std)  #使用inverse_transform逆转标准化

二、缺失值处理

（1）使用sklearn中impute模块填补

# -*- coding:utf-8 -*-
import pandas as pd
df = pd.read_csv(r"movies_metadata.csv", engine='python')   #45462行
runtime = df.loc[:,"runtime"].values.reshape(-1,1)   #45199行，注意：dataframe.values就变成ndarry数组了

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(runtime) #fit_transform一步完成调取结果
imp_median = imp_median.fit_transform(runtime)
imp_0 = imp_0.fit_transform(runtime)

print(len(imp_mean))
print(imp_mean[:20])    #输出前20行数据
#在这里我们使用中位数填补Age
df.loc[:,"runtime"] = imp_median	#将填补后的数组赋给原数据

（2）用Pandas和Numpy进行填补

data.loc[:,"runtime"] = data.loc[:,"runtime"].fillna(data.loc[:,"runtime"].median())
#.fillna 在DataFrame里用中位数
data.loc[:,"runtime"] = data.loc[:,"runtime"].fillna(0)	#用0填补
data.loc[:,"runtime"] = data.loc[:,"runtime"].fillna(data.loc[:,"runtime"].mean())	#用均值填补

（3）缺失值很少时，直接删除该行数据

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

三、处理分类型特征

（1）编码：将文字型数据转换为数值型

1.preprocessing.LabelEncoder:标签专用，能够将分类转换为分类数值

# -*- coding:utf-8 -*-
import pandas as pd
from sklearn.preprocessing import LabelEncoder  #引入处理分类标签的类
df = pd.read_csv(r"movies_metadata.csv", engine='python')
video = df.loc[:,"video"]   #要输入的是标签，不是特征矩阵，所以允许一维
le = LabelEncoder() #实例化
le = le.fit(video)  #导入数据
label = le.transform(video) #transform接口调取结果

print(le.classes_ )    #属性.classes_查看标签中究竟有多少类别
print(label)   #查看获取的结果label
# le.fit_transform(y) #也可以直接fit_transform一步到位
# le.inverse_transform(label) #使用inverse_transform可以逆转

df.loc[:,"video"] = label   #让标签等于我们运行出来的结果

#=========================以上代码可以简写为=====================
from sklearn.preprocessing import LabelEncoder
df.loc[:,"video"] = LabelEncoder().fit_transform(df.loc[:,"video"])

2、preprocessing.OrdinalEncoder:特征专用，能够将分类特征转换为分类数值

from sklearn.preprocessing import OrdinalEncoder
#接口categories_对应LabelEncoder的接口classes_，一模一样的功能
data_ = data.copy()
OrdinalEncoder().fit(data_.iloc[:,1:-1]).categories_	#查看特征中究竟有多少类别
data_.iloc[:,1:-1] = OrdinalEncoder().fit_transform(data_.iloc[:,1:-1])

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

在独热编码前要没有缺失值，不然会报错

# -*- coding:utf-8 -*-
import pandas as pd
from sklearn.preprocessing import OneHotEncoder  #引入处理分类标签的类
df = pd.read_csv(r"movies_metadata.csv", engine='python')
df.drop(['belongs_to_collection','homepage',"tagline"], axis=1, inplace=True)   #删除某些列
df.dropna(axis=0,inplace = True)    #删除缺失值行
original_language = df.loc[:,"original_language"].values.reshape(-1,1)  #为所选特征增维
ohe = OneHotEncoder(categories='auto').fit(original_language)   #实例化独热编码，并适用模型
result = ohe.transform(original_language).toarray() #返回独热编码后的结果并转换为数组
print(ohe.get_feature_names())  #查看类别的种类
res = pd.DataFrame(result)  #将独热编码后的数组转换为dataframe
res.columns = ohe.get_feature_names().tolist()  #设置转换后的列名为类别的种类
print(res.head())

# result= OneHotEncoder(categories='auto').fit_transform(original_language).toarray() #一步到位
# pd.DataFrame(ohe.inverse_transform(result)) #将数据还原

四、处理连续型特征

（1）二值化

根据阈值将数据二值化（将特征值设置为0或1），用于处理连续型变量。大于阈值的值映射为1，小于或等于阈值的值映射为0。

from sklearn.preprocessing import Binarizer
X = data_2.iloc[:,0].values.reshape(-1,1) #类为特征专用，所以不能使用一维数组	
transformer = Binarizer(threshold=30).fit_transform(X)

（2）分类

总共包含三个重要参数

from sklearn.preprocessing import KBinsDiscretizer
X = data.iloc[:,0].values.reshape(-1,1) 
est = KBinsDiscretizer(n_bins=3	#每个特征中分箱的个数，默认5,
						, encode='ordinal'	#编码方式，默认“onehot”：做哑变量，之后返回一个稀疏矩阵，每一列是一个特征中的一个类别，含有该类别的样本表示为1，不含有的表示为0；
						#“ordinal”：每个特征的每个箱都被编码为一个整数，返回每一列是一个特征，每个特征下含有不同整数编码的箱的矩阵；
						#“onehot-dense”：做哑变量，之后返回一个密集数组
						, strategy='uniform'	#用来定义箱宽的方式，默认“quantile”。“uniform”：表示等宽分箱，即每个特征中的每个箱的最大值之间的差为(特征.max() - 特征.min())/(n_bins)
						#"quantile"：表示等位分箱，即每个特征中的每个箱内的样本数量都相同
						#"kmeans"：表示按聚类分箱，每个箱中的值到最近的一维k均值聚类的簇心得距离都相同
						)
est.fit_transform(X) 
set(est.fit_transform(X).ravel())	#查看转换后分的箱：变成了一列中的三箱
est = KBinsDiscretizer(n_bins=3, encode='onehot', strategy='uniform') 
est.fit_transform(X).toarray()	#查看转换后分的箱：变成了哑变量

五、当样本分布不均，或者样本数差距很大时

此处采用上采样方法来平衡样本来解决此问题

#如果报错，就在prompt安装：pip install imblearn
import imblearn
#imblearn是专门用来处理不平衡数据集的库，在处理样本不均衡问题中性能高过sklearn很多
#imblearn里面也是一个个的类，也需要进行实例化，fit拟合，和sklearn用法相似
from imblearn.over_sampling import SMOTE
sm = SMOTE(random_state=42) #实例化
X,y = sm.fit_sample(X,y)	#上采样后的样本
n_sample_ = X.shape[0]	#查看样本数
pd.Series(y).value_counts()	#查看各类标签总数
n_1_sample = pd.Series(y).value_counts()[1]	#查看标签为1的样本数
n_0_sample = pd.Series(y).value_counts()[0]	#查看标签为2的样本数