day02-决策树-人工分类-逻辑分类-朴素贝叶斯分类-
六、决策树
既可用于解决回归问题，也可用于解决分类问题。
1.原理：相似的输入必会产生相似的输出
年龄：0-青年，1-中年，2-老年
学历：0-大专，1-大本，2-硕士，3-博士
资历：0-小白，1-小牛，2-大牛，3-骨灰
性别：0-女性，1-男性
等级：0-低收入，1-中等收入，2-高收入
-------------------------------------
年龄 学历 资历 性别 月薪 等级
样本1 0 1 0 1 5000 0
样本2 0 0 1 1 8000 1
样本3 1 2 2 1 10000 2
...
-----------------------------------------------------
待预测 1 2 2 1 ？
回归问题：对输出做平均处理 \ 都可以结合特征的
分类问题：对输出做投票处理 / 相似程度做加权
信息熵：熵高能量就高，熵低能量就低。
香农定律
2.构建树状模型提高对相似输入的检索性能
依次选取总样本空间中的每一个特征作为划分子表的依据，将样本矩阵
划分为若干层级的多个子矩阵，每一个层级对应一个特征，组成树状结
构。预测时，根据待预测样本的每个特征值，找到与之对应的叶级子表，
将该子表的输出按照平均或者投票的方式计算预测值。
3.优先选择对输出影响最大的部分特征划分子表
根据按照某个特征划分子表前后，其信息熵或基尼不纯度的减少量来判
断该特征对输出的影响，信息熵或基尼不纯度减少量越大的特征，对输
出的影响也越大，越应该优先作为子表划分的依据。
4.集成算法
1)概念
也叫集合算法，或集合弱学习方法
其核心思想就是，通过平均或投票，将多个不同学习方法的结论加以综合，
给出一个相对可靠的预测结果。
所选择的弱学习方法，在算法或数据上应该具备足够分散性，以体现相对
不同的倾向性，这样得出的综合结论才能够更加泛划和代表性。
2)基于决策树的集合算法，就是按照某种规则，构建多颗彼此不同的决策树
模型，分别给出针对未知样本的预测结果，最后通过平均或投票得到相对
综合的结论。
3)根据构建多颗决策树的规则不同，基于决策树的集合算法可分为:
1)自助聚合：每次从总样本空间中随机抽取一部分样本构建决策树，这
样共构建B棵决策树。
从原始训练样本中，以有放回或无放回抽样的方式，随机选取部分样本，
构建一颗决策树，重复以上过程，得到若干颗决策树，以此弱化某些强
势样本对预测结果的影响力，提高模型精度
2)随机森林：每次从总样本空间中随机抽取一部分样本及特征构建决策树，
这样共构建B棵决策树。
如果在自助聚合的基础上，每次构建决策树时，不但随机选择样本(行)，
而且特征(列)也是随机选择的，则称为随机森林。
3)正向激励：为样本空间中的每个样本分配初始权重，构建第一颗决策树，
针对训练集中预测错误的样本，提升其权重，再构建第二棵决策树，以此
类推，共构建B棵权重各不相同的决策树
首先为训练样本分配相等的权重，构建第一颗决策树，用该决策树对训练
样本进行预测，为预测错误的样本提升权重，再次构建下一颗决策树，
以此类推，得到针对每个样本拥有不同权重的多颗决策树。
代码示例：house.py
import sklearn.datasets as sd #标准数据集，来自实际数据的整合
import sklearn.utils as su #实用辅助工具
import sklearn.tree as st #决策树等
import sklearn.ensemble as se #集合处理、正向激励等
import sklearn.metrics as sm #量化评估
#load_boston（）美国波士顿的房价数据，关注哪些因素对房价的影响，并对房价预测
boston = sd.load_boston()
#print(boston.feature_names)#有13个特征名，表明这13个特征影响了房价
#'CRIM'犯罪率 'ZN'房屋密度(容积率) 'INDUS'商用土地比例(反映商业繁华程度)
#'CHAS'查理斯河空变量(如果边界是河流,则为1;否则为0) 'NOX'一氧化氮浓度(空气质量)
#'RM'住宅平均房间数 'AGE'1940 年之前建成的自用房屋比例。
# 'DIS'到波士顿五个中心区域的加权距离。 'RAD'路网密度。
# 'TAX'每 10000 美元的全值财产税率。 'PTRATIO'城镇师生比例。
# 'B' 指代城镇中黑人的比例 'LSTAT'人口中地位低下者(人口素质)的比例。 '
# MEDV'自住房的平均房价，以千美元计。
#print(boston.data.shape)#(506, 13)有506个样本地区，13个特征
#print(boston.data.shape)#每个地区的平均房价
#shuffle洗牌打乱，生成随机序列 boston.data 相当于x
#boston.data相当于y，random_state指定随机种子，
x,y = su.shuffle(boston.data,boston.target,random_state=7)#与原来的区别是顺序打乱了
train_size = int(len(x) * 0.8 ) #80%用于训练的比例，这个比例最低不能小于50%
#将506条样本分成两块，一块用于训练数据，一块用于测试数据，要不然数据不够用。
#train_x,train_y 训练数据
#test_x,test_y 测试数据
train_x,test_x,train_y,test_y =x[:train_size],x[train_size:],\
y[:train_size],y[train_size:]
#使用决策树方式
model1 = st.DecisionTreeRegressor(max_depth=5) #决策树回归器,max_depth深度，选择5层
#print(train_x.shape,train_y.shape)
model1.fit(train_x,train_y) #进行训练
pred_test_y = model1.predict(test_x) #用测试值去获得预测值
print(sm.r2_score(test_y,pred_test_y)) #比较实际数据test_y 和测试数据的差异，越接近于1，越相似。
#使用基于决策树的正向激励方式,AdaBoostRegressor正向激励回归器
model2 = se.AdaBoostRegressor(model1,
n_estimators=400,#n_estimators评估器，构建400颗
random_state=7)#random_state随机种子
model2.fit(train_x,train_y) #进行训练
pred_test_y = model2.predict(test_x)#获得预测值
#比较实际数据test_y 和测试数据的差异，
print(sm.r2_score(test_y,pred_test_y))#可看到分值由0.84提高到0.91
5.特征重要性
概念：
决策树模型在确定子表划分依据的过程中，会计算按照每个特征划分子表
所引起的信息熵或基尼不纯度减少量，从业务上看该指标即体现了，每个
特征对输出的影响力度。
决策树模型在确定划分子表优先选择特征的过程中，需要根据最大熵减
原则，确定划分子表的依据，因此，作为学习模型的副产品，可以得到
每个特征对于输出的影响力度，即特征重要性。
来自熵减变化量
model.feature_importances_
注：创建模型时，如果以"_"结尾，一般都是输出属性。
代码示例一：fi.py波士顿房价特征分析
import sklearn.datasets as sd #标准数据集，来自实际数据的整合
import sklearn.utils as su #实用辅助工具
import sklearn.tree as st #决策树等
import sklearn.ensemble as se #集合处理、正向激励等
import matplotlib.pyplot as mp
import numpy as np
#load_boston（）美国波士顿的房价数据，关注哪些因素对房价的影响，并对房价预测
boston = sd.load_boston()
feature_name = boston.feature_names #获得13个特征名称
x,y = su.shuffle(boston.data,boston.target,random_state=7)#与原来的区别是顺序打乱了
train_size = int(len(x) * 0.8 ) #80%用于训练的比例，这个比例最低不能小于50%
#将506条样本分成两块，一块用于训练数据，一块用于测试数据，要不然数据不够用。
train_x,test_x,train_y,test_y =x[:train_size],x[train_size:],\
y[:train_size],y[train_size:]
#使用决策树方式
model1 = st.DecisionTreeRegressor(max_depth=5) #决策树回归器,max_depth深度，选择5层
model1.fit(train_x,train_y) #进行训练
fi_dt = model1.feature_importances_ #获得重要性特征，必须经过训练后才能获取
#正向激励回归器
model2 = se.AdaBoostRegressor(model1,
n_estimators=400,#n_estimators评估器，构建400颗
random_state=7)#random_state随机种子
model2.fit(train_x,train_y) #进行训练
fi_ab = model2.feature_importances_ #获得重要性特征
mp.figure('Feature Importance',facecolor='lightgray')
mp.subplot(211)
#绘制重要性特征直方图
mp.title('Decision Tree', fontsize=16)
#mp.xlabel('Feature', fontsize=14)
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_name[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_name[sorted_indices], rotation=30)
mp.tight_layout()
mp.show()
特征重要性与模型的算法有关，还与数据的采集密度有关。
代码示例二：bike.py影响共享单车投放的因素
import csv
import numpy as np
import matplotlib.pyplot as mp
import sklearn.utils as su
import sklearn.metrics as sm
import sklearn.ensemble as se
#按天采样:按随机森林回归，基于天的数据集的重要性特征
with open('../../day01/data/bike_day.csv','r') as f:
reader = csv.reader(f)
x, y = [],[]
for row in reader: #按列读取数据
x.append(row[2:13]) #将主要特征值列数据放在x
y.append(row[-1]) #将结果列数据放在y
fn_dy = np.array(x[0]) #每列的第一行为特征值名称，取出来单独存放
x = np.array(x[1:],dtype=float) #第一行以下为数据，单独存放到x
y = np.array(y[1:],dtype=float)
x,y = su.shuffle(x,y,random_state=7)#与原来的区别是顺序打乱了
train_size = int(len(x) * 0.9 ) #80%用于训练的比例，这个比例最低不能小于50%
#将样本分成两块，一块用于训练数据，一块用于测试数据
train_x,test_x,train_y,test_y =x[:train_size],x[train_size:],\
y[:train_size],y[train_size:]
#使用随机森林回归器RandomForestRegressor
model1 = se.RandomForestRegressor(
max_depth=10,n_estimators=1000,min_samples_split=2
) #min_samples_split子表最小样本数
model1.fit(train_x,train_y) #进行训练
fi_dy = model1.feature_importances_ #获得重要性特征
pred_test_y = model1.predict(test_x)
print(sm.r2_score(test_y,pred_test_y))
#按小时采样:按随机森林回归，基于小时的数据集的重要性特征
with open('../../day01/data/bike_hour.csv','r') as f:
reader = csv.reader(f)
x, y = [],[]
for row in reader: #按列读取数据
x.append(row[2:13]) #将主要特征值列数据放在x
y.append(row[-1]) #将结果列数据放在y
fn_hr = np.array(x[0]) #每列的第一行为特征值名称，取出来单独存放
x = np.array(x[1:],dtype=float)
y = np.array(y[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:]
#使用随机森林回归器RandomForestRegressor
model1 = se.RandomForestRegressor(
max_depth=10,n_estimators=1000,min_samples_split=2
) #min_samples_split子表最小样本数
model1.fit(train_x,train_y) #进行训练
fi_hr = model1.feature_importances_ #获得重要性特征
pred_test_y = model1.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.xlabel('Feature', fontsize=14)
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, fn_dy[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, fn_dy[sorted_indices], rotation=30)
mp.tight_layout()
mp.show()
6、回归问题汇总：
线性回归：lm.LinearRegression()
多项式回归：
多项式特征扩展器=sp.PolynomialFeatures(最高次幂)
线性回归器=lm.LinearRegression()
管线模型=pl.make_pipeline(多项式特征扩展器,线性回归器)
岭回归：
lm.Ridge(正则强度,fit_intercept=True)
fit_intercept
决策树回归：
st.DecisionTreeRegressor(max_depth=)
max_depth：决策树最大深度int or None, (default=None)
一般来说，数据少或者特征少的时候可以不管这个值。如果模型样本量多，
特征也多的情况下，推荐限制这个最大深度，具体的取值取决于数据的分布。
常用的可以取值2-100之间。常用来解决过拟合。
基于决策树的正向激励回归：
se.AdaBoostRegressor(决策树回归器,n_estimators=,random_state=)
n_estimators，评估器
在利用最大投票数或平均值来预测之前,你想要建立子树的数量。
较多的子树可以让模型有更好的性能，但同时让你的代码变慢。
你应该选择尽可能高的值，只要你的处理器能够承受的住，
因为这使你的预测更好更稳定。
random_state 随机种子
基于决策树的随机森林回归：
se.RandomForestRegressor(max_depth=,n_estimators=,min_samples_split=)
min_samples_split：内部节点再划分所需最小样本数
int, float, optional (default=2)
如果是int则取传入值本身作为最小样本数；如果是 float，则取ceil(min_samples_split * 样本数量)
的值作为最小样本数，即向上取整。
回归模型关注的是回归曲线，该曲线反映了输入数据和输出数据之间的函数关系。
对于分类问题，模型关注的是分类边界，边界线反映了不同类别之间的划分依据。
七、人工分类
引例
假设有两组输入x1,x2-->一组输出y
x1 x2 y
3 1 0
2 5 1
1 8 1
6 4 0
5 2 0
3 5 1
4 7 1
4 -1 0
可以观察发现：
如果 x1 > x2 --> y = 0
x1 < x2 --> y = 1
即就可以预测后面的输入
代码示例：simple.py通过mp绘制人工分类
import numpy as np
import matplotlib.pyplot as mp
x = np.array([ #x1,x2
[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])
#分类边界x1 = x2
#l 左边界，R 右边界，h 水平间隔步长
l, r, h = x[:, 0].min() - 1, x[:, 0].max() + 1, 0.005
#b 底边界，t 上边界，v 垂直间隔步长
b, t, v = x[:, 1].min() - 1, x[:, 1].max() + 1, 0.005
#np.arange(l, r, h) 点阵中水平坐标的序列
#np.arange(b, t, v) 点阵中垂直坐标的序列
#meshgrid(x, y) 网格化序列
grid_x = np.meshgrid(np.arange(l, r, h),np.arange(b, t, v))
#np.c_ & np.r_是 np.column_stack& np.row_stack 的缩写
#np.c_ & np.r_是直接对数组进行操作
#np.column_stack& np.row_stack是对数组的元组或者列表操作
flat_x = np.c_[grid_x[0].ravel(), grid_x[1].ravel()] #列合并
#zeros，先假设x数组对应的y为0
flat_y = np.zeros(len(flat_x), dtype=int)
flat_y[flat_x[:, 0] < flat_x[:, 1]] = 1 # 进行分类，创建掩码
grid_y = flat_y.reshape(grid_x[0].shape)
mp.figure('Simple Classification',
facecolor='lightgray')
mp.title('Simple Classification', fontsize=20)
mp.xlabel('x', fontsize=14)
mp.ylabel('y', fontsize=14)
mp.tick_params(labelsize=10)
#pcolormesh绘制分类点阵 如cmap='gray'， 0 是黑，1是白
mp.pcolormesh(grid_x[0], grid_x[1], grid_y, cmap='gray')
#使用二维平面坐标展示三元信息：
# x1放在x坐标，x2放在y坐标，分类信息用颜色表示
#分类特征的一般标准做法，特征较多，如4个以上，则不适合
mp.scatter(x[:, 0], x[:, 1], c=y, cmap='brg', s=80)
mp.tight_layout()
mp.show()
八、逻辑分类
1.引例：
将第七中的例子看成为以下模型
y = w0+w1x1+w2x2
逻辑分类就是将连续的预测值变为离散的预测值
即：[-∞, +∞]--->转为{0, 1}
2.逻辑函数：sigmoid(大写Σ小写σ)
σ(x) = 1 / (1 + e^(-x))
代码示例：sigmoid.py 逻辑函数图形展示
import numpy as np
import matplotlib.pyplot as mp
x = np.linspace(-100,100,1000) #线性分割
y = 1 / (1 + np.exp(-x)) #逻辑函数方程
mp.figure('Sigmoid',facecolor='lightgray')
mp.title('Sigmoid', fontsize=20)
mp.xlabel('x', fontsize=14)
mp.ylabel('y', fontsize=14)
mp.tick_params(labelsize=10)
mp.grid(linestyle=':')
mp.plot(x, y, c='dodgerblue')
mp.legend()
mp.tight_layout()
mp.show()
3.预测函数：
y = 1/(1+e^(-(w0+w1x1+w2x2)))
此过程一般称为非线性化过程
传统叫逻辑函数，神经网络中叫激活函数
即：非线性的激活函数达到非线性的输出，
用一个回归的网络来解决分类问题。
通过将预测函数的输出当作概率值进行分类，
选择概率大的类别作为判断
4.模块：
逻辑分类器：
import sklearn.linear_model as lm
model=lm.LogisticRegression(solver='liblinear', C=正则强度)
5.二元分类：
代码示例：log2.py
import numpy as np
import sklearn.linear_model as lm
import matplotlib.pyplot as mp
x = np.array([ #x1,x2
[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])
#逻辑分类器，solve指明e的指数部分的函数关系，这里为线性组合
model = lm.LogisticRegression(solver='liblinear',C=1)
model.fit(x,y) #进行训练
l, r, h = x[:, 0].min() - 1, x[:, 0].max() + 1, 0.005
b, t, v = x[:, 1].min() - 1, x[:, 1].max() + 1, 0.005
grid_x = np.meshgrid(np.arange(l, r, h),np.arange(b, t, v))
flat_x = np.c_[grid_x[0].ravel(), grid_x[1].ravel()] #列合并
flat_y = np.zeros(len(flat_x), dtype=int)#进行自动分类
flat_y = model.predict(flat_x)
grid_y = flat_y.reshape(grid_x[0].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[0], grid_x[1], grid_y, cmap='gray')
mp.scatter(x[:, 0], x[:, 1], c=y, cmap='brg', s=80)
mp.tight_layout()
mp.show()
6.多元分类：
通过多次二元分类的方式选择
代码示例：log3.py 多元分类
import numpy as np
import sklearn.linear_model as lm
import matplotlib.pyplot as mp
x = np.array([ #x1,x2
[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])
#逻辑分类器
#v 正则强度，适当增加强度可解决过拟合问题 如：由1到100
#可避免对训练样本的过渡依赖
model = lm.LogisticRegression(solver='liblinear',C=100)
model.fit(x,y) #进行训练
l, r, h = x[:, 0].min() - 1, x[:, 0].max() + 1, 0.005
b, t, v = x[:, 1].min() - 1, x[:, 1].max() + 1, 0.005
grid_x = np.meshgrid(np.arange(l, r, h),np.arange(b, t, v))
flat_x = np.c_[grid_x[0].ravel(), grid_x[1].ravel()] #列合并
flat_y = np.zeros(len(flat_x), dtype=int)#进行自动分类
flat_y = model.predict(flat_x)
grid_y = flat_y.reshape(grid_x[0].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)
#cmap='gray'时，黑0 灰1 白2
#如果某一样本明显靠近边界，则存在过拟合现象
mp.pcolormesh(grid_x[0], grid_x[1], grid_y, cmap='gray')
mp.scatter(x[:, 0], x[:, 1], c=y, cmap='brg', s=80)
mp.tight_layout()
mp.show()
九、朴素贝叶斯分类
1.引例
如某次外出遇见1000人，其中遇到美女10人
即遇到美女的概率 P1 = 10/1000 = 1%
10个中遇到一个一见钟情的浪漫故事，
在这个概率中为：P2 = 1/10 = 10%
实际总体概率为P：0.1%
即表示：P(一见钟情) = P(遇到美女|一见钟情)
=P1(遇到美女)*P2(一见钟情)
=P1 * P2
2.朴素贝叶斯定理
P(A|B)=( P(A)*P(B|A) )/P(B) ==>
P(A|B)*P(B)=P(A)*P(B|A) ==>
P(A,B) P(A,B)
将特定类别出现的概率与该类别出现时每一个特征值出现的概率取乘积，
以此表示该组特征值被归属为该类别的概率。
以此计算该组特征值被归属为每一个类别的概率，
择其最大的概率所对应的类别作为预测结果。
关于某个特征值在特定类别出现时的概率，
可以通过事先已知的概率密度函数或概率质量函数计算得到。
体现历史数据所表现出的统计规律，同时不存在对分类边界的线性约束，
但是对于统计规则不明且样本数量较少的场合不适用。
1万+
评论
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
查看更多评论
添加红包
