监督学习（回归和分类）常见算法总结

根据训练期间接受的监督数量和监督类型,可以将机器学习分为以下四种类型:监督学习、非监督学习、半监督学习和强化学习。

本期将对监督学习常见算法进行简述。

一，概述

? ? ?监督学习的目的是让模型能够从已知的输入和输出之间的关系中学习，并且能够对新的输入做出正确的预测。在监督学习的范畴中，又可以划分为回归和分类算法。

一，分类算法

1.KNN（k近邻算法）

（1）核心思想：

给定一个训练数据集，对于新的待分类的输入实例，计算训练数据集中与该输入实例最相近的k个实例，则这k个实例的多数属于某个类，就把该输入实例分为这个类中。

（2）工作原理：

1） 假设有一个带有标签的样本数据集（训练样本集），其中包含每条数据与所属分类的对应关系。
2） 输入没有标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进行比较。
3） 计算新数据与样本数据集中每条数据的距离。
4） 对求得的所有距离进行排序（从小到大，越小表示越相似）。
5） 取前 k （k 一般小于等于 20 ）个样本数据对应的分类标签。
6） 求 k 个数据中出现次数最多的分类标签作为新数据的分类。

（3）算法流程：

1）计算测试数据与各个训练数据之间的距离；
2）按照距离的递增关系进行排序；
3）选取距离最小的K个点；
4）确定前K个点所在类别的出现频率；
5）返回前K个点中出现频率最高的类别作为测试数据的预测分类

（4）KNN三要素：

k值的选择、距离度量及分类决策规则是k近邻法的三个基本要素

1）k值的选择 :
如果 k 太小, 则对噪声点敏感；如果 k 太大, 邻域可能包含很多其他类的点；经验就是k=3，上限k=sqrt(n)

2）距离度量：

特征空间中的两个实例点的距离是两个实例点相似程度的反映。
使用的距离最常用的是欧氏距离，但也可以是其他距离。

3）分类决策规则

k近邻法中的分类决策规则往往是多数表决，即由输入实例的k个邻近的训练实例中的多数类，决定输入实例的类。

（5）实战算法流程代码总结（鸢尾花）：

一.准备操作

1.导入数据：data=pd.read_csv('iris.csv')
2.查看数据信息：data.info()
3.删除不需要的项：data=data.drop('Unnamed: 0',axis=1)?

二.离散值处理

1.画出箱型图查看是否有离群值存在：sns.boxplot(data=data,orient='h',palette='Set1')
2.利用天花板—地板法 或者四分法对离群值进行消除

def std_data(data)
在+-3 std 范围内的为正常值

? ? ? ? if item <=3*std or item >=-3*std:
? ? ? ? ? ? sep_w.append(item)

超过这个范围，将其赋值为天花板值或者地板值

item <-3*std:
? ? ? ? ? ? item=-3*item

3.将原来具有离散值的项做以更新

new_sepal_width=pd.DataFrame(sep_w)
? ? data['new_sepal_width']=new_sepal_width

4.再画出箱型图观察修改后的变化
5.删除原来有离群值的项，将数据做以更新
data1=data.drop('sepal_width',axis=1)

三.处理空缺值

1.处理空值，用填充法

data1.fillna(method='ffill',inplace=True)
2.数据标准化

（1）查看某一项受另一项的影响 画出散点图进行观察

x=data1['petal_len']
y=data1['petal_width']
plt.scatter(x,y,c=y,cmap=plt.cm.cool)

（2）利用sklearn中preprocessing库中的StandardScaler类对特征进行标准化

from sklearn.preprocessing import StandardScaler
X_1=StandardScaler().fit_transform(x_)

（3）将标准化处理后的数据进行DataFrame转换，然后在画出散点图观察
X_=pd.DataFrame(X_1)
Y_=pd.DataFrame(y_)?

四.数据离散化
1.也就是分箱操作，按照上述的散点图选取适当的区间

def bins_train(X_):
bins_1=[-2,-0.3,1,3]
......
然后将 数值数据 转换为 分类数据

X_['sepal_length']=pd.cut(x=X_['sepal_len'],bins=bins_1,labels=labels,include_lowest=True)
? #sepal_len是要传入和切分的一维数组，bins是切片的方式，include_lowest=True表示第一个区间应该是左包含的
? ? ......

2.将离散化处理后的数据进行更新
data3=bins_train(data2)
且转换成列表格式
data4=pd.get_dummies(data3)?
3.重新定义因变量和自变量
x=data4.drop('target',axis=1)
y=data4['target']
五.数据集的划分
?利用 sklearn.model_selection import train_test_split
1.将数据划分为训练集和测试集 且训练集占总数据的25%
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.25)
2.设置knn的邻近值
knn=KNeighborsClassifier(n_neighbors=3)
3.利用fit进行训练
knn.fit(x_train,y_train)
4.利用predict进行测试
y_=knn.predict(x_train)
5.输出正确率
print((y_==y_train).mean())

（6）算法优缺点：

1）是一种基于实例的学习，需要一个邻近性度量来确定实例间的相似性或距离?
2）不需要建立模型，但分类一个测试样例开销很大
3）需要计算域所有训练实例之间的距离?
4）基于局部信息进行预测，对噪声非常敏感?

（7）KNN的应用

文本分类、模式识别、聚类分析、多分类领域。

2.贝叶斯分类器

贝叶斯分类器是一种基于统计的分类器,它根据给定样本属于某一个具体类的概率来对其进行分类。对于给出的待分类项，求解在此项出现的条件下各个类别出现的概率，哪个最大，就认为此待分类项属于哪个类别。

（1）贝叶斯公式：

其中分母为每个类别中目标样本的概率的线性组合，分子为对应类中目标样本的概率。

例如：X的属性值为：age=25,income=$5000,H对应的假设是：X会买电脑。
P(H|X)：意思是在已知某客户信息age=25,income=$5000的条件下,该客户会买电脑的概率。
P(H):意思是对于任何给定的客户信息，该客户会购买电脑的概率。
P(X|H)：意思是已知客户会买电脑，那么该客户的age=25,income=$5000的概率。
P(X):意思是在我们所有的客户信息集合中,客户的age=25,income=$5000的概率。
所以：P(H|X) = P(X|H)P(H)/P(X)

（2）算法流程：

1）计算训练集中每个类出现的概率P

2）计算两个矩阵的标准差和均值

（3）算法特点：

1） 算法逻辑简单,易于实现

2）朴素贝叶斯中的空值不用特殊处理

3）分类过程中时空开销小

3.决策树算法

（1）概念：

1）是一种树形结构，本质是一颗由多个判断节点组成的树

2）其中每个内部节点表示一个属性上的判断

3）每个分支代表一个判断结果的输出

4）最后每个叶节点代表一种分类结果

信息熵：

度量样本集合纯度最常用的一种指标

当数据量一致时，系统越有序，熵值越低；系统越混乱或者分散，熵值越高。

（2）算法流程：

1）收集数据

2）准备数据：树构造算法只适用于标称型数据，因此数值型数据必须离散化。

3）分析数据：可以使用任何方法，构造树完成之后，我们应该检查图形是否符合预期。

4）训练算法：构造树的数据结构。

5）测试算法：使用经验树计算错误率

（3）划分选择

1）信息增益（ID3算法）

使用信息增益作为属性选择方法
Entropy：信息熵越大，包含的不确定性因素越多

信息增益 = entroy(前) - entroy(后)

在没有任何选项直接看目标字段的熵，和，在有条件加持的情况下看目标字段的熵，发现熵会减小，所减少的熵也就是信息的增益。
采用信息增益作为评价标准

注：信息增益表示得知特征X的信息而使得类Y的信息熵减少的程度

?核心思想：根据样本子集属性取值的信息增益值的大小来选择决策属性(即决策树的非叶子结点)，并根据该属性的不同取值生成决策树的分支，再对子集进行递归调用该方法，当所有子集的数据都只包含于同一个类别时结束。最后，根据生成的决策树模型，对新的、未知类别的数据对象进行分类。

算法特点：不能处理具有连续值的属性，也不能处理具有缺失数据的属性，没有对决策树进行修剪的过程，噪声比较大

2）信息增益率（C5.0）

算法特点：
采用信息增益率，引入了分支度的概念
可以处理数值型数据：先将数值型数据从小到大排序，选取相邻两点的中间点，将数据自动离散化为两群，分别计算每一次分割的信息增益率，选取信息增益率最大的为切割点，这个信息增益率就是这些数值属性的信息增益率

出现过度拟合，进行剪枝操作：通过计算预测错误率来剪枝

3）基尼值和基尼指数（CART树）

二元分类回归树：每次分两支
Gini Index 作为评估:为0 纯度最好，越大纯度越低

4)回归树

和分类树一样，只不过在最后的叶结点上做了一个线性回归方程

输入：训练数据集D:

输出：回归树f(x)f(x).

在训练数据集所在的输入空间中，递归的将每个区域划分为两个子区域并决定每个子区域上的输出值，构建二叉决策树

dtr=tree.DecisionTreeRegressor(max_depth=2) 
#  导入回归决策树模型 Regressor做回归    树的深度设为2
print(dtr.fit(X,Y))#输出训练

4.SVM（支持向量机）

支持向量：位于超平面附近的样本点，也就是落在超平面边缘上的数据，是最难被正确分类的

支持向量机：是一种二分类模型，它的基本模型是定义在特征空间上的间隔最大的线性分类器。其实，支持向量机的意思是指：求支持向量到超平面的距离之和尽可能的大的算法。

将线性SVM延申为非线性SVM ：
1.使用非线性转换将原始数据映像到较高纬度的特征空间（用核函数）
2.在高纬度特征空间中找出的最佳分割平面，再恢复原来的维度就是到非线性分割超曲面

（1）SVM处理流程总结：

1）收集数据，相关性分析（比如p卡方检验），特征选择（比如主成份分析PCA）。

2）归一化数据：就是根据实际要求，将数据的取值范围转化为统一的区间如[a,b],a,b为整数。

3）分训练集和测试集：利用抽样技术将数据集分为训练集和测试集。

4）数据转换

5）选择核函数，可以优先考虑RBF。

6）使用交叉验证寻找最佳参数C和Υ：一个较好的方法就是分层抽样。

7）使用最佳参数C和Υ来训练整个训练集

8）利用测试集测试模型，得到精度。

（2）一个小例子：

#make_moons 生成半环形数据
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
x,y=make_moons(n_samples=100,noise=0.15,random_state=42)
#make_moons 生成半环形数据 noise=0.15,加到数据里面的噪声
def plot_dataset(x,y,axes):
    plt.plot(x[:,0][y==0],x[:,1][y==0],"bs")
    plt.plot(x[:,0][y==1],x[:,1][y==1],"g^")
    plt.axis(axes)
    plt.xlabel(r"$x_1$",fontsize=20)
    plt.ylabel(r"$x_2$",fontsize=20,rotation=0)

plot_dataset(x,y,[-1.5,2.5,-1,1.5])
plt.show()

from sklearn.pipeline import Pipeline
#管道
from sklearn.preprocessing import PolynomialFeatures
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC  #线性区分   SVC做分类问题

polynomial_svm_clf=Pipeline((("poly_features",PolynomialFeatures(degree=3)),#第一步：导入PolynomialFeatures对数据进行升维
                            ("scaler",StandardScaler()),#第二步：对数据压缩到正负3之间
                            ("svm_clf",LinearSVC(C=10,loss='hinge'))#第三步：导入分类函数 C=10表示容忍程度，loss='hinge'损失函数
                            ))
polynomial_svm_clf.fit(x,y)

import numpy as np
def plot_predictions(clf,axes):
    x0s=np.linspace(axes[0],axes[1],100)
    x1s=np.linspace(axes[2],axes[3],100)
    x0,x1=np.meshgrid(x0s,x1s)
    x=np.c_[x0.ravel(),x1.ravel()]
    y_pred=clf.predict(x).reshape(x0.shape)
    plt.contourf(x0,x1,y_pred,cmap=plt.cm.brg,alpha=0.2)

plot_predictions(polynomial_svm_clf,[-1.5,2.5,-1,1.5])
plot_dataset(x,y,[-1.5,2.5,-1,1.5])
plt.show()


#PolynomialFeatures 作用
reg=PolynomialFeatures(degree=3)
y=np.arange(6).reshape(3,2)
print(y)
Y=reg.fit_transform(y)
print(y)

观察分类的效果

5.逻辑回归

（1）概念理解：

1）研究分类因变量与一些影响因素之间关系的一种多变量分析方法

2）是线性回归的一种变化，能预测事件发生的概率，是机器学习的一种分类方法

3）逻辑回归就是将线性回归产生的值带入逻辑方程，将输出值压制在0-1之间，用来预测分类函数中某一类的概率
4）逻辑因变量是二值，表示发生或者不发生，用0和1表示

（2）数据要求

1）自变量与因变量之间存在线性关系

2）自变量之间不存在多重共线性

3）自变量为分类变量或连续变量，对于分类变量，通常需要进行哑变量编码

4）数据不含有缺失值、异常值，当数据集中自变量的差异较大时，需要对其进行标准化。标准化的方法包括最大最小值标准化、Z-score标准化等。

5）当数据集中存在大量自变量时，需要对其进行特征选择。特征选择的方法包括相关系数分析、Lasso回归等

（3）判断逻辑回归模型的好坏

1）准确率(Accuracy):指分类器正确分类的样本数占总样本数的比例。准确率越高，表示分类器的性能越好

2）精确率(Precision):指分类器正确预测为正例的样本数占所有预测为正例的样本数的比例。精确率越高，表示分类器的误判率越低

3）召回率(Recall):指分类器正确预测为正例的样本数占所有真正的正例样本数的比例。召回率越高，表示分类器正确预测为正例的能力越强

4）F1-score:是精确率和召回率的加权调和平均数，是评价分类器综合性能的指标。

5）ROC曲线和AUC值:ROC曲线是衡量二分类模型性能的曲线，AUC是ROC曲线下的面积，AUC越大表示模型性能越好。

6）对数似然损失 (Log Loss): 是分类器预测概率与实际标签之间的差异度量，对数似然损失越小，表示模型的性能越好。

（4）代码流程总结：

# 1.获取数据
from sklearn.datasets import load_iris
iris=load_iris()

# 2.基本数据处理
# 2.1 缺失值处理
data = data.replace(to_replace="?", value=np.NaN)
data = data.dropna()
# 2.2 确定特征值,目标值
x = data.iloc[:, 1:10]
x.head()
y = data["Class"]
y.head()
# 2.3 分割数据
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)、
# 3.特征工程(标准化)
transfer = StandardScaler()
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)
# 4.机器学习(逻辑回归)
estimator = LogisticRegression()
estimator.fit(x_train, y_train)
# 5.模型评估
y_predict = estimator.predict(x_test)
y_predict
estimator.score(x_test, y_test)

#6.绘制roc曲线
from sklearn.metrics import roc_curve, auc, confusion_matrix
fpr, tpr, thread = roc_curve(y_test, y_pred)
roc_auc = auc(fpr, tpr)
plt.figure()
lw = 2
plt.plot(fpr, tpr, color='darkorange',
         lw=lw, label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()

#7.F1指标
from sklearn.metrics import f1_score
f1 = f1_score(y_test, y_pred, average='micro')
print(f1)
#混淆矩阵
matrix = confusion_matrix(y_test, y_pred)
#画出混淆矩阵
dataframe = pd.DataFrame(matrix)
sns.heatmap(dataframe, annot=True, fmt='.20g',cbar=None, cmap="Blues")
plt.title("Confusion Matrix"), plt.tight_layout()
plt.ylabel("True Class"), plt.xlabel("Predicted Class")
plt.show()

（5）用途及特点

用途：寻找危险因素

优点：预测结果介于0-1之间；?适用于连续性和类别型自变量
缺点：对自变量多重共线性较为敏感；预测结果呈“S”型 ?，在两端随着值的变化概率变化很小，边际值太小，slope太小，中间概率变化很大，很敏感，导致无法确定阈值

注意：二项分布及（是或不是）：逻辑回归（logistic）

二，回归算法

1.线性回归算法

线性回归要处理的一类问题是：给定一组输入样本，和每个样本对应的目标值，需要在某一损失准则下，找到（学习到）目标值和输入值的函数关系，这样，当有一个新的样本到达时，可以预测其对应的目标值是多少。

1. 假设目标值（因变量）与特征值（自变量）之间线性相关（即满足一个多元一次方程，如：f(x)=w1x1+…+wnxn+b.）。
2. 然后构建损失函数。
3. 最后通过令损失函数最小来确定参数。（最关键的一步）

1.线性回归

线性回归的建立准则
1）自变量对因变量必须有显著的影响，呈现密切的线性相关
2）自变量与因变量之间的线性相关必须是真实的，而不是形式上的
3）自变量之间应具有一定的互斥性
4）自变量应具有完整的统计数据，其预测值容易确定

（2）一元线性回归

只用一个x来预测y，也就是找一个直线来拟合数据，并且让这条直线尽可能地拟合图中的数据点。当我们有一个新的x的时候，我们就可以用这个直线方程来预测大概的y值。

（3）多元线性回归

用多个x的线性组合来预测y，当有2个x的时候，就是找一个平面来拟合数据，并且让这个平面尽可能地拟合图中的数据点。当我们有一组新的X的时候，我们就可以用这个直线方程来预测大概的y值。

误差：真实值和预测值之间肯定存在差异的，垂直方向上散点与直线之间的距离称为误差 ?误差最小的直线称为线性回归直线Y=a+bX ?

误差函数：所有的点和平面之间的误差，损失函数（衡量回归模型误差的函数，也就是选取出最优拟合所需的评价标准，这个值越小，说明模型拟合效果越好）

损失函数：最小二乘法：J=1/2(yi-axi)**2连加的和，无限接近于最小值 ，损失越小

最小二乘法:最小二乘法就是试图找到一条直线，使得所有样本到直线上的欧式距离之和最小。

2.线性分类

线性分类和线性回归很相似，但不同的是，线性回归的目标值是连续变量，线性分类的目标值是离散变量。

1. 如果目标变量是分类型变量，比如预测性别（男、女）、预测颜色（红、白、黄）等，那就需要用分类算法去拟合得出分类算法模型；
2. 如果目标变量是连续型变量，如预测年龄（13，35，78）、收入（1w、2w)等，此时需要用回归算法去拟合得出回归算法模型。

3.线性回归评估方法：

（1）皮尔森相关系数：
取值介于正负1之间，数值越接近1，表示两者呈现越强烈的正相关；数值越接近于-1 表示两者呈现强烈的负相关；数值越接近于0，表示两者之间的相关程度越弱。
不可以由回归方程或相关分析建立因果关系

（2）MAE：平均绝对误差

MSE：对极端误差更敏感

from sklearn.metrics import mean_squared_error
rms = mean_squared_error(y, y_pred)

RMSE：即MSE开方

from sklearn.metrics import mean_squared_error
rms = sqrt(mean_squared_error(y, y_pred))

SST：因变量的总变化
SSR：每个值-均值的平方和
SSE：预测值-实际值的平方和
SST=SSR+SSE
R2=SSR/SST=1-SSE/SST
R2=1 自变量可以完全解释因变量
R2=0 自变量完全不能解释因变量

4.注意：进行回归分析时

(1）应先绘制散点图scatter plot ，如果提示有直线趋势存在，可做直线回归分析

(2)观察散点图，处理异常值

(3)回归直线不要外延

5.部分代码

# 1.线性回归
from sklearn import linear_model
lm = linear_model.LinearRegression()

res = lm.fit(x, y)
print('线性回归截距为',lm.intercept_)  # 输出截距
coef = zip(['area', 'office', 'in_ex', 'age'], lm.coef_)  # 特征和系数对应  打包对应为元组
for T in coef:
    print('线性回归的特征与系数：',T)
y_pred = lm.predict(x) #训练

2.岭回归

可以把岭回归看做是普通线性回归的一种优化，它是通过引入L2正则化项来对模型进行优化，最终使模型的拟合效果更好。因为用普通线性回归模型有的时候会出现问题，当自变量间存在多重线性关系或者矩阵不可求逆时，这种求法就会出错或者是参数K会很大。

1）当岭参数?=0?时，得到的解是最小二乘解

2）当岭参数??趋向更大时，岭回归系数?趋向于0，约束项很小

部分代码：

#   2.试试岭回归，记得调整参数看看
lm1 = linear_model.Ridge(alpha=1)
res1 = lm1.fit(x, y)

3.LASSO回归

岭回归限定了所有回归系数的平方和不大于t, 在使用普通最小二乘法回归的时候当两个变量具有相关性的时候，可能会使得其中一个系数是个很大正数，另一个系数是很大的负数。通过岭回归可以避免这个问题。

LASSO的主要思想是构造一个一阶惩罚函数获得一个精炼的模型, 通过最终确定一些变量的系数为0进行特征筛选。

部分代码：

#  3.试试lasso回归
lm2 = linear_model.Lasso(alpha=10)
res2 = lm2.fit(x, y)