其他章节答案请参考我的汇总统计学习方法答案汇总,都是自己写的。
8.1、题目太长,懒得打字了
因为训练数据实例的维度比书中的例子8.1的实例的维度大,也就是特征的数目比较多,因而需要进行特征选择。我在这里根据数据集里面数据的权重进行特征选择的,如果按照原始数据进行原则,那么除了强制排除已经选择的特征,否则每次构造决策树桩,都只能选择相同的特征进行构造决策树桩,这显然是不合理的。
直接上代码:
import numpy as np
def choose_character_by_data_weight(X,Y,w):
'''
该方法使用数据的每次迭代的权重来选择特征,如果不使用数据的权重的话,每次计算出的特征都是相同的,将无法构造分类树桩
Parameters
----------
X : numpy array
训练数据.
Y : numpy array
数据标签.
w : numpy array
数据的权重.
Returns
-------
最佳的特征.
'''
s = np.shape(X)
char_nums = s[1] ## 特征的个数
## 下面开始计算H(D)
class_ = list(set(Y)) ## 类别集合
H_D = -sum([sum(np.where(Y == c, w, 0.0)) * np.log(sum(np.where(Y == c, w, 0.0))) for c in class_])
## 下面开始计算信息增益比
info_rate = []
for i in range(char_nums):
H_D_i = 0.0
char_i = list(set(X[:, i]))
for ch_i in char_i:
w1 = sum(np.where(X[:, i] == ch_i, w, 0.0))
for c in class_:
w2 = sum(np.where((X[:,i] == ch_i) * (Y == c), w, 0.0)) / w1
if w2 != 0.0:
H_D_i -= w1 * w2 * np.log(w2)
## 下面开始计算特征i的条件经验熵
H_i_D = -sum([sum(np.where(X[:, i] == ch, w, 0.0)) * np.log(sum(np.where(X[:, i] == ch, w, 0.0))) for ch in char_i])
info_rate.append((H_D - H_D_i) / H_i_D)
# print('2 is :', info_rate)
return info_rate.index(max(info_rate))
def create_Tree(X,Y,w):
#首先选择特征
char = choose_character_by_data_weight(X,Y,w) ## 根据权重选择特征
char_val = list(set(X[:, char])) ## 特征的取值
char_val = sorted(char_val)
## 下面开始确定选择特征char的取值才能是误差率最小
best_tree = None
best_loss = 2 ** 15
for i in range(len(char_val) - 1):## 只要循环特征char取值少一个就行啦
tree_i = [] # 使用一个列表表示一个二叉树桩,第0个元素是选择哪个特征来进行分类,第一个元素是决策元素,第二个元素表示当小于时的类别,第三个是大于时的类别
loss_i = 0
ch = (char_val[i] + char_val[i + 1]) / 2 #在已经排序好的特征取值中,取两个相邻特征的中间值就可以了,将其分为两类
# 下面根据数据权重计算损失并且确定决策树桩
Y1 = Y[X[:, char] < ch]
Y2 = Y[X[:, char] > ch]
W1 = w[X[:, char] < ch]
W2 = w[X[:, char] > ch]
n1 = list(set(Y1))
n2 = list(set(Y2))
tree_i.append(char)
tree_i.append(ch)
if len(n1) == 1:
## 此时说明只有一个类别,无需计算每个类别的损失,此时在这个子集上的分类误差是0
tree_i.append(Y1[0])
loss_i += 0
else:
## 此时说明Y1有两个类别,因为权重不是均衡的,不能按照数量的多少进行划分类别
loss_1 = sum(np.where(Y1 != 1, W1, 0)) ## 类别1的损失
loss_2 = sum(np.where(Y1 != -1, W1, 0)) ## 类别-1的损失
if loss_1 >= loss_2:
#此时说明应该取值为-1
tree_i.append(-1)
loss_i += loss_2
else:
tree_i.append(1)
loss_i += loss_1
if len(n2) == 1:
## 此时说明只有一个类别,无需计算每个类别的损失,此时在这个子集上的分类误差是0
tree_i.append(Y2[0])
loss_i += 0
else:
## 此时说明Y1有两个类别,因为权重不是均衡的,不能按照数量的多少进行划分类别
loss_1 = sum(np.where(Y2 != 1, W2, 0)) ## 类别1的损失
loss_2 = sum(np.where(Y2 != -1, W2, 0)) ## 类别-1的损失
if loss_1 >= loss_2:
#此时说明应该取值为-1
tree_i.append(-1)
loss_i += loss_2
else:
tree_i.append(1)
loss_i += loss_1
if loss_i < best_loss:
best_loss = loss_i
best_tree = tree_i
return best_tree, best_loss
def boost(X,Y):
init_w = np.array([0.1] * len(Y)) ## 初始的权重分类,使用原始数据训练一个决策树
all_tree = [] ## 用来存储生成的决策树
all_alpha = [] ## 存储每颗决策树的系数
while True:
tree_i, loss_i = create_Tree(X,Y,init_w) ## 生成一个决策树
alpha = 0.5 * np.log((1-loss_i) / loss_i)
all_tree.append(tree_i)
all_alpha.append(alpha)
## 下面开始计算已经得到决策树是否可以让训练的准确率足够高,这里使用完全正确分类来衡量是否跳出循环
acc = 0
for i in range(len(Y)):
x_i = X[i,:]
f = 0
y_true = Y[i]
for t in range(len(all_alpha)):
a_t = all_alpha[t]
tree_ = all_tree[t]
char = tree_[0]
seg = tree_[1]
label_1 = tree_[2]
label_2 = tree_[3]
if x_i[char] < seg:
f += a_t * label_1
else:
f += a_t * label_2
acc += int(np.sign(f) == y_true)
if (acc / len(Y)) == 1:
return all_tree, all_alpha
## 下面开始更新数据的权重
for i in range(len(Y)):
x_i = X[i,:]
y_true = Y[i]
char = tree_i[0]
seg = tree_i[1]
label1 = tree_i[2]
label2 = tree_i[3]
if x_i[char] < seg:
G = label1
else:
G = label2
init_w[i] = init_w[i] * np.exp(- alpha * y_true * G)
init_w = init_w / sum(init_w)
if __name__ == '__main__':
X = np.array([[0,1,3],
[0,3,1],
[1,2,2],
[1,1,3],
[1,2,3],
[0,1,2],
[1,1,2],
[1,1,1],
[1,3,1],
[0,2,1]])
Y = np.array([-1,-1,-1,-1,-1,-1,1,1,-1,-1])
tree, alpha = boost(X,Y)
2、比较支持向量机、AdaBoost、逻辑斯谛回归模型的学习策略与算法。
2.1、支持向量机的学习策略与算法
学习策略:
由目标函数函数可以看到,支持向量机的学习策略是结构风险极小化
算法有最大间隔方法、对偶算法、软间隔算法,emm,貌似对偶算法和软间隔算法是有相交关系的。
2.2、Adaboot模型的策略和算法
学习策略:经验风险极小化
学习算法:提升树算法等
2.3、逻辑斯谛回归的学习策略和算法
学习策略:经验风险极小化
算法:极大似然估计法