Python极简读书笔记（十）sklearn与经典机器学习算法

机器学习七个流程

sklearn功能主要分为：分类、回归、聚类、数据降维、模型选择和数据预处理。

• 经典分类算法：支持向量机SVM、最近邻算法、Logistic回归、随机森林、决策树、多层感知器Multilayer Perceptron MLP
• 回归regression：线性回归、支持向量回归SVR、岭回归、Logistic回归、贝叶斯回归
• 聚类clustering：k均值聚类、谱聚类、均值漂移Mean shift
• 数据降维 dimension reduction：减少要考虑的随机变量的数量。PCA主成分分析、特征选择feature selection、非负矩阵分解 non-negative matrix factorization
• 模型选择：评估和验证模型，对模型参数进行选择和平衡。包括模型度量metrics、网格搜索grid search、交叉验证cross validation等，通过调整模型参数来提高模型性能（预测准确度、泛化误差等）
• 数据预处理的功能：包括数据特征的提取、归一化，常用的模块有数据预处理preprocessing、特征抽取feature extraction

线性回归

• sklearn常用数据集

  

# 查看boston数据
from sklearn.datasets import load_boston
boston = load_boston()
boston.keys()
boston.data
boston.data[0]
boston.data[0][2]
boston.data[0,2]
boston.data.shape
boston.target
boston.feature_names
print(boston.DESCR)
boston.filename

# 利用pandas处理数据
import pandas as pd
bos = pd.DataFrame(boston.data) # numpy ndarray转成DataFrame
bos.head()
bos.columns = boston.feature_names # 添加特征名称
bos.head()
bos['PRICE'] = boston.target # 为DataFrame增加一列PRICE
bos.head()

# 分割数据集 训练集和测试集（验证集在模型初期不必须）
# train_test_split()： 为了处理方便，特征和标签必须是分开的
X = bos.drop('PRICE', axis=1)
y = bos['PRICE']
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 0)
# random_state为了保证数据集不碎机。也就是确保每次运行分割程序，获得一样的训练集和测试集
print(X_train.shape, y_test.shape)
X_train.head()

# 线性回归模型训练
from sklearn.linear_model import LinearRegression # 导入模型
LR = LinearRegression() # 生成模型
LR.fit(X_train, y_train) # 训练模型
y_pred = LR.predict(X_test)
print('截距w0=', LR.intercept_, '特征权重W=', LR.coef_)
​
import numpy as np
np.set_printoptions(precision = 3, suppress = True) # 设置numpy输出格式改变print格式
print('截距w0={0:.3f}'.format(LR.intercept_), '特征权重W=', LR.coef_) 

# 绘制预测结果
import matplotlib.pyplot as plt
import numpy as np
plt.scatter(y_test, y_pred)
plt.xlabel('Price: $Y_i$')
plt.title('Prices vs Predicted prices: $Y_i$ vs $\hat{Y}_i$')
plt.grid()
​
x = np.arange(0,50)
y = x
plt.plot(x,y,color='red',lw=4)
plt.text(30, 40, 'Predict line')
plt.show()

import seaborn as sns
​
data = pd.concat([pd.Series(y_test.values), pd.Series(y_pred)], axis = 1)
data.columns = ['actually price', 'pred price']
​
sns.lmplot(x = 'actually price', y = 'pred price', data = data)
plt.show()

# 模型效果评估
# RMSE 均方根误差 root mean square error
from sklearn import metrics
mse = metrics.mean_squared_error(y_test, y_pred)
print(mse)

K-近邻算法

惰性学习lazy learning——训练阶段只将样本保存，训练时间为0，收到测试样本后才开始处理。

K-mean是典型的少数服从多数。

距离：欧几里得距离 海明距离等

• k值选择

  • 

• 特征数据归一化

  • 

    from sklearn.preprocessing import MinMaxScaler
    min_max_scaler = MinMaxScaler()
    min_max_scaler.fit_transform(X_train).T
    

    

• 距离

  • 

• 分类原则

  • 加权投票原则，距离越近的领居，他的权重越大。

# knn 鸢尾花训练
import pandas as pd
df = pd.read_csv('./Iris/Iris.data', header=None)

from sklearn.datasets import load_iris
# 内置数据
iris = load_iris()
X = iris.data
y = iris.target

# 数据分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=123)

# 模型训练
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)

y_predict_on_train = knn.predict(X_train)
y_predict_on_test = knn.predict(X_test)

# 模型评估
from sklearn.metrics import accuracy_score
print('train accuracy:{:.2f}%'.format(100 * accuracy_score(y_train, y_predict_on_train)))
print('test accuracy:{:.2f}%'.format(100 * accuracy_score(y_test, y_predict_on_test)))

Logistic回归

监督学习，分类算法

• 线性回归模型：

• 概率probability P
• 可能性 odds

统计学领域，Logistic同义词是logit。比如　TensorFlow中的交叉熵损失函数tf.nn.softmax_cross_entropy_with_logits

logit就是：对数几率回归

值域（负无穷-正无穷），也就是说我们可以通过logit将任意实数值映射到0-1之间的值。

然后我们就可以用阈值（比如0.5）将0-1之间的概率转换为两个不同的类，比如0/1

logreg = LogisticRegression()
logreg.fit()
logreg.predict()

• 评估模型

  • 

神经网络学习算法

sklearn不支持深度学习，但支持多层感知机（浅层神经网络）

赫布假说

所以深度学习网络，学习的核心就是调整权重

合适的权重weight和偏置bias，让损失函数值最小

from sklearn.datasets import load_wine
wine = load_wine()

wine.data[0]
wine.data.shape
wine.target
wine.target_names
wine.feature_names

from sklearn.neural_network import MLPClassifier
# 构造多层感知机分类器模型
model = MLPClassifier(solver="lbfgs", hidden_layer_sizes=(10,10,))
model.fit(X_train, y_train) 

y_predict_on_train = model.predict(X_train)
y_predict_on_test = model.predict(X_test)

# 模型评估
from sklearn.metrics import accuracy_score
print('train accuracy:{:.2f}%'.format(100 * accuracy_score(y_train, y_predict_on_train)))
print('test accuracy:{:.2f}%'.format(100 * accuracy_score(y_test, y_predict_on_test)))

》〉》〉
train accuracy:39.52%
test accuracy:40.74%

数据预处理和特征工程决定了机器学习的上限，而模型和算法不过是逼近这个上限。

# 对数据做缩放处理
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
# 对训练集和测试集都做缩放处理
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
# 构造多层感知机分类器模型
model = MLPClassifier(solver="lbfgs", hidden_layer_sizes=(10,10,))
model.fit(X_train, y_train) 

y_predict_on_train = model.predict(X_train)
y_predict_on_test = model.predict(X_test)

# 模型评估
from sklearn.metrics import accuracy_score
print('train accuracy:{:.2f}%'.format(100 * accuracy_score(y_train, y_predict_on_train)))
print('test accuracy:{:.2f}%'.format(100 * accuracy_score(y_test, y_predict_on_test)))

》〉》〉》〉
train accuracy:100.00%
test accuracy:100.00%

# 查看模型参数
print(model.coefs_[0], '\n', model.coefs_[1])

=======================================================

非监督学习的代表——K均值聚类

K-mean和Knn是不一样的

K-means 的算法步骤为：

1. 选择初始化的 k 个样本作为初始聚类中心 a=a1,a2,…ak ；
2. 针对数据集中每个样本 xi 计算它到 k 个聚类中心的距离并将其分到距离最小的聚类中心所对应的类中；
3. 针对每个类别 aj ，重新计算它的聚类中心 aj=1|ci|∑x∈cix （即属于该类的所有样本的质心）；
4. 重复上面 2 3 两步操作，直到达到某个中止条件（迭代次数、最小误差变化等）。

优点

• 容易理解，聚类效果不错，虽然是局部最优， 但往往局部最优就够了；
• 处理大数据集的时候，该算法可以保证较好的伸缩性；
• 当簇近似高斯分布的时候，效果非常不错；
• 算法复杂度低。

缺点

• K 值需要人为设定，不同 K 值得到的结果不一样；
• 对初始的簇中心敏感，不同选取方式会得到不同结果；
• 对异常值敏感；
• 样本只能归为一类，不适合多分类任务；
• 不适合太离散的分类、样本类别不平衡的分类、非凸形状的分类。

• 基于sklearn的k均值聚类算法实战

# make_blobs()方法常用来生成聚类算法的测试数据
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs

blobs = make_blobs(n_samples=200, random_state=1, centers=4)
X_blobs = blobs[0] # 提取特征数据

plt.scatter(X_blobs[:,0], X_blobs[:,1], c=blobs[1])
plt.show()

from sklearn.cluster import KMeans
kmean = KMeans(n_clusters=4)
kmean.fit(X_blobs)