chapter11

README.md

@@ -2,18 +2,38 @@
 
 《**深度学习**》是深度学习领域唯一的综合性图书，全称也叫做**深度学习 AI圣经(Deep Learning)**，由三位全球知名专家IanGoodfellow、YoshuaBengio、AaronCourville编著，全书囊括了数学及相关概念的背景知识，包括线性代数、概率论、信息论、数值优化以及机器学习中的相关内容。同时，它还介绍了工业界中实践者用到的深度学习技术，包括深度前馈网络、正则化、优化算法、卷积网络、序列建模和实践方法等，并且调研了诸如自然语言处理、语音识别、计算机视觉、在线推荐系统、生物信息学以及视频游戏方面的应用。最后，深度学习全书还提供了一些研究方向，涵盖的理论主题包括线性因子模型、自编码器、表示学习、结构化概率模型、蒙特卡罗方法、配分函数、近似推断以及深度生成模型，适用于相关专业的大学生或研究生使用。
 
-<img src="./docs/cover.jpg" width="400" height="600" alt="深度学习封面" align=center>
+<img src="./docs/cover.jpg" width="200" height="300" alt="深度学习封面" align=center>
 
-可以下载《深度学习》的中文版[pdf](https://github.com/MingchaoZhu/DeepLearning/raw/master/DL%E4%B8%AD%E6%96%87.pdf)和英文版[pdf](https://github.com/MingchaoZhu/DeepLearning/raw/master/DL%E8%8B%B1%E6%96%87.pdf)直接阅读。
+可以下载《深度学习》的中文版 [pdf](https://github.com/MingchaoZhu/DeepLearning/raw/master/DL%E4%B8%AD%E6%96%87.pdf) 和英文版 [pdf](https://github.com/MingchaoZhu/DeepLearning/raw/master/DL%E8%8B%B1%E6%96%87.pdf) 直接阅读。
 
 ---
 
-《深度学习》可以说是深度学习与人工智能的入门宝典，许多算法爱好者、机器学习培训班、互联网企业的面试，很多都参考这本书。但本书晦涩，加上官方没有提供代码实现，因此某些地方较难理解。本站**基于数学推导和产生原理重新描述了书中的概念**，并用**Python** (numpy 库为主) 复现了书本内容（推导过程和代码实现均见**pdf文件**，重要部分的实现代码也放入**code文件夹**中）。
+《深度学习》可以说是深度学习与人工智能的入门宝典，许多算法爱好者、机器学习培训班、互联网企业的面试，很多都参考这本书。但本书晦涩，加上官方没有提供代码实现，因此某些地方较难理解。本站**基于数学推导和产生原理重新描述了书中的概念**，并用**Python** (numpy 库为主) 复现了书本内容 ( **源码级代码实现。推导过程和代码实现均放在了下载区的 pdf 文件中**，重要部分的实现代码也放入 **code 文件夹**中 )。
 
-然而我水平有限，但我真诚地希望这项工作可以帮助到更多人学习深度学习算法。我需要大家的建议和帮助。如果你在阅读中遇到有误或解释不清的地方，希望可以汇总你的建议，提issue （最好不要一个一个地提）。如果你也想加入这项工作书写中或有其他问题，可以联系我的邮箱：[email protected]。
+然而我水平有限，但我真诚地希望这项工作可以帮助到更多人学习深度学习算法。我需要大家的建议和帮助。如果你在阅读中遇到有误或解释不清的地方，希望可以汇总你的建议，提issue。如果你也想加入这项工作书写中或有其他问题，可以联系我的邮箱：[email protected]。
 
 写的过程中参考了较多网上优秀的工作，所有参考资源保存在了`reference.txt`文件中。
 
+# 作者留言
+
+最近收到了一些读者的催更邮件，感谢认可，但依旧想在此统一解释一下。每个章节的制作，从每一个概念的详细描述、原理推导、作图、代码实现到生成最终的 pdf 文件，需要时间。为了可以解释清楚，你在 pdf 文件中看到的所有的图几乎都是我自己画的。如果你在阅读过程中遇到有想要描述的概念点，可以发邮件告知我。这个项目的工作会一直更新完，不会咕。最后，如果你认可这份工作的话，希望可以 watch、star、fork 三连一下，或者在其他平台转发推广。非常感谢你的认可与推广，谢谢！ ——朱明超
+
+# 更新说明
+
+2020/3/：
+
+ 1. 修改第五章决策树部分，补充 ID3 和 CART 的原理，代码实现以 CART 为主。
+ 2. 第七章添加 L1 和 L2 正则化最优解的推导 (即 L1稀疏解的原理)。
+ 3. 第七章添加集成学习方法的推导与代码实现，包括 Bagging (随机森林)、Boosting (Adaboost、GBDT、XGBoost)
+ 4. 第八章添加牛顿法与拟牛顿法 (DFP、BFGS、L-BFGS) 的推导。
+ 5. 第十一章节添加高斯过程回归 (GPR) 与贝叶斯优化的推导与代码实现。
+
+后面每次的更新内容会统一放在 `update.txt` 文件中。
+
+# 章节目录与文件下载
+
+除了《深度学习》书中的概念点，**本项目也在各章节添加一些补充知识，例如第七章集成学习部分的 随机森林、Adaboost、GBDT、XGBoost 的原理剖析和代码实现等，又或者第十二章对当前一些主流方法的描述**。大的章节目录和 pdf 文件下载链接可以详见下表，而具体 pdf 文件中的实际目录请参考 `contents.txt`。
+
 | 中文章节 | 英文章节 | 下载<br />(含推导与代码实现) |
 | ------------ | ------------ | ------------ |
 | 第一章 前言 | 1 Introduction | |

code/chapter 11.py

@@ -0,0 +1,289 @@
+import pandas as pd
+import numpy as np
+import itertools
+import time
+import re
+from scipy.stats import norm
+import matplotlib.pyplot as plt
+
+
+def cal_conf_matrix(labels, preds):
+ """
+ 计算混淆矩阵。
+ 
+ 参数说明：
+ labels：样本标签 (真实结果)
+ preds：预测结果
+ """
+ n_sample = len(labels)
+ result = pd.DataFrame(index=range(0,n_sample),columns=('probability','label'))
+ result['label'] = np.array(labels)
+ result['probability'] = np.array(preds)
+ cm = np.arange(4).reshape(2,2)
+ cm[0,0] = len(result[result['label']==1][result['probability']>=0.5]) # TP，注意这里是以 0.5 为阈值
+ cm[0,1] = len(result[result['label']==1][result['probability']<0.5]) # FN
+ cm[1,0] = len(result[result['label']==0][result['probability']>=0.5]) # FP
+ cm[1,1] = len(result[result['label']==0][result['probability']<0.5]) # TN 
+ return cm
+
+
+def cal_PRF1(labels, preds):
+ """
+ 计算查准率P，查全率R，F1值。
+ """
+ cm = cal_conf_matrix(labels, preds)
+ P = cm[0,0]/(cm[0,0]+cm[1,0])
+ R = cm[0,0]/(cm[0,0]+cm[0,1])
+ F1 = 2*P*R/(P+R)
+ return P, R, F1
+
+
+def cal_PRcurve(labels, preds):
+ """
+ 计算PR曲线上的值。
+ """
+ n_sample = len(labels)
+ result = pd.DataFrame(index=range(0,n_sample),columns=('probability','label'))
+ y_pred[y_pred>=0.5] = 1
+ y_pred[y_pred<0.5] = 0
+ result['label'] = np.array(labels)
+ result['probability'] = np.array(preds)
+ result.sort_values('probability',inplace=True,ascending=False)
+ PandR = pd.DataFrame(index=range(len(labels)),columns=('P','R'))
+ for j in range(len(result)):
+ # 以每一个概率为分类的阈值，统计此时正例和反例的数量
+ result_j = result.head(n=j+1)
+ P = len(result_j[result_j['label']==1])/float(len(result_j)) # 当前实际为正的数量/当前预测为正的数量
+ R = len(result_j[result_j['label']==1])/float(len(result[result['label']==1])) # 当前真正例的数量/实际为正的数量
+ PandR.iloc[j] = [P,R]
+ return PandR
+
+
+def cal_ROCcurve(labels, preds):
+ """
+ 计算ROC曲线上的值。
+ """
+ n_sample = len(labels)
+ result = pd.DataFrame(index=range(0,n_sample),columns=('probability','label'))
+ y_pred[y_pred>=0.5] = 1
+ y_pred[y_pred<0.5] = 0
+ result['label'] = np.array(labels)
+ result['probability'] = np.array(preds)
+ # 计算 TPR,FPR
+ result.sort_values('probability',inplace=True,ascending=False)
+ TPRandFPR=pd.DataFrame(index=range(len(result)),columns=('TPR','FPR'))
+ for j in range(len(result)):
+ # 以每一个概率为分类的阈值，统计此时正例和反例的数量
+ result_j=result.head(n=j+1)
+ TPR=len(result_j[result_j['label']==1])/float(len(result[result['label']==1])) # 当前真正例的数量/实际为正的数量
+ FPR=len(result_j[result_j['label']==0])/float(len(result[result['label']==0])) # 当前假正例的数量/实际为负的数量
+ TPRandFPR.iloc[j]=[TPR,FPR]
+ return TPRandFPR
+
+
+def timeit(func):
+ """
+ 装饰器，计算函数执行时间
+ """
+ def wrapper(*args, **kwargs):
+ time_start = time.time()
+ result = func(*args, **kwargs)
+ time_end = time.time()
+ exec_time = time_end - time_start
+ print("{function} exec time: {time}s".format(function=func.__name__,time=exec_time))
+ return result
+ return wrapper
+
+@timeit
+def area_auc(labels, preds):
+ """
+ AUC值的梯度法计算
+ """
+ TPRandFPR = cal_ROCcurve(labels, preds)
+ # 计算AUC，计算小矩形的面积之和
+ auc = 0.
+ prev_x = 0
+ for x, y in zip(TPRandFPR.FPR,TPRandFPR.TPR):
+ if x != prev_x:
+ auc += (x - prev_x) * y
+ prev_x = x
+ return auc
+
+@timeit
+def naive_auc(labels, preds):
+ """
+ AUC值的概率法计算
+ """
+ n_pos = sum(labels)
+ n_neg = len(labels) - n_pos
+ total_pair = n_pos * n_neg # 总的正负样本对的数目
+ labels_preds = zip(labels, preds)
+ labels_preds = sorted(labels_preds,key=lambda x:x[1]) # 对预测概率升序排序
+ count_neg = 0 # 统计负样本出现的个数
+ satisfied_pair = 0 # 统计满足条件的样本对的个数
+ for i in range(len(labels_preds)):
+ if labels_preds[i][0] == 1:
+ satisfied_pair += count_neg # 表明在这个正样本下，有哪些负样本满足条件
+ else:
+ count_neg += 1
+ return satisfied_pair / float(total_pair)
+
+
+#####----Bayesian Hyperparameter Optimization----####
+class KernelBase(ABC):
+
+ def __init__(self):
+ super().__init__()
+ self.params = {}
+ self.hyperparams = {}
+
+ @abstractmethod
+ def _kernel(self, X, Y):
+ raise NotImplementedError
+
+ def __call__(self, X, Y=None):
+ return self._kernel(X, Y)
+
+ def __str__(self):
+ P, H = self.params, self.hyperparams
+ p_str = ", ".join(["{}={}".format(k, v) for k, v in P.items()])
+ return "{}({})".format(H["op"], p_str)
+
+ def summary(self):
+ return {
+ "op": self.hyperparams["op"],
+ "params": self.params,
+ "hyperparams": self.hyperparams,
+ }
+
+
+class RBFKernel(KernelBase):
+
+ def __init__(self, sigma=None):
+ """
+ RBF 核。
+ """
+ super().__init__()
+ self.hyperparams = {"op": "RBFKernel"}
+ self.params = {"sigma": sigma} # 如果 sigma 未赋值则默认为 np.sqrt(n_features/2)，n_features 为特征数。
+
+ def _kernel(self, X, Y=None):
+ """
+ 对 X 和 Y 的行的每一对计算 RBF 核。如果 Y 为空，则 Y=X。
+
+ 参数说明：
+ X：输入数组，为 (n_samples, n_features)
+ Y：输入数组，为 (m_samples, n_features)
+ """
+ X = X.reshape(-1, 1) if X.ndim == 1 else X
+ Y = X if Y is None else Y
+ Y = Y.reshape(-1, 1) if Y.ndim == 1 else Y
+ assert X.ndim == 2 and Y.ndim == 2, "X and Y must have 2 dimensions"
+ sigma = np.sqrt(X.shape[1] / 2) if self.params["sigma"] is None else self.params["sigma"]
+ X, Y = X / sigma, Y / sigma
+ D = -2 * X @ Y.T + np.sum(Y**2, axis=1) + np.sum(X**2, axis=1)[:, np.newaxis]
+ D[D < 0] = 0
+ return np.exp(-0.5 * D)
+
+
+class KernelInitializer(object):
+
+ def __init__(self, param=None):
+ self.param = param
+
+ def __call__(self):
+ r = r"([a-zA-Z0-9]*)=([^,)]*)"
+ kr_str = self.param.lower()
+ kwargs = dict([(i, eval(j)) for (i, j) in re.findall(r, self.param)])
+ if "rbf" in kr_str:
+ kernel = RBFKernel(**kwargs)
+ else:
+ raise NotImplementedError("{}".format(kr_str))
+ return kernel
+
+
+class GPRegression:
+ """
+ 高斯过程回归
+ """
+ def __init__(self, kernel="RBFKernel", sigma=1e-10):
+ self.kernel = KernelInitializer(kernel)()
+ self.params = {"GP_mean": None, "GP_cov": None, "X": None}
+ self.hyperparams = {"kernel": str(self.kernel), "sigma": sigma}
+
+ def fit(self, X, y):
+ """
+ 用已有的样本集合得到 GP 先验。
+
+ 参数说明：
+ X：输入数组，为 (n_samples, n_features)
+ y：输入数组 X 的目标值，为 (n_samples)
+ """
+ mu = np.zeros(X.shape[0])
+ Cov = self.kernel(X, X)
+ self.params["X"] = X
+ self.params["y"] = y
+ self.params["GP_cov"] = Cov
+ self.params["GP_mean"] = mu
+
+ def predict(self, X_star, conf_interval=0.95):
+ """
+ 对新的样本 X 进行预测。
+
+ 参数说明：
+ X_star：输入数组，为 (n_samples, n_features)
+ conf_interval：置信区间，浮点型 (0, 1)，default=0.95
+ """
+ X = self.params["X"]
+ y = self.params["y"]
+ K = self.params["GP_cov"]
+ sigma = self.hyperparams["sigma"]
+ K_star = self.kernel(X_star, X)
+ K_star_star = self.kernel(X_star, X_star)
+ sig = np.eye(K.shape[0]) * sigma
+ K_y_inv = np.linalg.pinv(K + sig)
+ mean = K_star @ K_y_inv @ y
+ cov = K_star_star - K_star @ K_y_inv @ K_star.T
+ percentile = norm.ppf(conf_interval)
+ conf = percentile * np.sqrt(np.diag(cov))
+ return mean, conf, cov
+
+
+class BayesianOptimization:
+
+ def __init__(self):
+ self.model = GPRegression()
+
+ def acquisition_function(self, Xsamples):
+ mu, _, cov = self.model.predict(Xsamples)
+ mu = mu if mu.ndim==1 else (mu.T)[0]
+ ysample = np.random.multivariate_normal(mu, cov) 
+ return ysample
+
+ def opt_acquisition(self, X, n_samples=20):
+ # 样本搜索策略，一般方法有随机搜索、基于网格的搜索，或局部搜索
+ # 我们这里就用简单的随机搜索，这里也可以定义样本的范围
+ Xsamples = np.random.randint(low=1,high=50,size=n_samples*X.shape[1])
+ Xsamples = Xsamples.reshape(n_samples, X.shape[1])
+ # 计算采集函数的值并取最大的值
+ scores = self.acquisition_function(Xsamples)
+ ix = np.argmax(scores)
+ return Xsamples[ix, 0]
+
+ def fit(self, f, X, y):
+ # 拟合 GPR 模型
+ self.model.fit(X, y)
+ # 优化过程
+ for i in range(15):
+ x_star = self.opt_acquisition(X) # 下一个采样点
+ y_star = f(x_star)
+ mean, conf, cov = self.model.predict(np.array([[x_star]]))
+ # 添加当前数据到数据集合
+ X = np.vstack((X, [[x_star]]))
+ y = np.vstack((y, [[y_star]]))
+ # 更新 GPR 模型
+ self.model.fit(X, y)
+ ix = np.argmax(y)
+ print('Best Result: x=%.3f, y=%.3f' % (X[ix], y[ix]))
+ return X[ix], y[ix] 
+