#### 1.2最值归一化实现

```import numpy as np
# 创建100个随机数
x = np.random.randint(0,100,size=100)
# 最值归一化（向量）
# 最值归一化公式，映射到0，1之间
(x - np.min(x)) / (np.max(x) -  np.min(x))
# 最值归一化（矩阵）
# 0～100范围内的50*2的矩阵
X = np.random.randint(0,100,(50,2))
# 将矩阵改为浮点型
X = np.array(X, dtype=float)
# 最值归一化公式，对于每一个维度（列方向）进行归一化。
# X[:,0]第一列，第一个特征
X[:,0] = (X[:,0] - np.min(X[:,0])) / (np.max(X[:,0]) - np.min(X[:,0]))
# X[:,1]第二列，第二个特征
X[:,1] = (X[:,1] - np.min(X[:,1])) / (np.max(X[:,1]) - np.min(X[:,1]))
# 如果有n个特征，可以写个循环：
for i in range(0,2):
X[:,i] = (X[:,i]-np.min(X[:,i])) / (np.max(X[:,i] - np.min(X[:,i])))```

```import matplotlib.pyplot as plt
# 简单绘制样本，看横纵坐标
plt.scatter(X[:,0],X[:,1])
plt.show()```

#### 1.3 均值方差归一化实现

```X2 = np.array(np.random.randint(0,100,(50,2)),dtype=float)
# 套用公式，对每一列做均值方差归一化
for i in range(0,2):
X2[:,i]=(X2[:,i]-np.mean(X2[:,i])) / np.std(X2[:,i])```

```import matplotlib.pyplot as plt
plt.scatter(X2[:,0],X2[:,1])
plt.show()```

```np.mean(X2[:,0])
np.std(X2[:,1])```

```-3.3306690738754695e-17
1.0```

#### 1.4 Sklearn中的归一化

```import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
X = iris.data
y = iris.target
X_train,X_test,y_train,y_test = train_test_split(iris.data,iris.target,test_size=0.2,random_state=666)```

```from sklearn.preprocessing import StandardScaler
standardScaler = StandardScaler()
# 归一化的过程跟训练模型一样
standardScaler.fit(X_train)
standardScaler.mean_
standardScaler.scale_   # 表述数据分布范围的变量，替代std_
# 使用transform
X_train_standard = standardScaler.transform(X_train)
X_test_standard = standardScaler.transform(X_test)```

#### 1.5 自己实现均值方差归一化

```import numpy as np
class StandardScaler:
def __init__(self):
self.mean_ = None
self.scale_ = None
def fit(self, X):
"""根据训练数据集X获得数据的均值和方差"""
assert X.ndim == 2, "The dimension of X must be 2"
# 求出每个列的均值
self.mean_ = np.array([np.mean(X[:,i] for i in range(X.shape[1]))])
self.scale_ = np.array([np.std(X[:, i] for i in range(X.shape[1]))])
return self
def tranform(self, X):
"""将X根据StandardScaler进行均值方差归一化处理"""
assert X.ndim == 2, "The dimension of X must be 2"
assert self.mean_ is not None and self.scale_ is not None, \
"must fit before transform"
assert X.shape[1] == len(self.mean_), \
"the feature number of X must be equal to mean_ and std_"
# 创建一个空的浮点型矩阵，大小和X相同
resX = np.empty(shape=X.shape, dtype=float)
# 对于每一列（维度）都计算
for col in range(X.shape[1]):
resX[:,col] = (X[:,col] - self.mean_[col]) / self.scale_[col]
return resX```

#### 1.6 kNN优缺点

KNN的主要优点有：

```维数	点到点	距离
1维	0到1的距离	1
2维	(0,0)到(1,1)的距离	1.414
3维	(0,0,0)到(1,1,1)的距离	1.73
64维	(0,0,...0)到(1,1,...1)	8
10000维	(0,0,...0)到(1,1,...1)	100```

### 二.缺失值处理

1.人工填写（filling manually）

2.特殊值填充（Treating Missing Attribute values as Special values）

3.平均值填充（Mean/Mode Completer）

4.热卡填充（Hot deck imputation，或就近补齐）

5.最近距离邻法（K-means clustering）

6.使用所有可能的值填充（Assigning All Possible values of the Attribute）

7.回归（Regression）

8.期望值最大化方法（Expectation maximization，EM）

EM算法是一种在不完全数据情况下计算极大似然估计或者后验分布的迭代算法。在每一迭代循环过程中交替执行两个步骤：E步（Excepctaion step,期望步），在给定完全数据和前一次迭代所得到的参数估计的情况下计算完全数据对应的对数似然函数的条件期望；M步（Maximzation step，极大化步），用极大化对数似然函数以确定参数的值，并用于下步的迭代。算法在E步和M步之间不断迭代直至收敛，即两次迭代之间的参数变化小于一个预先给定的阈值时结束。该方法可能会陷入局部极值，收敛速度也不是很快，并且计算很复杂。

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

R语言哑变量处理：

data(iris)

library(“dummy”) dumy <- dummy(x=iris) dummy函数会自动检查你输入数据集对象中的字符型/因子型变量，并全量输出字符型/因子型变量的哑变量编码结果。注意这里编码结果是全量输出，即类别型特征的每一个类别都有一个编码后的特征。为了编码引起多重共线性，我们需要舍弃一个（代表比较基准类的特征），这里Species类别变量一共有三个类别：setosa、versicolor 、virginica，各自都有一个对应编码变量，当原始类别变量取对应类别时，则对应类别哑变量位置取值为1，否则为0.

iris_data <- cbind(iris,dumy[,-1])

dumy <- model.matrix( ~ Species -1, data = iris) iris_data <- cbind(iris,dumy[,-1])

library(“caret”) dumy <- dummyVars(~gender,data=customers) trfs <- predict(dumy,newdata=customers)

iris_data <- iris %>% dummyVars(~Species,.) %>% predict(iris) %>% .[,-1] %>% cbind(iris,.) 选择规则同上。

Python中的哑变量处理工具：

from sklearn.preprocessing import Imputer,LabelEncoder,OneHotEncoder from sklearn import preprocessing from sklearn.model_selection import train_test_split from sklearn.datasets import load_iris import pandas as pd import numpy as np 方案一——：sk-learn中的OneHotEncoder方法：

iris = load_iris() data = iris[‘data’] iris_data = pd.DataFrame( data = data, columns = [‘sepal_length’,’sepal_width’,’petal_length’,’petal_width’] ) iris_data[“Species”] = iris[ ‘target’] iris_data[“Species”] = iris_data[“Species”].map({0:”setosa”,1:”versicolor”,2:”virginica”})

labelencoder_X = LabelEncoder() iris_data[“Species_code”] = labelencoder_X.fit_transform(iris_data.iloc[:,4])

onehotencoder = OneHotEncoder(categorical_features = [0]) X = onehotencoder.fit_transform(iris_data[[“Species_code”]]).toarray()

iris_data = pd.DataFrame( data = np.hstack((iris_data.values,X[:,0:2])), columns = iris_data.columns.tolist() + [‘Species_versicolor’,’Species_virginica’] )

dummy = pd.get_dummies(iris_data.iloc[:,4],prefix = “Species”) iris_data = pd.concat([iris_data,dummy.iloc[:,0:2]], axis= 1)

pandas中的get_dummies方法提供了非常简单高效的哑变量处理方案，只有短短的一句代码即可。

R语言：

#### 四 处理连续型特征：二值化与分段

6.1 二值化：preprocession.Binarizer(Threshold)

#导二值化包（特征专用） from sklearn.preprocessing import Binarizer ##提取年龄，要.reshape(-1,1)变为一列 data_2 = data.copy() data_2.iloc[:,0] X = data_2.iloc[:,0].values.reshape(-1,1) X[:,5] #将年龄二值化 transformer = Binarizer(threshold=30).fit_transform(X) #threshold = 30是阈值，大于30为1，小于30为0 transformer[:5] 6.2 分段：preprocessing.KBinsDiscretizer

n_bins ：每个特征中分箱的个数，默认5，一次会被运用到所有导入的特征 encode：编码的方式，默认“onehot”，”encode=ordinal”：每个特征的每个箱都被编码为一个整数，返回每一列是一个特征，每个特征下含有不同整数编码的箱的矩阵”encode=onehot-dense”：做哑变量，之后返回一个密集数组 strategy：用来定义箱宽的方式，默认”quantile”，”uniform”：表示等宽分箱；”quantile”：表示等位分箱，即每个特征中的每个箱内的样本数量都相同；”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)[:5]

set(est.fit_transform(X).ravel()) #检验是否分为三箱 set(est.fit_transform(X).flatten()) #ravel与flatten作用相同，均为降维（降至一维）

#分箱（独热编码） （每个类别数量不一定相等） est = KBinsDiscretizer(n_bins=3, encode=’onehot’, strategy=’uniform’) #查看转换后分的箱：变成了哑变量 est.fit_transform(X).toarray()

#分箱（独热编码）（每个类别数量基本相等） est = KBinsDiscretizer(n_bins=3, encode=’onehot’, strategy=’quantile’) #查看转换后分的箱：变成了哑变量,且每个类别数量基本相等 est.fit_transform(X).toarray()

est.fit_transform(X).toarray().sum(0) #查看每个类别是否数量一样 data[‘Age’].value_counts() #查看年龄分布