机器学习算法最终学习结果的优劣取决于两个主要因素：数据的质量和数据中蕴含的有用信息的数量。
一、缺失数据的处理
<一>删除缺失值
1. # Title : TODO
2. # Objective : TODO
3.
5.
6.
7. import numpy as np
8. import pandas as pd
9. from io import StringIO
10.
11. data = '''''''A,B,C,D
12. 1,2,3,4
13. 5,6,,8
14. 0,11,12,'''
15.
16. df = pd.read_csv(StringIO(data))
17. print(df)
18.
19. df.isnull().sum() # 返回一个布尔型的DataFrame值
20.
21. df.dropna() # 将含有缺失值的行删除
22.
23. df.dropna(axis=1) # 将含有缺失值的列删除
24.
25. df.dropna(how="all") # 全部缺失时才删除
26.
27. df.dropna(thresh=4) # 删除包含缺失值但数目小于4的行
28.
29. df.dropna(subset=['C']) # 删除特定列元素为缺失值的行
<二>缺失值数据填充
1. from sklearn.preprocessing import Imputer
2. imr = Imputer(missing_values='NaN', strategy='mean', axis=0)
3. # 这里使用的是每列均值填充,axis=1的话用每行的均值填充
4. imr = imr.fit(df)
5. imputer_data = imr.transform(df.values)
6. print(imputer_data)
7.
8.
9. [[ 1. 2. 3. 4. ]
10. [ 5. 6. 7.5 8. ]
11. [ 0. 11. 12. 6. ]]
二、处理类别数据
首先构造一个数据集：
1. import pandas as pd
2. df = pd.DataFrame([
3. ['green','M',10.1,'class1'],
4. ['red','L',13.5,'class2'],
5. ['blue','XL',15.3,'class1']
6. ])
7. df.columns = ['color','size','price','classlabel']
8. print(df)
9.
10.
11. color size price classlabel
12. 0 green M 10.1 class1
13. 1 red L 13.5 class2
14. 2 blue XL 15.3 class1
<一> 有序特征的映射
1. size_mapping = {
2. 'XL':3,
3. 'L':2,
4. 'M':1
5. }
6. df['size'] = df['size'].map(size_mapping)
7. print(df)
8.
9.
10. color size price classlabel
11. 0 green 1 10.1 class1
12. 1 red 2 13.5 class2
13. 2 blue 3 15.3 class1
<二> 类标的编码
类标并不是有序的，而且对于特定的字符串类标，赋予其哪个整数值并不重要。
1. import numpy as np
2. class_mapping = {label:idx for idx,label in
3. enumerate(np.unique(df['classlabel']))}
4. print(class_mapping)
5.
6.
7. {'class1': 0, 'class2': 1}
8.
9.
10. df['classlabel'] = df['classlabel'].map(class_mapping)
11. print(df)
12.
13.
14. color size price classlabel
15. 0 green 1 10.1 0
16. 1 red 2 13.5 1
17. 2 blue 3 15.3 0
18.
19. #可以进行倒置
20. inv_class_mapping = {v:k for k,v in class_mapping.items()}
21. df['classlabel'] = df['classlabel'].map(inv_class_mapping)
22. print(df)
23.
24. color size price classlabel
25. 0 green 1 10.1 class1
26. 1 red 2 13.5 class2
27. 2 blue 3 15.3 class1
28.
29. #使用sklearn中的LabelEncoder类可以更加方便地完成对类标对整数编码工作
30. from sklearn.preprocessing import LabelEncoder
31. class_le = LabelEncoder()
32. y = class_le.fit_transform(df['classlabel'].values)
33. print(y)
34.
35. [0 1 0]
36.
37. #进行倒置
38. print(class_le.inverse_transform(y))
39.
40. ['class1' 'class2' 'class1']
<三> 标称特征的独热编码
1. X = df[['color','size','price']].values
2. color_le = LabelEncoder()
3. X[:,0] = color_le.fit_transform(X[:,0])
4. print(X)
5.
6. [[1 1 10.1]
7. [2 2 13.5]
8. [0 3 15.3]]
注意这里是有问题的，在对颜色的类标进行编码时生成了有序的特征。可以通过独热编码来解决。
1. from sklearn.preprocessing import OneHotEncoder
2. ohe = OneHotEncoder(categorical_features=[0])
3. print(ohe.fit_transform(X).toarray()) #这里返回的是稀疏矩阵，再用toarray处理以便于可视化
4.
5. [[ 0. 1. 0. 1. 10.1]
6. [ 0. 0. 1. 2. 13.5]
7. [ 1. 0. 0. 3. 15.3]]
也可以通过pandas里的get_dummies方法来更方便的实现独热编码技术。
1. print(pd.get_dummies(df[['color','size','price']]))
2.
3. size price color_blue color_green color_red
4. 0 1 10.1 0 1 0
5. 1 2 13.5 0 0 1
6. 2 3 15.3 1 0 0
四、将数据集划分为训练集和测试集
在实际应用中，基于原始数据的大小，常用的划分比例是60:40、70:30、80:20，对于非常庞大的数据集，按90:10和99:1来划分也是可以接受的。
1. df_wine = pd.read_csv("http://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data", header=None)
2. df_wine.columns = [
3. 'Class label','Alcohol',
4. 'Malic acid','Ash',
5. 'Alcalinity of ash','Magnesium',
6. 'Total phenols','Flavanoids',
7. 'Nonflavanoid phenols',
8. 'Proanthocyanins',
9. 'Color intensity','Hue',
10. 'OD280/OD315 of diluted wines',
11. 'Proline',
12. ]
13. print("Class label", df_wine['Class label'].unique())
14.
15. Class label [1 2 3]
16.
17. from sklearn.cross_validation import train_test_split
18. X,y = df_wine.iloc[:,1:].values, df_wine.iloc[:,0].values
19. X_train,X_test,y_train,y_test = train_test_split(X, y, test_size=0.2, random_state=0)
五、将特征值缩放到相同的空间
特征缩放是机器学习非常重要的一步，并且很容易被忽略。决策树和随机森林是为数不多的不需要进行特征缩放的算法。然而，对大多数机器学习和优化算法而言，将特征值缩放到相同的空间会显著提高其性能。
目前主要有两种方法：归一化和标准化。
<一> 归一化
1. from sklearn.preprocessing import MinMaxScaler
2. mms = MinMaxScaler()
3. X_train_transform = mms.fit_transform(X_train)
4. X_test_transform = mms.fit_transform(X_test)
<二> 标准化
1. from sklearn.preprocessing import StandardScaler
2. std = StandardScaler()
3. X_train_transform = std.fit_transform(X_train)
4. X_test_transform = std.fit_transform(X_test)
注意：我们只是使用StandardScaler()对训练数据进行了拟合，并使用相同的拟合参数来完成对测试集以及未知数据的转换。