机器学习04-(决策树、集合算法：AdaBoost模型、BBDT、随机森林、分类模型：逻辑回归)

最新推荐文章于 2021-06-29 17:00:43 发布
最新推荐文章于 2021-06-29 17:00:43 发布
阅读量1.4k 收藏 4
点赞数 1
分类专栏： 机器学习 文章标签： 机器学习 决策树 集合算法 分类模型
原文链接：https://blog.csdn.net/m0_55389447/article/details/119442586
版权

机器学习04

机器学习-04

集合算法

根据多个不同模型给出的预测结果，利用平均(回归)或者投票(分类)的方法，得出最终预测结果。

基于决策树的集合算法，就是按照某种规则，构建多棵彼此不同的决策树模型，分别给出针对未知样本的预测结果，最后通过平均或投票得到相对综合的结论。常用的集合模型包括Boosting类模型（AdaBoost、GBDT）与Bagging（自助聚合、随机森林）类模型。

AdaBoost模型（正向激励）

首先为样本矩阵中的样本随机分配初始权重，由此构建一棵带有权重的决策树，在由该决策树提供预测输出时，通过加权平均或者加权投票的方式产生预测值。将训练样本代入模型，预测其输出，对那些预测值与实际值不同的样本，提高其权重，由此形成第二棵决策树。重复以上过程，构建出不同权重的若干棵决策树。

正向激励相关API：

import sklearn.tree as st
import sklearn.ensemble as se
# model: 决策树模型（一颗）
model = st.DecisionTreeRegressor(max_depth=4)
# 自适应增强决策树回归模型	
# n_estimators：构建400棵不同权重的决策树，训练模型
model = se.AdaBoostRegressor(model, n_estimators=400, random_state=7)
# 训练模型
model.fit(train_x, train_y)
# 测试模型
pred_test_y = model.predict(test_x)

案例：基于正向激励训练预测波士顿地区房屋价格的模型。

# 创建基于决策树的正向激励回归器模型
model = se.AdaBoostRegressor(
	st.DecisionTreeRegressor(max_depth=4), n_estimators=400, random_state=7)
# 训练模型
model.fit(train_x, train_y)
# 测试模型
pred_test_y = model.predict(test_x)
print(sm.r2_score(test_y, pred_test_y))
特征重要性

作为决策树模型训练过程的副产品，根据划分子表时选择特征的顺序标志了该特征的重要程度，此即为该特征重要性指标。训练得到的模型对象提供了属性：feature_importances_来存储每个特征的重要性。

获取样本矩阵特征重要性属性：

model.fit(train_x, train_y)
fi = model.feature_importances_

案例：获取普通决策树与正向激励决策树训练的两个模型的特征重要性值，按照从大到小顺序输出绘图。

import matplotlib.pyplot as mp

model = st.DecisionTreeRegressor(max_depth=4)
model.fit(train_x, train_y)
# 决策树回归器给出的特征重要性
fi_dt = model.feature_importances_
model = se.AdaBoostRegressor(
    st.DecisionTreeRegressor(max_depth=4), n_estimators=400, random_state=7)
model.fit(train_x, train_y)
# 基于决策树的正向激励回归器给出的特征重要性
fi_ab = model.feature_importances_

mp.figure('Feature Importance', facecolor='lightgray')
mp.subplot(211)
mp.title('Decision Tree', fontsize=16)
mp.ylabel('Importance', fontsize=12)
mp.tick_params(labelsize=10)
mp.grid(axis='y', linestyle=':')
sorted_indices = fi_dt.argsort()[::-1]
pos = np.arange(sorted_indices.size)
mp.bar(pos, fi_dt[sorted_indices], facecolor='deepskyblue', edgecolor='steelblue')
mp.xticks(pos, feature_names[sorted_indices], rotation=30)
mp.subplot(212)
mp.title('AdaBoost Decision Tree', fontsize=16)
mp.ylabel('Importance', fontsize=12)
mp.tick_params(labelsize=10)
mp.grid(axis='y', linestyle=':')
sorted_indices = fi_ab.argsort()[::-1]
pos = np.arange(sorted_indices.size)
mp.bar(pos, fi_ab[sorted_indices], facecolor='lightcoral', edgecolor='indianred')
mp.xticks(pos, feature_names[sorted_indices], rotation=30)
mp.tight_layout()
mp.show()
GBDT

GBDT（Gradient Boosting Decision Tree 梯度提升树）通过多轮迭代，每轮迭代产生一个弱分类器，每个分类器在上一轮分类器的残差**（残差在数理统计中是指实际观察值与估计值（拟合值）之间的差）**基础上进行训练。基于预测结果的残差设计损失函数。GBDT训练的过程即是求该损失函数最小值的过程。

案例：预测年龄

样本消费金额上网时长年龄
A1000114
B8001.216
C12000.924
D14001.526

训练第一颗决策树：

总 样 本 { ( 金 额 < = 1000 ) ⇒ [ A 1000 1 14 B 800 1.2 16 ] ( 金 额 > 1000 ) ⇒ [ C 1200 1 24 D 1400 1.5 26 ] 总样本\left\{ \begin{aligned} (金额<=1000) \quad \Rightarrow \quad \begin{bmatrix} A & 1000 & 1 & 14\\ B & 800 & 1.2 & 16\\ \end{bmatrix}\\ \\ (金额>1000) \quad \Rightarrow \quad \begin{bmatrix} C & 1200 & 1 & 24\\ D & 1400 & 1.5 & 26\\ \end{bmatrix}\\ \end{aligned} \right. 总样本⎩⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎧​(金额<=1000)⇒[AB​1000800​11.2​1416​](金额>1000)⇒[CD​12001400​11.5​2426​]​

计算每个样本的真实结果与预测结果之差（残差）：

样本消费金额上网时长残差
A10001-1
B8001.21
C12000.9-1
D14001.51

基于残差训练第二颗决策树：
总 样 本 { ( 时 长 < = 1 ) ⇒ [ A 1000 1 − 1 C 1200 1 − 1 ] ( 时 长 > 1 ) ⇒ [ B 800 1.2 1 D 1400 1.5 1 ] 总样本\left\{ \begin{aligned} (时长<=1) \quad \Rightarrow \quad \begin{bmatrix} A & 1000 & 1 & -1\\ C & 1200 & 1 & -1\\ \end{bmatrix}\\ \\ (时长>1) \quad \Rightarrow \quad \begin{bmatrix} B & 800 & 1.2 & 1\\ D & 1400 & 1.5 & 1\\ \end{bmatrix}\\ \end{aligned} \right. 总样本⎩⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎧​(时长<=1)⇒[AC​10001200​11​−1−1​](时长>1)⇒[BD​8001400​1.21.5​11​]​

再次计算每个样本残差为0，再无优化空间，迭代结束。

预测过程：预测以下样本的年龄：

样本消费金额上网时长年龄
E12001.6?

将每颗决策树的预测结果相加： 25 + 1 = 26 25 + 1 = 26 25+1=26

import sklearn.tree as st
import sklearn.ensemble as se
# 自适应增强决策树回归模型	
# n_estimators：构建400棵不同权重的决策树，训练模型
model = se.GridientBoostingRegressor(
    	max_depth=10, n_estimators=1000, min_samples_split=2)
# 训练模型
model.fit(train_x, train_y)
# 测试模型
pred_test_y = model.predict(test_x)
自助聚合

每次从总样本矩阵中以有放回抽样的方式随机抽取部分样本构建决策树，这样形成多棵包含不同训练样本的决策树，以削弱某些强势样本对模型预测结果的影响，提高模型的泛化特性。

随机森林

在自助聚合的基础上，每次构建决策树模型时，不仅随机选择部分样本，而且还随机选择部分特征，这样的集合算法，不仅规避了强势样本对预测结果的影响，而且也削弱了强势特征的影响，使模型的预测能力更加泛化。

随机森林相关API：

import sklearn.ensemble as se
# 随机森林回归模型	（属于集合算法的一种）
# max_depth：决策树最大深度10
# n_estimators：构建1000棵决策树，训练模型
# min_samples_split: 子表中最小样本数 若小于这个数字，则不再继续向下拆分
model = se.RandomForestRegressor(
    max_depth=10, n_estimators=1000, min_samples_split=2)

案例：分析共享单车的需求，从而判断如何进行共享单车的投放。

import numpy as np
import sklearn.utils as su
import sklearn.ensemble as se
import sklearn.metrics as sm
import matplotlib.pyplot as mp

data = np.loadtxt('../data/bike_day.csv', unpack=False, dtype='U20', delimiter=',')
day_headers = data[0, 2:13]
x = np.array(data[1:, 2:13], dtype=float)
y = np.array(data[1:, -1], dtype=float)

x, y = su.shuffle(x, y, random_state=7)
print(x.shape, y.shape)
train_size = int(len(x) * 0.9)
train_x, test_x, train_y, test_y = \
    x[:train_size], x[train_size:], y[:train_size], y[train_size:]
# 随机森林回归器
model = se.RandomForestRegressor( max_depth=10, n_estimators=1000, min_samples_split=2)
model.fit(train_x, train_y)
# 基于“天”数据集的特征重要性
fi_dy = model.feature_importances_
pred_test_y = model.predict(test_x)
print(sm.r2_score(test_y, pred_test_y))

data = np.loadtxt('../data/bike_hour.csv', unpack=False, dtype='U20', delimiter=',')
hour_headers = data[0, 2:13]
x = np.array(data[1:, 2:13], dtype=float)
y = np.array(data[1:, -1], dtype=float)
x, y = su.shuffle(x, y, random_state=7)
train_size = int(len(x) * 0.9)
train_x, test_x, train_y, test_y = \
    x[:train_size], x[train_size:], \
    y[:train_size], y[train_size:]
# 随机森林回归器
model = se.RandomForestRegressor(
    max_depth=10, n_estimators=1000,
    min_samples_split=2)
model.fit(train_x, train_y)
# 基于“小时”数据集的特征重要性
fi_hr = model.feature_importances_
pred_test_y = model.predict(test_x)
print(sm.r2_score(test_y, pred_test_y))

画图显示两组样本数据的特征重要性：

mp.figure('Bike', facecolor='lightgray')
mp.subplot(211)
mp.title('Day', fontsize=16)
mp.ylabel('Importance', fontsize=12)
mp.tick_params(labelsize=10)
mp.grid(axis='y', linestyle=':')
sorted_indices = fi_dy.argsort()[::-1]
pos = np.arange(sorted_indices.size)
mp.bar(pos, fi_dy[sorted_indices], facecolor='deepskyblue', edgecolor='steelblue')
mp.xticks(pos, day_headers[sorted_indices], rotation=30)

mp.subplot(212)
mp.title('Hour', fontsize=16)
mp.ylabel('Importance', fontsize=12)
mp.tick_params(labelsize=10)
mp.grid(axis='y', linestyle=':')
sorted_indices = fi_hr.argsort()[::-1]
pos = np.arange(sorted_indices.size)
mp.bar(pos, fi_hr[sorted_indices], facecolor='lightcoral', edgecolor='indianred')
mp.xticks(pos, hour_headers[sorted_indices], rotation=30)
mp.tight_layout()
mp.show()

分类模型

什么问题属于分类问题？

sklearn.datasets.load_iris() 鸢尾花数据集

逻辑回归

逻辑回归分类模型是一种基于回归思想实现分类业务的分类模型。

逻辑回归做二元分类时的核心思想为：

针对输出为{0, 1}的已知训练样本训练一个回归模型，使得训练样本的预测输出限制在(0, 1)的数值区间。该使原类别为0的样本的输出更接近于0，原类别为1的样本的输出更接近于1。这样就可以使用相同的回归模型来完成分类预测。

逻辑回归原理：

逻辑回归目标函数：
逻 辑 函 数 ( s i g m o i d ) ： y = 1 1 + e − z ; z = w T x + b 逻辑函数(sigmoid)：y = \frac{1}{1+e^{-z}}; \quad z=w^Tx+b 逻辑函数(sigmoid)：y=1+e−z1​;z=wTx+b
该逻辑函数值域被限制在(0, 1)区间，当x>0，y>0.5；当x<0, y<0.5。可以把训练样本数据通过线性预测模型 z z z 代入逻辑函数，找到一组最优秀的模型参数使得原本属于1类别的样本输出趋近于1；原本属于0类别的样本输出趋近于0。即将预测函数的输出看做被划分为1类的概率，择概率大的类别作为预测结果。

逻辑回归相关API：

import sklearn.linear_model as lm
# 构建逻辑回归器 
# solver：逻辑函数中指数的函数关系（liblinear为线型函数关系）
# C：参数代表正则强度，为了防止过拟合。正则越大拟合效果越小。
model = lm.LogisticRegression(solver='liblinear', C=正则强度)
model.fit(训练输入集，训练输出集)
result = model.predict(带预测输入集)

案例：基于逻辑回归器绘制网格化坐标颜色矩阵。

import numpy as np
import sklearn.linear_model as lm
import matplotlib.pyplot as mp
x = np.array([
    [3, 1],
    [2, 5],
    [1, 8],
    [6, 4],
    [5, 2],
    [3, 5],
    [4, 7],
    [4, -1]])
y = np.array([0, 1, 1, 0, 0, 1, 1, 0])`
# 逻辑分类器
model = lm.LogisticRegression(solver='liblinear', C=1)
model.fit(x, y)
l, r = x[:, 0].min() - 1, x[:, 0].max() + 1
b, t = x[:, 1].min() - 1, x[:, 1].max() + 1
n = 500
grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
samples = np.column_stack((grid_x.ravel(), grid_y.ravel()))

grid_z = model.predict(samples)
grid_z = grid_z.reshape(grid_x.shape)
mp.figure('Logistic Classification', facecolor='lightgray')
mp.title('Logistic Classification', fontsize=20)
mp.xlabel('x', fontsize=14)
mp.ylabel('y', fontsize=14)
mp.tick_params(labelsize=10)
mp.pcolormesh(grid_x, grid_y, grid_z, cmap='gray')
mp.scatter(x[:, 0], x[:, 1], c=y, cmap='brg', s=80)
mp.show()

多元分类

通过多个二元分类器解决多元分类问题。

特征1特征2==>所属类别
47==>A
3.58==>A
1.21.9==>B
5.42.2==>C

若拿到一组新的样本，可以基于二元逻辑分类训练出一个模型判断属于A类别的概率。再使用同样的方法训练出两个模型分别判断属于B、C类型的概率，最终选择概率最高的类别作为新样本的分类结果。

案例：基于逻辑分类模型的多元分类。

import numpy as np
import sklearn.linear_model as lm
import matplotlib.pyplot as mp
x = np.array([
    [4, 7],
    [3.5, 8],
    [3.1, 6.2],
    [0.5, 1],
    [1, 2],
    [1.2, 1.9],
    [6, 2],
    [5.7, 1.5],
    [5.4, 2.2]])
y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2])
# 逻辑分类器
model = lm.LogisticRegression(solver='liblinear', C=1000)
model.fit(x, y)
l, r = x[:, 0].min() - 1, x[:, 0].max() + 1
b, t = x[:, 1].min() - 1, x[:, 1].max() + 1
n = 500
grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
samples = np.column_stack((grid_x.ravel(), grid_y.ravel()))
grid_z = model.predict(samples)
print(grid_z)
grid_z = grid_z.reshape(grid_x.shape)

mp.figure('Logistic Classification', facecolor='lightgray')
mp.title('Logistic Classification', fontsize=20)
mp.xlabel('x', fontsize=14)
mp.ylabel('y', fontsize=14)
mp.tick_params(labelsize=10)
mp.pcolormesh(grid_x, grid_y, grid_z, cmap='gray')
mp.scatter(x[:, 0], x[:, 1], c=y, cmap='brg', s=80)
mp.show()

代码总结

波士顿房屋价格数据分析与房价预测

import numpy as np
import matplotlib.pyplot as plt
import sklearn.datasets as sd
import sklearn.utils as su
import pandas as pd

# 加载数据集
boston = sd.load_boston()
# print(boston.DESCR)
x, y, header = boston.data, boston.target, boston.feature_names

# 针对当前数据集，做简单的数据分析
data = pd.DataFrame(x, columns=header)
data['y'] = y
data.describe()
CRIMZNINDUSCHASNOXRMAGEDISRADTAXPTRATIOBLSTATy
count506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000506.000000
mean3.59376111.36363611.1367790.0691700.5546956.28463468.5749013.7950439.549407408.23715418.455534356.67403212.65306322.532806
std8.59678323.3224536.8603530.2539940.1158780.70261728.1488612.1057108.707259168.5371162.16494691.2948647.1410629.197104
min0.0063200.0000000.4600000.0000000.3850003.5610002.9000001.1296001.000000187.00000012.6000000.3200001.7300005.000000
25%0.0820450.0000005.1900000.0000000.4490005.88550045.0250002.1001754.000000279.00000017.400000375.3775006.95000017.025000
50%0.2565100.0000009.6900000.0000000.5380006.20850077.5000003.2074505.000000330.00000019.050000391.44000011.36000021.200000
75%3.64742312.50000018.1000000.0000000.6240006.62350094.0750005.18842524.000000666.00000020.200000396.22500016.95500025.000000
max88.976200100.00000027.7400001.0000000.8710008.780000100.00000012.12650024.000000711.00000022.000000396.90000037.97000050.000000
data.pivot_table(index='CHAS', values='y')
y
CHAS
0.022.093843
1.028.440000
data['DIS'].plot.box()

<matplotlib.axes._subplots.AxesSubplot at 0x2d7838dc5c0>

在这里插入图片描述

# 判断每个字段与房价之间的关系
data.plot.scatter(x='RM', y='y')

<matplotlib.axes._subplots.AxesSubplot at 0x2d78388b240>

在这里插入图片描述

训练回归模型，预测房屋价格

  1. 整理数据集（输入集、输出集）
  2. 打乱数据集，拆分测试集、训练集。
  3. 选择模型，使用训练集训练模型，用测试集测试。
# 整理数据集（输入集、输出集）
x, y = data.iloc[:, :-1], data['y']
# 打乱数据集。  su:  sklearn.utils
# random_state：随机种子。 若两次随机操作使用的随机种子相同，则随机结果也相同。
x, y = su.shuffle(x, y, random_state=7)
# 拆分测试集、训练集。
train_size = int(len(x) * 0.9)
train_x, test_x, train_y, test_y = \
    x[:train_size], x[train_size:], y[:train_size], y[train_size:]
train_x.shape, test_x.shape, train_y.shape, test_y.shape

((455, 13), (51, 13), (455,), (51,))

决策树回归

import sklearn.tree as st
import sklearn.metrics as sm
# 决策树回归模型，使用训练集训练模型，用测试集测试。
model = st.DecisionTreeRegressor(max_depth=4)
model.fit(train_x, train_y)  # 针对训练集数据进行训练
pred_test_y = model.predict(test_x)  # 针对测试集数据进行测试
print(sm.r2_score(test_y, pred_test_y))
print(sm.mean_absolute_error(test_y, pred_test_y))

# 输出单棵决策树的特征重要性指标
fi = model.feature_importances_
print(fi)
print(header)


0.678829897847864
2.923060066720631
[0.04992925 0.         0.         0.         0.02788393 0.62987544
 0.00067595 0.0908006  0.         0.         0.00415868 0.
 0.19667614]
['CRIM' 'ZN' 'INDUS' 'CHAS' 'NOX' 'RM' 'AGE' 'DIS' 'RAD' 'TAX' 'PTRATIO'
 'B' 'LSTAT']

import graphviz
dot_data = st.export_graphviz(model,out_file=None,feature_names= header)
graph = graphviz.Source(dot_data)
graph

在这里插入图片描述

正向激励

import sklearn.ensemble as se

# AdaBoost回归模型，使用训练集训练模型，用测试集测试。
# 调整参数
# params1 = [6, 7]
# params2 = [50, 100, 150, 200]

# for p1 in params1:
#     for p2 in params2:
#         model = st.DecisionTreeRegressor(max_depth=p1)
#         model = se.AdaBoostRegressor(model, n_estimators=p2, random_state=7)
#         model.fit(train_x, train_y)  # 针对训练集数据进行训练
#         pred_test_y = model.predict(test_x)  # 针对测试集数据进行测试
#         print('max_depth:', p1, '  n_estimators:', p2)
#         print(sm.r2_score(test_y, pred_test_y))
#         print(sm.mean_absolute_error(test_y, pred_test_y))

model = st.DecisionTreeRegressor(max_depth=6)
model = se.AdaBoostRegressor(model, n_estimators=100, random_state=7)
model.fit(train_x, train_y)  # 针对训练集数据进行训练
pred_test_y = model.predict(test_x)  # 针对测试集数据进行测试
print(sm.r2_score(test_y, pred_test_y))
print(sm.mean_absolute_error(test_y, pred_test_y))       
# 输出单棵决策树的特征重要性指标
fi = model.feature_importances_
print(fi)
print(header)
# 特征重要性可视化
s = pd.Series(fi, index=header)
s.sort_values().plot.barh()

0.8814458900728809
2.060418077972981
[0.03474378 0.00092137 0.00581656 0.00102895 0.03494231 0.23408824
 0.01790326 0.10480302 0.00889913 0.02894075 0.03176375 0.01503917
 0.48110971]
['CRIM' 'ZN' 'INDUS' 'CHAS' 'NOX' 'RM' 'AGE' 'DIS' 'RAD' 'TAX' 'PTRATIO'
 'B' 'LSTAT']


<matplotlib.axes._subplots.AxesSubplot at 0x2d786e57400>

在这里插入图片描述

GBDT

model = se.GradientBoostingRegressor(
    max_depth=6, n_estimators=1000, min_samples_split=15)
model.fit(train_x, train_y)
pred_test_y = model.predict(test_x)
print(sm.r2_score(test_y, pred_test_y))
print(sm.mean_absolute_error(test_y, pred_test_y))

0.9293816082262505
1.610908989775633

随机森林

model = se.RandomForestRegressor(
    max_depth=10, n_estimators=1000, min_samples_split=4)
model.fit(train_x, train_y)
pred_test_y = model.predict(test_x)
print(sm.r2_score(test_y, pred_test_y))
print(sm.mean_absolute_error(test_y, pred_test_y))

0.8977117124659044
1.9161244706102394

案例：共享单车投放量分析与预测

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import sklearn.preprocessing as sp
import sklearn.utils as su
import sklearn.linear_model as lm
import sklearn.tree as st
import sklearn.ensemble as se
import sklearn.metrics as sm

# 加载共享单车数据集，完成基本数据分析
data = pd.read_csv('../data/bike_day.csv')
# 特征工程，删除不必要的特征
data = data.drop(['instant', 'dteday', 'casual', 'registered'], axis=1)
data.describe()
seasonyrmnthholidayweekdayworkingdayweathersittempatemphumwindspeedcnt
count731.000000731.000000731.000000731.000000731.000000731.000000731.000000731.000000731.000000731.000000731.000000731.000000
mean2.4965800.5006846.5198360.0287282.9972640.6839951.3953490.4953850.4743540.6278940.1904864504.348837
std1.1108070.5003423.4519130.1671552.0047870.4652330.5448940.1830510.1629610.1424290.0774981937.211452
min1.0000000.0000001.0000000.0000000.0000000.0000001.0000000.0591300.0790700.0000000.02239222.000000
25%2.0000000.0000004.0000000.0000001.0000000.0000001.0000000.3370830.3378420.5200000.1349503152.000000
50%3.0000001.0000007.0000000.0000003.0000001.0000001.0000000.4983330.4867330.6266670.1809754548.000000
75%3.0000001.00000010.0000000.0000005.0000001.0000002.0000000.6554170.6086020.7302090.2332145956.000000
max4.0000001.00000012.0000001.0000006.0000001.0000003.0000000.8616670.8408960.9725000.5074638714.000000
# 离散型特征数值分析
data['weathersit'].value_counts()

1    463
2    247
3     21
Name: weathersit, dtype: int64

data.pivot_table(index='weathersit', values='cnt')
cnt
weathersit
14876.786177
24035.862348
31803.285714
data.pivot_table(index='workingday', values='cnt')
cnt
workingday
04330.168831
14584.820000
data.pivot_table(index='weekday', values='cnt')
cnt
weekday
04228.828571
14338.123810
24510.663462
34548.538462
44667.259615
54690.288462
64550.542857
# 连续型特征数值分析
data[['temp', 'atemp', 'hum', 'windspeed']].plot.box()

<matplotlib.axes._subplots.AxesSubplot at 0x2161e29dfd0>

在这里插入图片描述

训练机器学习模型，预测共享单车使用量
# 1. 整理输入集x 与 输出集y
x, y = data.iloc[:, :-1], data['cnt']
x.shape, y.shape

# 2. 拆分测试集与训练集
x, y = su.shuffle(x, y, random_state=7)
train_size = int(len(x) * 0.9)
train_x, test_x, train_y, test_y = \
    x[:train_size], x[train_size:], y[:train_size], y[train_size:]

# 3. 选择模型，训练模型
model = se.RandomForestRegressor(
    max_depth=10, n_estimators=1000, min_samples_split=3)
model.fit(train_x, train_y)

# 预测
pred_train_y = model.predict(train_x)
pred_test_y = model.predict(test_x)

# 4. 评估模型
print('train r2 score:', sm.r2_score(train_y, pred_train_y))
print('test  r2 score:', sm.r2_score(test_y, pred_test_y))

train r2 score: 0.9773682034502736
test  r2 score: 0.891479300161597

# 输出特征重要性
fi = model.feature_importances_
header = x.columns
s = pd.Series(fi, index=header)
s.sort_values().plot.barh()

<matplotlib.axes._subplots.AxesSubplot at 0x216204655c0>

在这里插入图片描述

以hour为单位的共享单车投放量预测
# 加载共享单车数据集，完成基本数据分析
data = pd.read_csv('../data/bike_hour.csv')
# 特征工程，删除不必要的特征
data = data.drop(['instant', 'dteday', 'casual', 'registered'], axis=1)
# 1. 整理输入集x 与 输出集y
x, y = data.iloc[:, :-1], data['cnt']
x.shape, y.shape

# 2. 拆分测试集与训练集
x, y = su.shuffle(x, y, random_state=7)
train_size = int(len(x) * 0.9)
train_x, test_x, train_y, test_y = \
    x[:train_size], x[train_size:], y[:train_size], y[train_size:]

# 3. 选择模型，训练模型
model = se.RandomForestRegressor(
    max_depth=10, n_estimators=1000, min_samples_split=3)
model.fit(train_x, train_y)

# 预测
pred_train_y = model.predict(train_x)
pred_test_y = model.predict(test_x)

# 4. 评估模型
print('train r2 score:', sm.r2_score(train_y, pred_train_y))
print('test  r2 score:', sm.r2_score(test_y, pred_test_y))

train r2 score: 0.9420587049496375
test  r2 score: 0.9185966492961931

# 输出特征重要性
fi = model.feature_importances_
header = x.columns
s = pd.Series(fi, index=header)
s.sort_values().plot.barh()

<matplotlib.axes._subplots.AxesSubplot at 0x21620685550>

在这里插入图片描述

分类模型：鸢尾花数据集

import numpy as np
import pandas as pd
import sklearn.datasets as sd

# 加载鸢尾花数据集
iris = sd.load_iris()
# 简单封装并分析
data = pd.DataFrame(iris.data, columns=iris.feature_names)
data['target'] = iris.target
data.describe()
sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)target
count150.000000150.000000150.000000150.000000150.000000
mean5.8433333.0540003.7586671.1986671.000000
std0.8280660.4335941.7644200.7631610.819232
min4.3000002.0000001.0000000.1000000.000000
25%5.1000002.8000001.6000000.3000000.000000
50%5.8000003.0000004.3500001.3000001.000000
75%6.4000003.3000005.1000001.8000002.000000
max7.9000004.4000006.9000002.5000002.000000
# 分析不同类别下鸢尾花其他属性特征的规律
data.pivot_table(index='target')
petal length (cm)petal width (cm)sepal length (cm)sepal width (cm)
target
01.4640.2445.0063.418
14.2601.3265.9362.770
25.5522.0266.5882.974
data.plot.scatter(x='sepal length (cm)', y='sepal width (cm)', 
                 c='target', cmap='brg')

<matplotlib.axes._subplots.AxesSubplot at 0x17de30ff080>

在这里插入图片描述

data.plot.scatter(x='petal length (cm)', y='petal width (cm)', 
                 c='target', cmap='brg')

<matplotlib.axes._subplots.AxesSubplot at 0x17de324ff28>

在这里插入图片描述

# 整理一组简单数据，训练逻辑回归模型，完成分类业务。

import sklearn.utils as su
import sklearn.linear_model as lm

sub_data = data.tail(150)
# 整理输入集与输出集
x, y = sub_data.iloc[:, :-1], sub_data['target']
# 拆分测试集与训练集
x, y = su.shuffle(x, y, random_state=7)
train_size = 70
train_x, test_x, train_y, test_y = \
    x[:train_size], x[train_size:], y[:train_size], y[train_size:]
# 训练模型，并使用测试数据评估模型
model = lm.LogisticRegression()
model.fit(train_x, train_y)
pred_test_y = model.predict(test_x)
# 对于分类结果的评估：
(pred_test_y==test_y).sum() / test_y.size

0.975

import matplotlib.pyplot as plt
x = np.linspace(-10, 10, 200)
y = 1 / (1 + np.exp(-x))
plt.grid(linestyle=':')
plt.plot(x, y)

[<matplotlib.lines.Line2D at 0x17de33d4358>]

在这里插入图片描述

data[['petal length (cm)', 'target']].head(100).plot.scatter(x='petal length (cm)', y='target')

<matplotlib.axes._subplots.AxesSubplot at 0x17de33fd128>

在这里插入图片描述

YEGE学AI算法
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
机器学习算法_DT_决策树模型案例2_基于sklearn接口的回归
佐少的博客
04-20 403
机器学习算法_DT_决策树模型案例2_基于sklearn接口的回归1、导入功能模块函数2、建模2.1、导入测试数据数据集2.2、划分测试集-训练集-验证集2.3、模型训练，测试调参，外延测试2.3.1、设置模型参数2.3.2、模型训练3、模型预测与评估3.1、模型预测3.2、模型评估 1、导入功能模块函数 from sklearn.datasets import load_boston from ...
决策树（Decision Tree，DT）
Michael是个半路程序员
03-12 3687
决策树（decision tree）是一种基本的分类与回归方法。 分类问题中，基于特征对实例进行分类的过程。 优点：模型具有可读性，分类速度快。 学习：利用训练数据，根据损失函数最小化的原则建立决策树模型。 预测：对新的数据，利用决策树模型进行分类。 决策树学习通常包括3个步骤：特征选择、决策树生成、决策树修剪。 Quinlan在1986年提出的ID3算法、1993年提出的C4.5算法 Breiman等人在1984年提出的CART算法
DBDT 基于不同损失函数的算法推导细节
格物致知
10-22 1667
Freidman提出了梯度提升算法，该方法是利用最速下降法的近似方法，其关键是利用损失函数的负梯度在当前模型的值 −[∂L(y,f(xi))∂f(xi)]f(x)=fm−1(x)-[{\partial L(y,f(x_i)) \over \partial f(x_i)}]_{f(x) = f_{m-1}(x)}作为回归问题算法中的残差的近似值，拟合一个回归模型。其算法流程如下： 1. F0(x)
机器学习笔记01 -- 决策树、随机森林、AdaBoost
WANFANQ的博客
05-30 231
一、决策树 1 决策树的优化：剪枝 1.1 预剪枝： 每个节点在进行划分时进行估计，看该节点进行划分前后是否可以带来泛化能力上的提升，如果不能，则直接标记为叶子节点。 1.2 后剪枝： 生成完整的决策树后，再自下而上去评估每个非叶子节点的划分是否带来了泛化能力的提升，如果不能，则将该节点的子树替换为叶子节点。 要用验证集数据来判断。 2 属性划分纯度变化的计算方法 2.1 信息增益 – ID3 X：样本类别；A：一种特征 x：一种类别；a：A特征划分后的一个分支 熵：事件X发生概率p(x)的倒数取对数 信息
调用sklearn库实现随机森林及AdaBoost
weixin_41857483的博客
11-07 1507
1. 随机森林 1.1 原理介绍 随机森林(Random Forest)是一种遵循bagging技术的集成机器学习算法。 Bagging算法 （英语：Bootstrap aggregating，引导聚集算法），又称装袋算法，是机器学习领域的一种团体学习算法。最初由Leo Breiman于1994年提出。Bagging算法可与其他分类、回归算法结合，提高其准确率、稳定性的同时，通过降低结果的方差，避免过拟合的发生。 给定一个大小为n的训练集 D，Bagging算法从中均匀、有放回地（即使用自助抽样法）选出m
机器学习中的算法：决策树模型组合之GBDT
02-25
本文来自于csdn，本文从informationgain和决策树两个方面介绍了机器学习的算法，希望对您的学习有帮助。决策树这种算法有着很多良好的特性，比如说训练时间复杂度较低，预测的过程比较快速，模型容易展示（容易将...
传统机器学习分类算法python实现源码集合(KNN决策树贝叶斯随机森林SVM等).zip
03-13
传统机器学习分类算法python实现源码集合(KNN决策树贝叶斯随机森林SVM等).zip 传统机器学习分类算法 1.KNN 2.朴素贝叶斯 3.决策树 4.Adaboost 5.模型评估与选择 6.SVM 传统机器学习分类算法python实现源码集合(KNN...
机器学习与算法源代码4： 逻辑回归模型.zip
05-18
逻辑回归是一种广泛应用于分类问题的统计学模型，尤其在机器学习领域中占据着重要的地位。本资料包聚焦于逻辑回归模型的源代码实现，旨在帮助读者深入理解逻辑回归的工作原理并掌握其实现方法。 1. **逻辑回归简介*...
机器学习与算法源代码9： AdaBoost与GBDT模型.zip
05-18
在机器学习领域，AdaBoost和梯度提升决策树（Gradient Boosting Decision Tree，简称GBDT）是两种广泛应用且强大的算法，它们在数据挖掘、预测分析和模式识别中扮演着重要角色。这两个模型都是集成学习（Ensemble ...
机器学习-决策树（以西瓜数据集为例）
最新发布
03-30
决策树是一种广泛应用于机器学习领域的算法，它通过创建分层的决策模型来预测目标变量。在本案例中，我们将深入探讨如何使用决策树处理“西瓜数据集”。这个数据集是用于教学目的的理想选择，因为它包含了多个特征，...
机器学习七之随机森林、Adaboost、GBDT
Silimere
03-14 578
目录 十七、随机森林、Adaboost、GBDT、XGBoost、LightBGM 一、随机森林 二、Adaboost 三、GBDT (梯度提升树) 四、GBDT和随机森林 十七、随机森林、Adaboost、GBDT 一、随机森林 随机森林在使用CART决策树作为弱学习器的基础上，决策树的建立做了改进，对于普通的决策树，我们会在节点上所有的n个样本特...
机器学习(七)随机森林,GBDT,Adaboost
黑洲非人lyf
04-04 1484
Bagging（装袋） Bagging的策略: （1）从样本集中重采样（有重复的）选出n个样本； （2）在所有属性上，对这n个样本建立分类器（ID3、C4.5、CART、SVM、Logistic回归等）； （3）重复以上两步m次，即获得了m个分类器； （4）将数据放在这m个分类器上，最后根据这m个分类器的投票结果，决定数据属于哪一类。 疑问1：n的值如何选择？ 疑问2：m的值如何选择...
【集成学习】【随机森林】【AdaBoost、GBDT】
zyuPp的博客
04-06 1129
随机森林、AdaBoost、GBDT、XGBoost、LightGBM、CatBoost 组合分类器 思想：将多个分类器的结果进行多票表决或取平均值，以此作为最终的结果。 好处： 提升模型精度，整合各个分类器结果，得到更合理的决策边界，减少整体错误 处理较大数据集，可以划分多个子集，对子集构建分类器；处理较小数据集，通过自助采样boostrap产生多个数据集，构建分类器 当决策边界比较复杂...
bagging、boosting，adaboost，随机森林和GBDT
MrLQD
04-09 823
关于采样： bagging:总的训练样本个数P，每次随机抽取N（N<=P）个样本做训练集，训练完了把N个样本重新放回总样本中。显然当前抽取的样本的某些样本可能与前一次抽取的某些样本是相同的。如果有M个分类器（需要训练M次），则抽取M次。 boosting：总的训练样本个数P，每次用全部样本做训练集，每个样本人为的赋于一个权重。 样例权重： Bagging：使用均匀取样，每个样例的权重...
常用决策树集成模型Random Forest、Adaboost、GBDT详解
qq_34184505的博客
06-29 897
常用的集成学习策略 在之前的文章我有介绍过常用的基本决策树模型ID3、C4.5、CART算法，其中提到了一个关于基本决策树模型的缺点，那就是决策树模型学习一棵最优的决策树被认为是NP-Complete问题。实际中的决策树是基于启发式的贪心算法建立的，这种算法不能保证建立全局最优的决策树，Random Forest 引入随机能缓解这个问题。 那么什么是Random Forest呢？其实这正是今天首先要介绍的集成学习框架的一种，常见的集成学习框架有三种：Bagging，Boosting 和 Stacking。三
决策树 随机森林 xgboost_AdaBoost、GBDT、RF、XGboost、LightGBM的对比分析
weixin_39591720的博客
11-23 717
AdaBoost简单介绍AdaBoost是基于boosting的思想，通过多个弱分类器的线性组合来得到强分类器，训练时重点关注被错分的样本，准确率高的弱分类器权重大。更深一步的介绍在训练过程中，它不改变所给的训练数据，而是不断改变训练数据权值的分布，使得被误分类的数据再后一轮的分类中受到更大的关注。同时采用加权多数表决的方法，加大分类误差率小的弱分类器的权值，使其在最后的表决中起更大的作用，减小分...
理解GBDT算法（一）——理论
热门推荐
bigfacesafdasgfewgf
12-16 2万+
这篇讲到的GBDT的基本思想是“积跬步以至千里”！也就是说我每次都只学习一点，然后一步步的接近最终要预测的值（完全是gradient的思想~）。换句话来说，我们先用一个初始值来学习一棵决策树，叶子处可以得到预测的值，以及预测之后的残差，然后后面的决策树就要基于前面决策树的残差来学习，直到预测值和真实值的残差为零。最后对于测试样本的预测值，就是前面许多棵决策树预测值的累加。整个过程都是每次学习一点（真实值的一部分），最后累加，所以叫做“积跬步以至千里”！
机器学习-决策树
m0_51298665的博客
05-28 173
决策树 sklearn建模的基本流程 拟合度 拟合度可简单理解为模型对于数据集背后客观规律的掌握程度，模型对于给定数据集如果拟合度较差，则对规律的捕捉不完全，用作分类和预测时可能准确率不高，换句话说，当模型把训练样本学得"太好"了的时候，很可能已经把训练样本自身的一些特点当作了所有潜在样本的普遍性质，这时候所选的模型的复杂度往往会比真模型更高，这样就会导致泛化性能下降。这种现象称为过拟合（overfitting）；欠拟合（underfitting），是指模型学习能力低下，导致对训练样本的一般性质尚未学好。
机器学习算法（2）——AdaBoost算法
知识搬运工的博客
01-18 1843
Boosting算法 提升算法/Boosting是一种提高弱分类器准确度的方法。 通常在分类问题中，boosting通过改变训练样本的权重，学习多个分类器，并将这些分类器线性组合，提高分类性能。一组弱分类器可以创建一个强大的分类器。 Boosting 就是通过组合许多弱分类器（只比随机选择好一点）来产生一个强大的分类器组。且弱分类器的设计简单没有太大计算量。 boost...
机器学习十大常用算法概览：决策树、随机森林、逻辑回归、SVM等
我们将对机器学习十大常用算法进行简介和总结，这些算法都是机器学习领域中常用的分类算法，包括决策树、随机森林算法、逻辑回归、支持向量机（SVM）、朴素贝叶斯、K最近邻算法、K均值算法、Adaboost算法、神经网络...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值