机器学习之回归算法

机器学习之回归算法

参考链接：

#1. scikit-learn官网 https://scikit-learn.org/stable/modules/classes.html

#2. scikit-learn中文手册https://sklearn.apachecn.org/docs/master/30.html

#3. 分类回归方法介绍https://www.cnblogs.com/qiuyuyu/p/11399697.html

如何选择回归分析算法:

数据集本身结构简单、分布规律有明显线性关系——简单线性回归，基于最小二乘法的普通线性回归。

自变量数量少或降维后得到了二维变量（包括预测变量）——直接使用散点图，发现自变量和因变量之间的相互关系，然后再选择最佳回归方法

自变量间有较强共线性关系——岭回归，L2正则化，对多重共线性灵活处理的方法

如果噪声较多——推荐主成分回归，通过对参与回归的主成分的合理选择，可以去掉噪声；各个主成分相互正交，解决多元回归共线性问题。

高维度变量下——正则化回归方法，Lasso、Ridge、ElasticNet。降维、逐步回归

可使用交叉验证做多个模型的效果对比，验证多个算法

注重模型的可解释性—— 线性回归、逻辑回归、对数回归、二项式或多项式回归

集成或组合方法——加权、均值等方法确定最终输出结果（一旦确认来多个方法，又不确定取舍）

1. 线性回归–岭回归 --lasso回归

普通最小二乘法–LinearRegression 拟合一个带有系数 w = (w_1, …, w_p) 的线性模型，使得数据集实际观测数据和预测数据（估计值）之间的残差平方和最小。其数学表达式为:图片

岭回归–Ridge 回归通过对系数的大小施加惩罚来解决 普通最小二乘法 的一些问题。岭系数最小化的是带罚项的残差平方和。图片

Lasso回归–Lasso 是拟合稀疏系数的线性模型。它在一些情况下是有用的，因为它倾向于使用具有较少参数值的情况，有效地减少给定解决方案所依赖变量的数量。因此，Lasso 及其变体是压缩感知领域的基础。在一定条件下，它可以恢复一组非零权重的精确集（见压缩感知_断层重建）。图片

LinearRegression回归

import numpy as np
from sklearn.linear_model import LinearRegression
X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
# y = 1 * x_0 + 2 * x_1 + 3
y = np.dot(X, np.array([1, 2])) + 3
reg = LinearRegression().fit(X, y)
data1=reg.score(X, y)
data2=reg.coef_
data3=reg.intercept_
data4=reg.predict(np.array([[3, 5]]))
print(data1,data2,data3,data4)

Ridge 回归

from sklearn.linear_model import Ridge
import numpy as np
n_samples, n_features = 10, 5
rng = np.random.RandomState(0)
y = rng.randn(n_samples)
X = rng.randn(n_samples, n_features)

clf = Ridge(alpha=1.0)
clf.fit(X, y)
data1=clf.score(X, y)
data2=clf.coef_
data3=clf.intercept_
data4=clf.predict( [[-0.40178094,-1.63019835,0.46278226,-0.90729836,0.0519454 ]])
print(data1,data2,data3,data4)

内核岭回归(Kernel ridge regression-KRR）–与SVR类似

由使用内核方法的岭回归（使用 l2 正则化的最小二乘法）所组成。因此，它所拟合到的在空间中不同的线性函数是由不同的内核和数据所导致的。
对于非线性的内核，它与原始空间中的非线性函数相对应。

from sklearn.kernel_ridge import KernelRidge
import numpy as np

n_samples, n_features = 10, 5
rng = np.random.RandomState(0)
y = rng.randn(n_samples)
X = rng.randn(n_samples, n_features)

clf = KernelRidge(alpha=1.0)
clf.fit(X, y)
data1=clf.score(X, y)
data4=clf.predict( [[-0.40178094,-1.63019835,0.46278226,-0.90729836,0.0519454 ]])
print(data1,data2,data3,data4)

Lasso回归

from sklearn import linear_model

y = [0, 1, 2]
X = [[0,0], [1, 1], [2, 2]]
clf = linear_model.Lasso(alpha=0.1)
clf.fit(X, y)
data1=clf.score(X, y)
data2=clf.coef_
data3=clf.intercept_
data4=clf.predict( [[3,3]])
print(data1,data2,data3,data4)

线性回归算法比较和参数调优重要性研究

# -*- coding: utf-8 -*-
"""
Created on Mon Jul 16 09:08:09 2018

@author: zhen
"""

from sklearn.linear_model import LinearRegression, Ridge, Lasso
import mglearn
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import numpy as np
# 线性回归
x, y = mglearn.datasets.load_extended_boston()
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=0)

linear_reg = LinearRegression()
lr = linear_reg.fit(x_train, y_train)

print("lr.coef_:{}".format(lr.coef_))  # 斜率
print("lr.intercept_:{}".format(lr.intercept_))  # 截距

print("="*25+"线性回归"+"="*25)
print("Training set score:{:.2f}".format(lr.score(x_train, y_train)))
print("Rest set score:{:.2f}".format(lr.score(x_test, y_test)))

"""
    总结：
        训练集和测试集上的分数非常接近，这说明可能存在欠耦合。
        训练集和测试集之间的显著性能差异是过拟合的明显标志。解决方式是使用岭回归！
"""
print("="*25+"岭回归（默认值1.0）"+"="*25)
# 岭回归
ridge = Ridge().fit(x_train, y_train)

print("Training set score:{:.2f}".format(ridge.score(x_train, y_train)))
print("Test set score:{:.2f}".format(ridge.score(x_test, y_test)))

print("="*25+"岭回归（alpha=10）"+"="*25)
# 岭回归
ridge_10 = Ridge(alpha=10).fit(x_train, y_train)

print("Training set score:{:.2f}".format(ridge_10.score(x_train, y_train)))
print("Test set score:{:.2f}".format(ridge_10.score(x_test, y_test)))

print("="*25+"岭回归（alpha=0.1）"+"="*25)
# 岭回归
ridge_01 = Ridge(alpha=0.1).fit(x_train, y_train)

print("Training set score:{:.2f}".format(ridge_01.score(x_train, y_train)))
print("Test set score:{:.2f}".format(ridge_01.score(x_test, y_test)))


# 可视化
fig = plt.figure(10)
plt.subplots_adjust(wspace =0, hspace =0.6)#调整子图间距
ax1 = plt.subplot(2, 1, 1)

ax2 = plt.subplot(2, 1, 2)

ax1.plot(ridge_01.coef_, 'v', label="Ridge alpha=0.1")
ax1.plot(ridge.coef_, 's', label="Ridge alpha=1")
ax1.plot(ridge_10.coef_, '^', label="Ridge alpha=10")

ax1.plot(lr.coef_, 'o', label="LinearRegression")


ax1.set_ylabel("Cofficient magnitude")
ax1.set_ylim(-25,25)
ax1.hlines(0, 0, len(lr.coef_))
ax1.legend(ncol=2, loc=(0.1, 1.05))

print("="*25+"Lasso回归（默认配置）"+"="*25)
lasso = Lasso().fit(x_train, y_train)

print("Training set score:{:.2f}".format(lasso.score(x_train, y_train)))
print("Test set score:{:.2f}".format(lasso.score(x_test, y_test)))
print("Number of features used:{}".format(np.sum(lasso.coef_ != 0)))

print("="*25+"Lasso回归（aplpha=0.01）"+"="*25)
lasso_001 = Lasso(alpha=0.01, max_iter=1000).fit(x_train, y_train)

print("Training set score:{:.2f}".format(lasso_001.score(x_train, y_train)))
print("Test set score:{:.2f}".format(lasso_001.score(x_test, y_test)))
print("Number of features used:{}".format(np.sum(lasso_001.coef_ != 0)))


print("="*15+"Lasso回归（aplpha=0.0001）太小可能会过拟合"+"="*15)
lasso_00001 = Lasso(alpha=0.0001, max_iter=1000).fit(x_train, y_train)

print("Training set score:{:.2f}".format(lasso_00001.score(x_train, y_train)))
print("Test set score:{:.2f}".format(lasso_00001.score(x_test, y_test)))
print("Number of features used:{}".format(np.sum(lasso_00001.coef_ != 0)))


# 可视化
ax2.plot(ridge_01.coef_, 'o', label="Ridge alpha=0.1")
ax2.plot(lasso.coef_, 's', label="lasso alpha=1")
ax2.plot(lasso_001.coef_, '^', label="lasso alpha=0.001")
ax2.plot(lasso_00001.coef_, 'v', label="lasso alpha=0.00001")

ax2.set_ylabel("Cofficient magnitude")
ax2.set_xlabel("Coefficient index")
ax2.set_ylim(-25,25)
ax2.legend(ncol=2, loc=(0.1, 1))
plt.show()
图片

2. 支持向量机¶

支持向量分类的方法可以被扩展用作解决回归问题. 这个方法被称作支持向量回归.

支持向量分类生成的模型(如前描述)只依赖于训练集的子集,因为构建模型的 cost function 不在乎边缘之外的训练点. 类似的,支持向量回归生成的模型只依赖于训练集的子集, 因为构建模型的 cost function 忽略任何接近于模型预测的训练数据.

支持向量回归有三种不同的实现形式: SVR, NuSVR 和 LinearSVR. 在只考虑线性核的情况下, LinearSVR 比 SVR 提供一个更快的实现形式, 然而比起 SVR 和 LinearSVR, NuSVR 实现一个稍微不同的构思。

SVR

from sklearn.svm import SVR
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
import numpy as np
n_samples, n_features = 10, 5
rng = np.random.RandomState(0)
y = rng.randn(n_samples)
X = rng.randn(n_samples, n_features)
regr = make_pipeline(StandardScaler(), SVR(C=1.0, epsilon=0.2))
regr.fit(X, y)
print(regr.predict(rng.randn(1, n_features)))
#LinearSVR
from sklearn.svm import LinearSVR
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_regression
X, y = make_regression(n_features=4, random_state=0)
regr = make_pipeline(StandardScaler(),
                     LinearSVR(random_state=0, tol=1e-5))
regr.fit(X, y)
print(regr.predict(rng.randn(1, 4)))

NuSVR

from sklearn.svm import NuSVR
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
import numpy as np
n_samples, n_features = 10, 5
np.random.seed(0)
y = np.random.randn(n_samples)
X = np.random.randn(n_samples, n_features)
regr = make_pipeline(StandardScaler(), NuSVR(C=1.0, nu=0.1))
regr.fit(X, y)
print(regr.predict(rng.randn(1, 5)))

3. 随机梯度下降(SGD) 回归

SGDRegressor 类实现了一个简单的随机梯度下降学习例程，它支持用不同的损失函数和惩罚来拟合线性回归模型。SGDRegressor 非常适用于有大量训练样本（>10.000)的回归问题，对于其他问题，我们推荐使用 Ridge ，Lasso ，或 ElasticNet 。

具体的损失函数可以通过 loss 参数设置。SGDRegressor 支持以下的损失函数:

loss=“squared_loss”: Ordinary least squares（普通最小二乘法）,
loss=“huber”: Huber loss for robust regression（Huber回归）,
loss=“epsilon_insensitive”: linear Support Vector Regression（线性支持向量回归）.

import numpy as np
from sklearn.linear_model import SGDRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
n_samples, n_features = 10, 5
rng = np.random.RandomState(0)
y = rng.randn(n_samples)
X = rng.randn(n_samples, n_features)
# Always scale the input. The most convenient way is to use a pipeline.
reg = make_pipeline(StandardScaler(),
                    SGDRegressor(max_iter=1000, tol=1e-3))
reg.fit(X, y)
print(regr.predict(rng.randn(1, 5)))

4. 最近邻回归 KNN

最近邻回归是用在数据标签为连续变量，而不是离散变量的情况下。分配给查询点的标签是由它的最近邻标签的均值计算而来的。

scikit-learn 实现了两种不同的最近邻回归：KNeighborsRegressor 基于每个查询点的 k 个最近邻实现， 其中 k 是用户指定的整数值。RadiusNeighborsRegressor 基于每个查询点的固定半径 r 内的邻点数量实现， 其中 r 是用户指定的浮点数值。

基本的最近邻回归使用统一的权重：即，本地邻域内的每个邻点对查询点的分类贡献一致。在某些环境下，对邻点加权可能是有利的，使得附近点对于回归所作出的贡献多于远处点。这可以通过 weights 关键字来实现。默认值 weights = ‘uniform’ 为所有点分配同等权重。而 weights = ‘distance’ 分配的权重与查询点距离呈反比。或者，用户可以自定义一个距离函数用来计算权重。

X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsRegressor
neigh = KNeighborsRegressor(n_neighbors=2)
neigh.fit(X, y)

print(neigh.predict([[1.5]]))

5. 高斯过程回归（GPR）

高斯过程 (GP) 是一种常用的监督学习方法，旨在解决回归问题和概率分类问题。

高斯过程模型的优点如下：
预测内插了观察结果（至少对于正则核）。
预测结果是概率形式的（高斯形式的）。这样的话，人们可以计算得到经验置信区间并且据此来判断是否需要修改（在线拟合，自适应）在一些区域的预测值。
通用性: 可以指定不同的:内核(kernels)。虽然该函数提供了常用的内核，但是也可以指定自定义内核。

高斯过程模型的缺点包括：
它们不稀疏，例如，模型通常使用整个样本/特征信息来进行预测。
高维空间模型会失效，高维也就是指特征的数量超过几十个。

from sklearn.datasets import make_friedman2
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import DotProduct, WhiteKernel
X, y = make_friedman2(n_samples=500, noise=0, random_state=0)
kernel = DotProduct() + WhiteKernel()
gpr = GaussianProcessRegressor(kernel=kernel,
        random_state=0).fit(X, y)
gpr.score(X, y)

print(gpr.predict(X[:2,:], return_std=True))

6. 偏最小二乘法回归（PLS）

    偏最小二乘回归提供一种多对多线性回归建模的方法，特别当两组变量的个数很多，且都存在多重相关性，而观测数据的数量（样本量）又较少时，用偏最小二乘回归建立的模型具有传统的经典回归分析等方法所没有的优点。

    在解决多对多线性回归问题时，多元线性回归会因为自变量之间存在的相关性导致过拟合。PLS的方法先找到线性独立的替换自变量，这样它们之间相互独立且与能最大限度的反应因变量之间的差异 https://blog.csdn.net/Candy_GL/article/details/79815228?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_title~default-0.control&spm=1001.2101.3001.4242

# PLSRegression
from sklearn.cross_decomposition import PLSRegression
X = [[0., 0., 1.], [1.,0.,0.], [2.,2.,2.], [2.,5.,4.]]
Y = [[0.1, -0.2], [0.9, 1.1], [6.2, 5.9], [11.9, 12.3]]
pls2 = PLSRegression(n_components=2)
pls2.fit(X, Y)
Y_pred = pls2.predict(X)
print(Y_pred)

7.决策树回归

Decision Trees (DTs) 是一种用来 classification 和 regression 的无参监督学习方法。其目的是创建一种模型从数据特征中学习简单的决策规则来预测一个目标变量的值。

决策树的优势:

便于理解和解释。树的结构可以可视化出来。
训练需要的数据少。其他机器学习模型通常需要数据规范化，比如构建虚拟变量和移除缺失值,不过请注意，这种模型不支持缺失值。
由于训练决策树的数据点的数量导致了决策树的使用开销呈指数分布(训练树模型的时间复杂度是参与训练数据点的对数值)。
能够处理数值型数据和分类数据。其他的技术通常只能用来专门分析某一种变量类型的数据集。详情请参阅算法。
能够处理多路输出的问题。
使用白盒模型。如果某种给定的情况在该模型中是可以观察的，那么就可以轻易的通过布尔逻辑来解释这种情况。相比之下，在黑盒模型中的结果就是很难说明清 楚地。
可以通过数值统计测试来验证该模型。这对事解释验证该模型的可靠性成为可能。
即使该模型假设的结果与真实模型所提供的数据有些违反，其表现依旧良好。
决策树的缺点包括:

决策树模型容易产生一个过于复杂的模型,这样的模型对数据的泛化性能会很差。这就是所谓的过拟合.一些策略像剪枝、设置叶节点所需的最小样本数或设置数的最大深度是避免出现 该问题最为有效地方法。
决策树可能是不稳定的，因为数据中的微小变化可能会导致完全不同的树生成。这个问题可以通过决策树的集成来得到缓解
在多方面性能最优和简单化概念的要求下，学习一棵最优决策树通常是一个NP难问题。因此，实际的决策树学习算法是基于启发式算法，例如在每个节点进 行局部最优决策的贪心算法。这样的算法不能保证返回全局最优决策树。这个问题可以通过集成学习来训练多棵决策树来缓解,这多棵决策树一般通过对特征和样本有放回的随机采样来生成。
有些概念很难被决策树学习到,因为决策树很难清楚的表述这些概念。例如XOR，奇偶或者复用器的问题。
如果某些类在问题中占主导地位会使得创建的决策树有偏差。因此，我们建议在拟合前先对数据集进行平衡。

from sklearn import tree
X = [[0, 0], [2, 2]]
y = [0.5, 2.5]
clf = tree.DecisionTreeRegressor()
clf = clf.fit(X, y)
data=clf.predict([[1, 1]])
print(data)

8. 集成学习（Ensembale Learning）

常见的集成算法：bagging、boosting、stacking

Bagging Bagging这个名字是Boostrap AGGregatING缩写而来的，是并行式集成学习方法的最著名代表。

Random Forest (随机森林) RF随机森林是一个包含多个决策树的分类器，其输出的类别是由各个子树数据类别的众数（majority voting）决定的。当你不知道该用什么算法来处理分类的时候，随机森林都是一个作为尝试的不错的选择。

Boosting Boosting是一族将弱学习器提升为强学习器的算法。

GBDT（Gradient Boost Decision Tree) 增强版叫做xgboost

Adaboost ：梯度提升树 模型 sklearn.ensemble 包含了流行的提升算法 AdaBoost, 这个算法是由 Freund and Schapire 在 1995 年提出来的 [FS1995]. AdaBoost 的核心思想是用反复修改的数据（校对者注：主要是修正数据的权重）来训练一系列的弱学习器(一个弱学习器模型仅仅比随机猜测好一点, 比如一个简单的决策树),由这些弱学习器的预测结果通过加权投票(或加权求和)的方式组合, 得到我们最终的预测结果。

stacking

Random Forest

from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import make_regression
X, y = make_regression(n_features=4, n_informative=2,
                       random_state=0, shuffle=False)
regr = RandomForestRegressor(max_depth=2, random_state=0)
regr.fit(X, y)

print(regr.predict([[0, 0, 0, 0]]))

GBDT

Gradient Tree Boosting 或梯度提升回归树（GBRT）是对于任意的可微损失函数的提升算法的泛化。
#GBRT 是一个准确高效的现有程序， 它既能用于分类问题也可以用于回归问题。梯度树提升模型被应用到各种领域，包括网页搜索排名和生态领域。

from sklearn.datasets import make_regression
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import train_test_split
X, y = make_regression(random_state=0)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, random_state=0)
reg = GradientBoostingRegressor(random_state=0)
reg.fit(X_train, y_train)

reg.predict(X_test[1:2])

reg.score(X_test, y_test)

xgboost

from sklearn.datasets import make_hastie_10_2
from xgboost import XGBRegressor

X, y = make_regression(random_state=0)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, random_state=0)
reg = XGBRegressor(random_state=0)
reg.fit(X_train, y_train)

y_pred=reg.predict(X_test[1:2])

reg.score(X_test, y_test)
print(y_pred)

Adaboost 梯度提升树

from sklearn.ensemble import AdaBoostRegressor
from sklearn.datasets import make_regression
X, y = make_regression(n_features=4, n_informative=2,
                       random_state=0, shuffle=False)
regr = AdaBoostRegressor(random_state=0, n_estimators=100)
regr.fit(X, y)

data=regr.predict([[0, 0, 0, 0]])

regr.score(X, y)
print(data)

Voting Regressor（投票回归器）

投票回归器背后的思想是将概念上不同的机器学习回归器组合起来，并返回平均预测值。
#这样一个回归器对于一组同样表现良好的模型是有用的，以便平衡它们各自的弱点。

# from sklearn import datasets
from sklearn.datasets import make_regression
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import VotingRegressor

from sklearn.datasets import make_regression
X, y = make_regression(n_features=4, n_informative=2,
                       random_state=0, shuffle=False)

# Training classifiers
reg1 = GradientBoostingRegressor(random_state=1, n_estimators=10)
reg2 = RandomForestRegressor(random_state=1, n_estimators=10)
reg3 = LinearRegression()
ereg = VotingRegressor(estimators=[('gb', reg1), ('rf', reg2), ('lr', reg3)])
ereg = ereg.fit(X, y)
data=ereg.predict([[0, 0, 0, 0]])
print(data)

9.神经网络模型回归

MLPRegressor 类实现了多层感知器（MLP），它使用反向传播进行训练，输出层没有使用激活函数，也可以被看作是使用恒等函数（identity function）作为激活函数。因此，它使用平方误差作为损失函数，输出是一组连续值。

MLPRegressor 还支持多输出回归，其中一个样本可以有多个目标值。

from sklearn.neural_network import MLPRegressor
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler  #归一化
X, y = make_regression(n_samples=200, random_state=1)
X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                    random_state=1)
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
regr = MLPRegressor(random_state=1, max_iter=500).fit(X_train, y_train)
data=regr.predict(X_test[:2])
regr.score(X_test, y_test)
print(data)