2020-10-19 21:18:53

docs/ml/1.md

 # 第1章 机器学习基础
 
-![机器学习基础_首页](http://data.apachecn.org/img/AiLearning/ml/1.MLFoundation/机器学习基础-首页.jpg)
+![机器学习基础_首页](img/机器学习基础-首页.jpg)
 
 ## 机器学习 概述
 
@@ -86,11 +86,11 @@
 这个算法可以训练程序做出某一决定。程序在某一情况下尝试所有的可能行动，记录不同行动的结果并试着找出最好的一次尝试来做决定。 属于这一类算法的有马尔可夫决策过程。
 ### 训练过程
 
-![机器学习训练过程图](http://data.apachecn.org/img/AiLearning/ml/1.MLFoundation/机器学习基础训练过程.jpg)
+![机器学习训练过程图](img/机器学习基础训练过程.jpg)
 
 ### 算法汇总
 
-![算法汇总](http://data.apachecn.org/img/AiLearning/ml/1.MLFoundation/ml_algorithm.jpg)
+![算法汇总](img/ml_algorithm.jpg)
 
 
 ## 机器学习 使用
@@ -104,7 +104,7 @@
 
 > 举例
 
-![选择算法图](http://data.apachecn.org/img/AiLearning/ml/1.MLFoundation/机器学习基础-选择算法.jpg)
+![选择算法图](img/机器学习基础-选择算法.jpg)
 
 > 机器学习 开发流程
 
@@ -215,7 +215,7 @@ F 值 = 70% * 50% * 2 / (70% + 50%) = 58.3%
 
 下面这个图可以比较直观地展示出来: 
 
-![](http://data.apachecn.org/img/AiLearning/ml/1.MLFoundation/ml_add_1.jpg)
+![](img/ml_add_1.jpg)
 
 ### 特征工程的一些小东西
 
@@ -225,7 +225,7 @@ F 值 = 70% * 50% * 2 / (70% + 50%) = 58.3%
 
 下面给出一个特征工程的图: 
 
-![](http://data.apachecn.org/img/AiLearning/ml/1.MLFoundation/ml_add_2.jpg)
+![](img/ml_add_2.jpg)
 
 ### 其他
 

docs/ml/10.md

 # 第 10 章 K-Means（K-均值）聚类算法
 
-![K-Means（K-均值）聚类算法_首页](http://data.apachecn.org/img/AiLearning/ml/10.KMeans/K-Means_首页.jpg)
+![K-Means（K-均值）聚类算法_首页](img/K-Means_首页.jpg)
 
 ## 聚类
 
@@ -59,7 +59,7 @@ kmeans，如前所述，用于数据集内种类属性不明晰，希望能够
 
 有关 `簇` 和 `质心` 术语更形象的介绍, 请参考下图:
 
-![K-Means 术语图](http://data.apachecn.org/img/AiLearning/ml/10.KMeans/apachecn-k-means-term-1.jpg)
+![K-Means 术语图](img/apachecn-k-means-term-1.jpg)
 
 ### K-Means 工作流程
 1. 首先, 随机确定 K 个初始点作为质心（**不必是数据中的点**）。
@@ -162,7 +162,7 @@ def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent):
 2. 测试一下 kMeans 函数是否可以如预期运行, 请看: <https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/10.kmeans/kMeans.py> 
 
 参考运行结果如下:  
-![K-Means 运行结果1](http://data.apachecn.org/img/AiLearning/ml/10.KMeans/apachecn-k-means-run-result-1.jpg)
+![K-Means 运行结果1](img/apachecn-k-means-run-result-1.jpg)
 
 
 
@@ -170,7 +170,7 @@ def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent):
 > 在 kMeans 的函数测试中，可能偶尔会陷入局部最小值（局部最优的结果，但不是全局最优的结果）.
 
 局部最小值的的情况如下:  
-![K-Means 局部最小值1](http://data.apachecn.org/img/AiLearning/ml/10.KMeans/apachecn-kmeans-partial-best-result-1.jpg)
+![K-Means 局部最小值1](img/apachecn-kmeans-partial-best-result-1.jpg)
 出现这个问题有很多原因，可能是k值取的不合适，可能是距离函数不合适，可能是最初随机选取的质心靠的太近，也可能是数据本身分布的问题。
 
 为了解决这个问题，我们可以对生成的簇进行后处理，一种方法是将具有最大**SSE**值的簇划分成两个簇。具体实现时可以将最大簇包含的点过滤出来并在这些点上运行K-均值算法，令k设为2。
@@ -239,7 +239,7 @@ def biKMeans(dataSet, k, distMeas=distEclud):
 
 上述函数可以运行多次，聚类会收敛到全局最小值，而原始的 kMeans() 函数偶尔会陷入局部最小值。  
 运行参考结果如下:  
-![二分 K-Means 运行结果1](http://data.apachecn.org/img/AiLearning/ml/10.KMeans/apachecn-bikmeans-run-result-1.jpg)
+![二分 K-Means 运行结果1](img/apachecn-bikmeans-run-result-1.jpg)
 
 * **作者: [那伊抹微笑](http://cwiki.apachecn.org/display/~xuxin),  [清都江水郎](http://cwiki.apachecn.org/display/~xuzhaoqing)** 
 * [GitHub地址](https://github.com/apachecn/AiLearning): <https://github.com/apachecn/AiLearning>

docs/ml/11.md

 
 # 第 11 章 使用 Apriori 算法进行关联分析
 
-![](http://data.apachecn.org/img/AiLearning/ml/11.Apriori/apachecn_apriori_homepage.jpg)
+![](img/apachecn_apriori_homepage.jpg)
 
 ## 关联分析
 关联分析是一种在大规模数据集中寻找有趣关系的任务。
@@ -12,7 +12,7 @@
 ## 相关术语
 * 关联分析（关联规则学习): 从大规模数据集中寻找物品间的隐含关系被称作 `关联分析(associati analysis)` 或者 `关联规则学习（association rule learning）` 。
 下面是用一个 `杂货店` 例子来说明这两个概念，如下图所示:  
-![关联分析示例1](http://data.apachecn.org/img/AiLearning/ml/11.Apriori/apachecn_apriori_association_demo_1.jpg)
+![关联分析示例1](img/apachecn_apriori_association_demo_1.jpg)
 
 * 频繁项集: {葡萄酒, 尿布, 豆奶} 就是一个频繁项集的例子。
 * 关联规则: 尿布 -> 葡萄酒 就是一个关联规则。这意味着如果顾客买了尿布，那么他很可能会买葡萄酒。
@@ -31,14 +31,14 @@
 
 假设我们一共有 4 个商品: 商品0, 商品1, 商品2, 商品3。
 所有可能的情况如下:  
-![4种商品的所有组合](http://data.apachecn.org/img/AiLearning/ml/11.Apriori/apachecn_apriori_goods_all_1.jpg)  
+![4种商品的所有组合](img/apachecn_apriori_goods_all_1.jpg)  
 如果我们计算所有组合的支持度，也需要计算 15 次。即 2^N - 1 = 2^4 - 1 = 15。  
 随着物品的增加，计算的次数呈指数的形式增长 ...   
 为了降低计算次数和时间，研究人员发现了一种所谓的 Apriori 原理，即某个项集是频繁的，那么它的所有子集也是频繁的。
 例如，如果 {0, 1} 是频繁的，那么 {0}, {1} 也是频繁的。
 该原理直观上没有什么帮助，但是如果反过来看就有用了，也就是说如果一个项集是 `非频繁项集`，那么它的所有超集也是非频繁项集，如下图所示:  
 
-![非频繁项集](http://data.apachecn.org/img/AiLearning/ml/11.Apriori/非频繁项集.png)
+![非频繁项集](img/非频繁项集.png)
 
 在图中我们可以看到，已知灰色部分 {2,3} 是 `非频繁项集`，那么利用上面的知识，我们就可以知道 {0,2,3} {1,2,3} {0,1,2,3} 都是 `非频繁的`。
 也就是说，计算出 {2,3} 的支持度，知道它是 `非频繁` 的之后，就不需要再计算 {0,2,3} {1,2,3} {0,1,2,3} 的支持度，因为我们知道这些集合不会满足我们的要求。
@@ -272,7 +272,7 @@ def apriori(dataSet, minSupport=0.5):
 
 ### 一个频繁项集可以产生多少条关联规则呢？
 如下图所示，给出的是项集 {0,1,2,3} 产生的所有关联规则:  
-![关联规则网格示意图](http://data.apachecn.org/img/AiLearning/ml/11.Apriori/apachecn_association_rule_demo_1.jpg)  
+![关联规则网格示意图](img/apachecn_association_rule_demo_1.jpg)  
 与我们前面的 `频繁项集` 生成一样，我们可以为每个频繁项集产生许多关联规则。  
 如果能减少规则的数目来确保问题的可解析，那么计算起来就会好很多。  
 通过观察，我们可以知道，如果某条规则并不满足 `最小可信度` 要求，那么该规则的所有子集也不会满足 `最小可信度` 的要求。  
@@ -386,7 +386,7 @@ def generateRules(L, supportData, minConf=0.7):
     * 1.首先从一个频繁项集开始，接着创建一个规则列表，其中规则右部分只包含一个元素，然后对这个规则进行测试。
     * 2.接下来合并所有剩余规则来创建一个新的规则列表，其中规则右部包含两个元素。
     * 如下图: 
-    * ![所有可能的项集组合](http://data.apachecn.org/img/AiLearning/ml/11.Apriori/所有可能的项集组合.png)
+    * ![所有可能的项集组合](img/所有可能的项集组合.png)
 * 最后:  每次增加频繁项集的大小，Apriori 算法都会重新扫描整个数据集，是否有优化空间呢？ 下一章: FP-growth算法等着你的到来
 
 * * *

docs/ml/12.md

 
 # 第12章 使用FP-growth算法来高效发现频繁项集
 
-![](http://data.apachecn.org/img/AiLearning/ml/12.FP-growth/apachecn_fp_growth_homepage.png)
+![](img/apachecn_fp_growth_homepage.png)
 
 ## 前言
 在 [第11章]() 时我们已经介绍了用 `Apriori` 算法发现 `频繁项集` 与 `关联规则`。  
@@ -37,16 +37,16 @@ class treeNode:
    1. 遍历所有的数据集合，计算所有项的支持度。
    2. 丢弃非频繁的项。
    3. 基于 支持度 降序排序所有的项。
-   ![](http://data.apachecn.org/img/AiLearning/ml/12.FP-growth/步骤1-3.png)
+   ![](img/步骤1-3.png)
    4. 所有数据集合按照得到的顺序重新整理。
    5. 重新整理完成后，丢弃每个集合末尾非频繁的项。
-   ![](http://data.apachecn.org/img/AiLearning/ml/12.FP-growth/步骤4-5.png)
+   ![](img/步骤4-5.png)
 
 步骤2:
    6. 读取每个集合插入FP树中，同时用一个头部链表数据结构维护不同集合的相同项。  
-   ![](http://data.apachecn.org/img/AiLearning/ml/12.FP-growth/步骤6-1.png)
+   ![](img/步骤6-1.png)
    最终得到下面这样一棵FP树
-   ![](http://data.apachecn.org/img/AiLearning/ml/12.FP-growth/步骤6-2.png)
+   ![](img/步骤6-2.png)
 
 
 从FP树中挖掘出频繁项集
@@ -54,14 +54,14 @@ class treeNode:
 步骤3:
    1. 对头部链表进行降序排序
    2. 对头部链表节点从小到大遍历，得到条件模式基，同时获得一个频繁项集。
-        ![](http://data.apachecn.org/img/AiLearning/ml/12.FP-growth/步骤6-2.png)
+        ![](img/步骤6-2.png)
         如上图，从头部链表 t 节点开始遍历，t 节点加入到频繁项集。找到以 t 节点为结尾的路径如下:
-        ![](http://data.apachecn.org/img/AiLearning/ml/12.FP-growth/步骤7-1.png)
+        ![](img/步骤7-1.png)
         去掉FP树中的t节点，得到条件模式基<左边路径, 右边是值>[z,x,y,s,t]:2，[z,x,y,r,t]:1 。条件模式基的值取决于末尾节点 t ，因为 t 的出现次数最小，一个频繁项集的支持度由支持度最小的项决定。所以 t 节点的条件模式基的值可以理解为对于以 t 节点为末尾的前缀路径出现次数。
        
    3. 条件模式基继续构造条件 FP树， 得到频繁项集，和之前的频繁项组合起来，这是一个递归遍历头部链表生成FP树的过程，递归截止条件是生成的FP树的头部链表为空。
         根据步骤 2 得到的条件模式基 [z,x,y,s,t]:2，[z,x,y,r,t]:1 作为数据集继续构造出一棵FP树，计算支持度，去除非频繁项，集合按照支持度降序排序，重复上面构造FP树的步骤。最后得到下面 t-条件FP树 :
-        ![](http://data.apachecn.org/img/AiLearning/ml/12.FP-growth/步骤7-2.png)
+        ![](img/步骤7-2.png)
         然后根据 t-条件FP树 的头部链表进行遍历，从 y 开始。得到频繁项集 ty 。然后又得到 y 的条件模式基，构造出 ty的条件FP树，即 ty-条件FP树。继续遍历ty-条件FP树的头部链表，得到频繁项集 tyx，然后又得到频繁项集 tyxz. 然后得到构造tyxz-条件FP树的头部链表是空的，终止遍历。我们得到的频繁项集有 t->ty->tyz->tyzx，这只是一小部分。
    * 条件模式基:头部链表中的某一点的前缀路径组合就是条件模式基，条件模式基的值取决于末尾节点的值。
    * 条件FP树:以条件模式基为数据集构造的FP树叫做条件FP树。

docs/ml/13.md

 # 第13章 利用 PCA 来简化数据
 
-![利用PCA简化数据_首页](http://data.apachecn.org/img/AiLearning/ml/13.PCA/利用PCA简化数据_首页.jpg)
+![利用PCA简化数据_首页](img/利用PCA简化数据_首页.jpg)
 
 ## 降维技术 
 
@@ -70,7 +70,7 @@
 
 例如下图: 
 
-![应用PCA降维](http://data.apachecn.org/img/AiLearning/ml/13.PCA/应用PCA降维.png)
+![应用PCA降维](img/应用PCA降维.png)
 
 > PCA 优缺点
 
@@ -128,7 +128,7 @@ def replaceNanWithMean():
 
 > 分析数据: 统计分析 N 的阈值
 
-![PCA分析数据过程](http://data.apachecn.org/img/AiLearning/ml/13.PCA/PCA分析数据过程.jpg)
+![PCA分析数据过程](img/PCA分析数据过程.jpg)
 
 > PCA 数据降维
 

docs/ml/14.md

 # 第14章 利用SVD简化数据
 <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default"></script>
 
-![利用SVD简化数据首页](http://data.apachecn.org/img/AiLearning/ml/14.SVD/svd_headPage.jpg "利用SVD简化数据首页")
+![利用SVD简化数据首页](img/svd_headPage.jpg "利用SVD简化数据首页")
 
 ## SVD 概述
 
@@ -17,14 +17,14 @@
 隐性语义索引: 矩阵 = 文档 + 词语
 * 是最早的 SVD 应用之一，我们称利用 SVD 的方法为隐性语义索引（LSI）或隐性语义分析（LSA）。
 
-![LSA举例](http://data.apachecn.org/img/AiLearning/ml/14.SVD/使用SVD简化数据-LSI举例.png)
+![LSA举例](img/使用SVD简化数据-LSI举例.png)
 
 > 推荐系统
 
 1. 利用 SVD 从数据中构建一个主题空间。
 2. 再在该空间下计算其相似度。(从高维-低维空间的转化，在低维空间来计算相似度，SVD 提升了推荐系统的效率。)
 
-![主题空间案例1](http://data.apachecn.org/img/AiLearning/ml/14.SVD/SVD_推荐系统_主题空间案例1.jpg)
+![主题空间案例1](img/SVD_推荐系统_主题空间案例1.jpg)
 
 * 上图右边标注的为一组共同特征，表示美式 BBQ 空间；另一组在上图右边未标注的为日式食品 空间。
 
@@ -32,7 +32,7 @@
 
 例如: `32*32=1024 => 32*2+2*1+32*2=130`(2*1表示去掉了除对角线的0), 几乎获得了10倍的压缩比。
 
-![SVD公式](http://data.apachecn.org/img/AiLearning/ml/14.SVD/使用SVD简化数据-SVD公式.jpg)
+![SVD公式](img/使用SVD简化数据-SVD公式.jpg)
 
 ## SVD 原理
 
@@ -54,11 +54,11 @@
 
 $$Data_{m \ast n} = U_{m \ast k} \sum_{k \ast k} V_{k \ast n}$$
 
-![SVD公式](http://data.apachecn.org/img/AiLearning/ml/14.SVD/使用SVD简化数据-SVD公式.jpg)
+![SVD公式](img/使用SVD简化数据-SVD公式.jpg)
 
 具体的案例: （大家可以试着推导一下: https://wenku.baidu.com/view/b7641217866fb84ae45c8d17.html ）
 
-![SVD公式](http://data.apachecn.org/img/AiLearning/ml/14.SVD/SVD公式的测试案例.jpg)
+![SVD公式](img/SVD公式的测试案例.jpg)
 
 * 上述分解中会构建出一个矩阵 $$\sum$$ ，该矩阵只有对角元素，其他元素均为0(近似于0)。另一个惯例就是，$$\sum$$ 的对角元素是从大到小排列的。这些对角元素称为奇异值。
 * 奇异值与特征值(PCA 数据中重要特征)是有关系的。这里的奇异值就是矩阵 $$Data \ast Data^T$$ 特征值的平方根。
@@ -97,12 +97,12 @@ $$Data_{m \ast n} = U_{m \ast k} \sum_{k \ast k} V_{k \ast n}$$
 * 基于物品的相似度: 计算物品之间的距离。【耗时会随物品数量的增加而增加】
 * 由于物品A和物品C 相似度(相关度)很高，所以给买A的人推荐C。
 
-![SVD公式](http://data.apachecn.org/img/AiLearning/ml/14.SVD/使用SVD简化数据-基于物品相似度.png)
+![SVD公式](img/使用SVD简化数据-基于物品相似度.png)
 
 * 基于用户的相似度: 计算用户之间的距离。【耗时会随用户数量的增加而增加】
 * 由于用户A和用户C 相似度(相关度)很高，所以A和C是兴趣相投的人，对于C买的物品就会推荐给A。
 
-![SVD公式](http://data.apachecn.org/img/AiLearning/ml/14.SVD/使用SVD简化数据-基于用户相似度.png)
+![SVD公式](img/使用SVD简化数据-基于用户相似度.png)
 
 > 相似度计算
 
@@ -146,7 +146,7 @@ $$Data_{m \ast n} = U_{m \ast k} \sum_{k \ast k} V_{k \ast n}$$
 
 > 收集 并 准备数据
 
-![SVD 矩阵](http://data.apachecn.org/img/AiLearning/ml/14.SVD/项目数据导入.jpg)
+![SVD 矩阵](img/项目数据导入.jpg)
 
 ```python
 def loadExData3():
@@ -177,9 +177,9 @@ recommend() 会调用 基于物品相似度 或者是 基于SVD，得到推荐
 
 * 1.基于物品相似度
 
-![基于物品相似度](http://data.apachecn.org/img/AiLearning/ml/14.SVD/基于物品相似度.jpg)
+![基于物品相似度](img/基于物品相似度.jpg)
 
-![欧式距离的计算方式](http://data.apachecn.org/img/AiLearning/ml/14.SVD/欧式距离的计算方式.jpg)
+![欧式距离的计算方式](img/欧式距离的计算方式.jpg)
 
 ```python
 # 基于物品相似度的推荐引擎
@@ -229,7 +229,7 @@ def standEst(dataMat, user, simMeas, item):
 
 * 2.基于SVD(参考地址: http://www.codeweblog.com/svd-%E7%AC%94%E8%AE%B0/)
 
-![基于SVD.png](http://data.apachecn.org/img/AiLearning/ml/14.SVD/基于SVD.png)
+![基于SVD.png](img/基于SVD.png)
 
 ```python
 # 基于SVD的评分估计

docs/ml/15.md

 # 第15章 大数据与MapReduce
 
-![大数据与MapReduce首页](http://data.apachecn.org/img/AiLearning/ml/15.BigData_MapReduce/mr_headPage.jpg "大数据与MapReduce首页")
+![大数据与MapReduce首页](img/mr_headPage.jpg "大数据与MapReduce首页")
 
 ## 大数据 概述
 
@@ -37,7 +37,7 @@ MapReduce: 分布式的计算框架，可以将单个计算作业分配给多台
 * 数据被重复存放在不同的机器上，以防止某个机器失效
 * mapper 和 reducer 传输的数据形式为 key/value对
 
-![MapReduce框架的示意图](http://data.apachecn.org/img/AiLearning/ml/15.BigData_MapReduce/mr_1_cluster.jpg "MapReduce框架的示意图")
+![MapReduce框架的示意图](img/mr_1_cluster.jpg "MapReduce框架的示意图")
 
 > MapRedece 特点
 

docs/ml/16.md

@@ -46,13 +46,13 @@
 | 基于知识推荐  |   |
 | 组合推荐     |   |
 
-![推荐方法对比](http://data.apachecn.org/img/AiLearning/ml/16.RecommendedSystem/推荐方法对比.png)
+![推荐方法对比](img/推荐方法对比.png)
 
 ### 基于知识推荐
 
 基于知识的推荐（Knowledge-based Recommendation）在某种程度是可以看成是一种推理（Inference）技术，它不是建立在用户需要和偏好基础上推荐的。基于知识的方法因它们所用的功能知识不同而有明显区别。效用知识（Functional Knowledge）是一种关于一个项目如何满足某一特定用户的知识，因此能解释需要和推荐的关系，所以用户资料可以是任何能支持推理的知识结构，它可以是用户已经规范化的查询，也可以是一个更详细的用户需要的表示。
 
-![基于知识的推荐](http://data.apachecn.org/img/AiLearning/ml/16.RecommendedSystem/基于知识的推荐.jpg)
+![基于知识的推荐](img/基于知识的推荐.jpg)
 
 ### 协同过滤推荐
 

docs/ml/2.md

 # 第2章 k-近邻算法
 <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default"></script>
 
-![k-近邻算法_首页](http://data.apachecn.org/img/AiLearning/ml/2.KNN/knn_headPage_xy.png "k-近邻算法首页")
+![k-近邻算法_首页](img/knn_headPage_xy.png "k-近邻算法首页")
 
 ## KNN 概述
 
@@ -21,7 +21,7 @@
 
 基于电影中的亲吻、打斗出现的次数，使用 k-近邻算法构造程序，就可以自动划分电影的题材类型。
 
-![电影视频案例](http://data.apachecn.org/img/AiLearning/ml/2.KNN/knn-1-movie.png "电影视频案例")
+![电影视频案例](img/knn-1-movie.png "电影视频案例")
 
 ```
 现在根据上面我们得到的样本集中所有电影与未知电影的距离，按照距离递增排序，可以找到 k 个距离最近的电影。
@@ -162,7 +162,7 @@ plt.show()
 
 下图中采用矩阵的第一和第二列属性得到很好的展示效果，清晰地标识了三个不同的样本分类区域，具有不同爱好的人其类别区域也不同。
 
-![Matplotlib 散点图](http://data.apachecn.org/img/AiLearning/ml/2.KNN/knn_matplotlib_2.png)
+![Matplotlib 散点图](img/knn_matplotlib_2.png)
 
 * 归一化数据 （归一化是一个让权重变为统一的过程，更多细节请参考:  https://www.zhihu.com/question/19951858 ）
 
@@ -194,7 +194,7 @@ $$\sqrt{(0-67)^2 + (20000-32000)^2 + (1.1-0.1)^2 }$$
 
     如图: 
     
-    ![对数函数图像](http://data.apachecn.org/img/AiLearning/ml/2.KNN/knn_1.png)
+    ![对数函数图像](img/knn_1.png)
 
 3) 反余切函数转换，表达式如下: 
 
@@ -202,7 +202,7 @@ $$\sqrt{(0-67)^2 + (20000-32000)^2 + (1.1-0.1)^2 }$$
 
     如图: 
     
-    ![反余切函数图像](http://data.apachecn.org/img/AiLearning/ml/2.KNN/arctan_arccot.gif)
+    ![反余切函数图像](img/arctan_arccot.gif)
 
 4) 式(1)将输入值换算为[-1,1]区间的值，在输出层用式(2)换算回初始值，其中和分别表示训练样本集中负荷的最大值和最小值。　
     
@@ -363,7 +363,7 @@ You will probably like this person: in small doses
 
 目录 [trainingDigits](/data/2.KNN/trainingDigits) 中包含了大约 2000 个例子，每个例子内容如下图所示，每个数字大约有 200 个样本；目录 [testDigits](/data/2.KNN/testDigits) 中包含了大约 900 个测试数据。
 
-![手写数字数据集的例子](http://data.apachecn.org/img/AiLearning/ml/2.KNN/knn_2_handWriting.png)
+![手写数字数据集的例子](img/knn_2_handWriting.png)
 
 > 准备数据: 编写函数 img2vector(), 将图像文本数据转换为分类器使用的向量
 

docs/ml/3.md

@@ -2,7 +2,7 @@
 # 第3章 决策树
 <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default"></script>
 
-![决策树_首页](http://data.apachecn.org/img/AiLearning/ml/3.DecisionTree/DecisionTree_headPage_xy.png "决策树首页")
+![决策树_首页](img/DecisionTree_headPage_xy.png "决策树首页")
 
 ## 决策树 概述
 
@@ -18,7 +18,7 @@
 
 一个邮件分类系统，大致工作流程如下: 
 
-![决策树-流程图](http://data.apachecn.org/img/AiLearning/ml/3.DecisionTree/决策树-流程图.jpg "决策树示例流程图")
+![决策树-流程图](img/决策树-流程图.jpg "决策树示例流程图")
 
 ```
 首先检测发送邮件域名地址。如果地址为 myEmployer.com, 则将其放在分类 "无聊时需要阅读的邮件"中。
@@ -114,7 +114,7 @@ def createBranch():
 
 > 收集数据: 可以使用任何方法
 
-![海洋生物数据](http://data.apachecn.org/img/AiLearning/ml/3.DecisionTree/DT_海洋生物数据.png)
+![海洋生物数据](img/DT_海洋生物数据.png)
 
 我们利用 createDataSet() 函数输入数据
 
@@ -134,7 +134,7 @@ def createDataSet():
 
 > 分析数据: 可以使用任何方法，构造树完成之后，我们可以将树画出来。
 
-![熵的计算公式](http://data.apachecn.org/img/AiLearning/ml/3.DecisionTree/熵的计算公式.jpg)
+![熵的计算公式](img/熵的计算公式.jpg)
 
 计算给定数据集的香农熵的函数
 

docs/ml/4.md

@@ -2,7 +2,7 @@
 # 第4章 基于概率论的分类方法: 朴素贝叶斯
 <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default"></script>
 
-![朴素贝叶斯_首页](http://data.apachecn.org/img/AiLearning/ml/4.NaiveBayesian/NavieBayesian_headPage_xy.png "朴素贝叶斯首页")
+![朴素贝叶斯_首页](img/NavieBayesian_headPage_xy.png "朴素贝叶斯首页")
 
 ## 朴素贝叶斯 概述 
 
@@ -14,7 +14,7 @@
 
 我们现在有一个数据集，它由两类数据组成，数据分布如下图所示: 
 
-![朴素贝叶斯示例数据分布](http://data.apachecn.org/img/AiLearning/ml/4.NaiveBayesian/朴素贝叶斯示例数据分布.png "参数已知的概率分布")
+![朴素贝叶斯示例数据分布](img/朴素贝叶斯示例数据分布.png "参数已知的概率分布")
 
 我们现在用 p1(x,y) 表示数据点 (x,y) 属于类别 1（图中用圆点表示的类别）的概率，用 p2(x,y) 表示数据点 (x,y) 属于类别 2（图中三角形表示的类别）的概率，那么对于一个新数据点 (x,y)，可以用下面的规则来判断它的类别: 
 * 如果 p1(x,y) > p2(x,y) ，那么类别为1
@@ -28,11 +28,11 @@
 
 有一个装了 7 块石头的罐子，其中 3 块是白色的，4 块是黑色的。如果从罐子中随机取出一块石头，那么是白色石头的可能性是多少？由于取石头有 7 种可能，其中 3 种为白色，所以取出白色石头的概率为 3/7 。那么取到黑色石头的概率又是多少呢？很显然，是 4/7 。我们使用 P(white) 来表示取到白色石头的概率，其概率值可以通过白色石头数目除以总的石头数目来得到。
 
-![包含 7 块石头的集合](http://data.apachecn.org/img/AiLearning/ml/4.NaiveBayesian/NB_2.png)
+![包含 7 块石头的集合](img/NB_2.png)
 
 如果这 7 块石头如下图所示，放在两个桶中，那么上述概率应该如何计算？
 
-![7块石头放入两个桶中](http://data.apachecn.org/img/AiLearning/ml/4.NaiveBayesian/NB_3.png)
+![7块石头放入两个桶中](img/NB_3.png)
 
 计算 P(white) 或者 P(black) ，如果事先我们知道石头所在桶的信息是会改变结果的。这就是所谓的条件概率（conditional probablity）。假定计算的是从 B 桶取到白色石头的概率，这个概率可以记作 P(white|bucketB) ，我们称之为“在已知石头出自 B 桶的条件下，取出白色石头的概率”。很容易得到，P(white|bucketA) 值为 2/4 ，P(white|bucketB) 的值为 1/3 。
 
@@ -44,7 +44,7 @@ P(white|bucketB) = P(white and bucketB) / P(bucketB)
 
 另外一种有效计算条件概率的方法称为贝叶斯准则。贝叶斯准则告诉我们如何交换条件概率中的条件与结果，即如果已知 P(x|c)，要求 P(c|x)，那么可以使用下面的计算方法: 
 
-![计算p(c|x)的方法](http://data.apachecn.org/img/AiLearning/ml/4.NaiveBayesian/NB_4.png)
+![计算p(c|x)的方法](img/NB_4.png)
 
 ### 使用条件概率来分类
 
@@ -54,7 +54,7 @@ P(white|bucketB) = P(white and bucketB) / P(bucketB)
 
 这并不是贝叶斯决策理论的所有内容。使用 p1() 和 p2() 只是为了尽可能简化描述，而真正需要计算和比较的是 p(c1|x, y) 和 p(c2|x, y) .这些符号所代表的具体意义是: 给定某个由 x、y 表示的数据点，那么该数据点来自类别 c1 的概率是多少？数据点来自类别 c2 的概率又是多少？注意这些概率与概率 p(x, y|c1) 并不一样，不过可以使用贝叶斯准则来交换概率中条件与结果。具体地，应用贝叶斯准则得到: 
 
-![应用贝叶斯准则](http://data.apachecn.org/img/AiLearning/ml/4.NaiveBayesian/NB_5.png)
+![应用贝叶斯准则](img/NB_5.png)
 
 使用上面这些定义，可以定义贝叶斯分类准则为:
 * 如果 P(c1|x, y) > P(c2|x, y), 那么属于类别 c1;
@@ -213,7 +213,7 @@ def setOfWords2Vec(vocabList, inputSet):
 
 现在已经知道了一个词是否出现在一篇文档中，也知道该文档所属的类别。接下来我们重写贝叶斯准则，将之前的 x, y 替换为 <b>w</b>. 粗体的 <b>w</b> 表示这是一个向量，即它由多个值组成。在这个例子中，数值个数与词汇表中的词个数相同。
 
-![重写贝叶斯准则](http://data.apachecn.org/img/AiLearning/ml/4.NaiveBayesian/NB_6.png )
+![重写贝叶斯准则](img/NB_6.png )
 
 我们使用上述公式，对每个类计算该值，然后比较这两个概率值的大小。
 
@@ -274,7 +274,7 @@ def _trainNB0(trainMatrix, trainCategory):
 
 下图给出了函数 f(x) 与 ln(f(x)) 的曲线。可以看出，它们在相同区域内同时增加或者减少，并且在相同点上取到极值。它们的取值虽然不同，但不影响最终结果。
 
-![函数图像](http://data.apachecn.org/img/AiLearning/ml/4.NaiveBayesian/NB_7.png )
+![函数图像](img/NB_7.png )
 
 ```python
 def trainNB0(trainMatrix, trainCategory):

docs/ml/5.md

 # 第5章 Logistic回归
 <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default"></script>
 
-![朴素贝叶斯_首页](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LogisticRegression_headPage_xy.png "Logistic回归首页")
+![朴素贝叶斯_首页](img/LogisticRegression_headPage_xy.png "Logistic回归首页")
 
 ## Logistic 回归 概述
 
@@ -19,11 +19,11 @@
 
 我们想要的函数应该是: 能接受所有的输入然后预测出类别。例如，在两个类的情况下，上述函数输出 0 或 1.或许你之前接触过具有这种性质的函数，该函数称为 `海维塞得阶跃函数(Heaviside step function)`，或者直接称为 `单位阶跃函数`。然而，海维塞得阶跃函数的问题在于: 该函数在跳跃点上从 0 瞬间跳跃到 1，这个瞬间跳跃过程有时很难处理。幸好，另一个函数也有类似的性质（可以输出 0 或者 1 的性质），且数学上更易处理，这就是 Sigmoid 函数。 Sigmoid 函数具体的计算公式如下: 
 
-![Sigmoid 函数计算公式](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_1.png)
+![Sigmoid 函数计算公式](img/LR_1.png)
 
 下图给出了 Sigmoid 函数在不同坐标尺度下的两条曲线图。当 x 为 0 时，Sigmoid 函数值为 0.5 。随着 x 的增大，对应的 Sigmoid 值将逼近于 1 ; 而随着 x 的减小， Sigmoid 值将逼近于 0 。如果横坐标刻度足够大， Sigmoid 函数看起来很像一个阶跃函数。
 
-![Sigmoid 函数在不同坐标下的图片](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_3.png)
+![Sigmoid 函数在不同坐标下的图片](img/LR_3.png)
 
 因此，为了实现 Logistic 回归分类器，我们可以在每个特征上都乘以一个回归系数（如下公式所示），然后把所有结果值相加，将这个总和代入 Sigmoid 函数中，进而得到一个范围在 0~1 之间的数值。任何大于 0.5 的数据被分入 1 类，小于 0.5 即被归入 0 类。所以，Logistic 回归也是一种概率估计，比如这里Sigmoid 函数得出的值为0.5，可以理解为给定数据和参数，数据被分入 1 类的概率为0.5。想对Sigmoid 函数有更多了解，可以点开[此链接](https://www.desmos.com/calculator/bgontvxotm)跟此函数互动。
 
@@ -31,9 +31,9 @@
 
 Sigmoid 函数的输入记为 z ，由下面公式得到: 
 
-![Sigmoid 函数计算公式](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_2.png)
+![Sigmoid 函数计算公式](img/LR_2.png)
 
-如果采用向量的写法，上述公式可以写成 ![Sigmoid 函数计算公式向量形式](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_4.png) ，它表示将这两个数值向量对应元素相乘然后全部加起来即得到 z 值。其中的向量 x 是分类器的输入数据，向量 w 也就是我们要找到的最佳参数（系数），从而使得分类器尽可能地精确。为了寻找该最佳参数，需要用到最优化理论的一些知识。我们这里使用的是——梯度上升法（Gradient Ascent）。
+如果采用向量的写法，上述公式可以写成 ![Sigmoid 函数计算公式向量形式](img/LR_4.png) ，它表示将这两个数值向量对应元素相乘然后全部加起来即得到 z 值。其中的向量 x 是分类器的输入数据，向量 w 也就是我们要找到的最佳参数（系数），从而使得分类器尽可能地精确。为了寻找该最佳参数，需要用到最优化理论的一些知识。我们这里使用的是——梯度上升法（Gradient Ascent）。
 
 
 ### 梯度上升法
@@ -50,17 +50,17 @@ Sigmoid 函数的输入记为 z ，由下面公式得到:
 #### 梯度上升法的思想
 要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻。如果梯度记为 ▽ ，则函数 f(x, y) 的梯度由下式表示: 
 
-![梯度上升计算公式](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_5.png)
+![梯度上升计算公式](img/LR_5.png)
 
-这个梯度意味着要沿 x 的方向移动 ![f(x, y)对x求偏导](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_6.png) ，沿 y 的方向移动 ![f(x, y)对y求偏导](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_7.png) 。其中，函数f(x, y) 必须要在待计算的点上有定义并且可微。下图是一个具体的例子。
+这个梯度意味着要沿 x 的方向移动 ![f(x, y)对x求偏导](img/LR_6.png) ，沿 y 的方向移动 ![f(x, y)对y求偏导](img/LR_7.png) 。其中，函数f(x, y) 必须要在待计算的点上有定义并且可微。下图是一个具体的例子。
 
-![梯度上升](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_8.png)
+![梯度上升](img/LR_8.png)
 
 上图展示的，梯度上升算法到达每个点后都会重新估计移动的方向。从 P0 开始，计算完该点的梯度，函数就根据梯度移动到下一点 P1。在 P1 点，梯度再次被重新计算，并沿着新的梯度方向移动到 P2 。如此循环迭代，直到满足停止条件。迭代过程中，梯度算子总是保证我们能选取到最佳的移动方向。
 
 上图中的梯度上升算法沿梯度方向移动了一步。可以看到，梯度算子总是指向函数值增长最快的方向。这里所说的是移动方向，而未提到移动量的大小。该量值称为步长，记作 α 。用向量来表示的话，梯度上升算法的迭代公式如下: 
 
-![梯度上升迭代公式](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_9.png)
+![梯度上升迭代公式](img/LR_9.png)
 
 该公式将一直被迭代执行，直至达到某个停止条件为止，比如迭代次数达到某个指定值或者算法达到某个可以允许的误差范围。
 
@@ -80,12 +80,12 @@ Sigmoid 函数的输入记为 z ，由下面公式得到:
 
    只需要在迭代公式中的加法变成减法。因此，对应的公式可以写成
 
-![梯度下降迭代公式](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_10.png)
+![梯度下降迭代公式](img/LR_10.png)
 
 
 **局部最优现象 （Local Optima）**
 
-![梯度下降图_4](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_20.png)
+![梯度下降图_4](img/LR_20.png)
 
 上图表示参数 θ 与误差函数 J(θ) 的关系图 (这里的误差函数是损失函数，所以我们要最小化损失函数)，红色的部分是表示 J(θ) 有着比较高的取值，我们需要的是，能够让 J(θ) 的值尽量的低。也就是深蓝色的部分。θ0，θ1 表示 θ 向量的两个维度（此处的θ0，θ1是x0和x1的系数，也对应的是上文w0和w1）。
 
@@ -126,7 +126,7 @@ Sigmoid 函数的输入记为 z ，由下面公式得到:
 
 ### 附加 方向导数与梯度
 
-![方向导数与梯度](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/方向导数和梯度.png)
+![方向导数与梯度](img/方向导数和梯度.png)
 
 ## Logistic 回归 项目案例
 
@@ -163,7 +163,7 @@ Sigmoid 函数的输入记为 z ，由下面公式得到:
 
 绘制在图中，如下图所示: 
 
-![简单数据集绘制在图上](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_11.png)
+![简单数据集绘制在图上](img/LR_11.png)
 
 > 准备数据: 由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据格式则最佳
 
@@ -247,7 +247,7 @@ def gradAscent(dataMatIn, classLabels):
 
 大家看到这儿可能会有一些疑惑，就是，我们在迭代中更新我们的回归系数，后边的部分是怎么计算出来的？为什么会是 alpha * dataMatrix.transpose() * error ?因为这就是我们所求的梯度，也就是对 f(w) 对 w 求一阶导数。具体推导如下:
 
-![f(w)对w求一阶导数](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_21.png)
+![f(w)对w求一阶导数](img/LR_21.png)
 可参考http://blog.csdn.net/achuo/article/details/51160101
 
 画出数据集和 Logistic 回归最佳拟合直线的函数
@@ -357,7 +357,7 @@ def stocGradAscent0(dataMatrix, classLabels):
 
 判断优化算法优劣的可靠方法是看它是否收敛，也就是说参数是否达到了稳定值，是否还会不断地变化？下图展示了随机梯度上升算法在 200 次迭代过程中回归系数的变化情况。其中的系数2，也就是 X2 只经过了 50 次迭代就达到了稳定值，但系数 1 和 0 则需要更多次的迭代。如下图所示: 
 
-![回归系数与迭代次数的关系图](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_12.png)
+![回归系数与迭代次数的关系图](img/LR_12.png)
 
 针对这个问题，我们改进了之前的随机梯度上升算法，如下: 
 
@@ -393,7 +393,7 @@ def stocGradAscent1(dataMatrix, classLabels, numIter=150):
 
 程序运行之后能看到类似于下图的结果图。
 
-![改进随机梯度下降结果图](http://data.apachecn.org/img/AiLearning/ml/5.Logistic/LR_13.png)
+![改进随机梯度下降结果图](img/LR_13.png)
 
 
 ### 项目案例2: 从疝气病症预测病马的死亡率

docs/ml/6.1.md

@@ -44,13 +44,13 @@ support vector （支持向量）的意思就是 <b>数据集中的某些点</b>
 <b>不通俗的理解</b>: 
 在 maximum margin （最大间隔）上的这些点就叫 “支持向量”，我想补充的是为啥这些点就叫 “支持向量” ，因为最后的 classification machine （分类器）的表达式里只含有这些 “支持向量” 的信息，而与其他数据点无关: 
 
-![支持向量机公式](http://data.apachecn.org/img/AiLearning/ml/6.SVM/supportVector公式.jpg "supportVector公式")
+![支持向量机公式](img/supportVector公式.jpg "supportVector公式")
 
-在这个表达式中，只有支持向量的系数 ![alphai](http://data.apachecn.org/img/AiLearning/ml/6.SVM/alpha.png "alphai") 不等于 0 。
+在这个表达式中，只有支持向量的系数 ![alphai](img/alpha.png "alphai") 不等于 0 。
 
 如果还是不怎么理解，不要紧，看下图:
 
-![supportVector](http://data.apachecn.org/img/AiLearning/ml/6.SVM/supportVector.png "supportVector")
+![supportVector](img/supportVector.png "supportVector")
 
 “支持向量” 就是图中用紫色框框圈出来的点...
 
@@ -59,7 +59,7 @@ support vector （支持向量）的意思就是 <b>数据集中的某些点</b>
 
 我们先看一张图
 
-![supportVectorMachine](http://data.apachecn.org/img/AiLearning/ml/6.SVM/svm_2.png "supportVectorMachine")
+![supportVectorMachine](img/svm_2.png "supportVectorMachine")
 
 `linearly separable （线性可分）`: 如上图中的两组数据，它们之间已经分的足够开了，因此很容易就可以在图中画出一条直线将两组数据点分开。在这种情况下，这组数据就被称为<b>线性可分数据</b>。
 
@@ -87,35 +87,35 @@ support vector （支持向量）的意思就是 <b>数据集中的某些点</b>
 
 魔鬼在桌子上似乎有规律放了两种颜色的球，说: “你用一根棍分开它们？要求: 尽量在放更多球之后，仍然适用。”
 
-![story_1](http://data.apachecn.org/img/AiLearning/ml/6.SVM/story_1.png "story_1")
+![story_1](img/story_1.png "story_1")
 
 于是大侠这样放，干的不错？ 
 
-![story_2](http://data.apachecn.org/img/AiLearning/ml/6.SVM/story_2.png "story_2")
+![story_2](img/story_2.png "story_2")
 
 然后魔鬼，又在桌上放了更多的球，似乎有一个球站错了阵营。
 
-![story_3](http://data.apachecn.org/img/AiLearning/ml/6.SVM/story_3.png "story_3")
+![story_3](img/story_3.png "story_3")
 
 SVM 就是试图把棍放在最佳位置，好让在棍的两边有尽可能大的间隙。
 
-![story_4](http://data.apachecn.org/img/AiLearning/ml/6.SVM/story_4.png "story_4")
+![story_4](img/story_4.png "story_4")
 
 现在即使魔鬼放了更多的球，棍仍然是一个好的分界线。
 
-![story_5](http://data.apachecn.org/img/AiLearning/ml/6.SVM/story_5.png "story_5")
+![story_5](img/story_5.png "story_5")
 
 然后，在 SVM 工具箱中有另一个更加重要的 trick。 魔鬼看到大侠已经学会了一个 trick ，于是魔鬼给了大侠一个新的挑战。
 
-![story_6](http://data.apachecn.org/img/AiLearning/ml/6.SVM/story_6.png "story_6")
+![story_6](img/story_6.png "story_6")
 
 现在，大侠没有棍可以很好帮他分开两种球了，现在怎么办呢？当然像所有武侠片中一样大侠桌子一拍，球飞到空中。然后，凭借大侠的轻功，大侠抓起一张纸，插到了两种球的中间。
 
-![story_7](http://data.apachecn.org/img/AiLearning/ml/6.SVM/story_7.png "story_7")
+![story_7](img/story_7.png "story_7")
 
 现在，从魔鬼的角度看这些球，这些球看起来像是被一条曲线分开了。
 
-![story_8](http://data.apachecn.org/img/AiLearning/ml/6.SVM/story_8.png "story_8")
+![story_8](img/story_8.png "story_8")
 
 再之后，无聊的大人们，把这些球叫做 <b>「data」</b>，把棍子叫做 <b>「classifier」</b>, 最大间隙 trick 叫做<b>「optimization」</b>， 拍桌子叫做<b>「kernelling」</b>, 那张纸叫做<b>「hyperplane」</b> 。
 
@@ -162,11 +162,11 @@ d<D,米粒
 
 如图的例子，（训练集）红色点是我们已知的分类1，（训练集）蓝色点是已知的分类2，我们想寻找一个分隔超平面（图中绿线）（因为示例是二维数据点，所以只是一条线，如果数据是三维的就是平面，如果是三维以上就是超平面）把这两类完全分开，这样的话再来一个样本点需要我们预测的话，我们就可以根据这个分界超平面预测出分类结果。
 
-![hu_1](http://data.apachecn.org/img/AiLearning/ml/6.SVM/hu_1.jpg "hu_1")
+![hu_1](img/hu_1.jpg "hu_1")
 
-那我们如何选择这个分类超平面呢？从数学上说，超平面的公式是,也就是说如何选取这个 ![w](http://data.apachecn.org/img/AiLearning/ml/6.SVM/w.png "w")（是个向量）。
+那我们如何选择这个分类超平面呢？从数学上说，超平面的公式是,也就是说如何选取这个 ![w](img/w.png "w")（是个向量）。
 
-传统方法是根据最小二乘错误法（least squared error），首先随便定选取一个随机平面，也就是随机选取 ![w](http://data.apachecn.org/img/AiLearning/ml/6.SVM/w.png "w") 和 ![b](http://data.apachecn.org/img/AiLearning/ml/6.SVM/b.png "b")，然后想必会在训练集中产生大量的错误分类，也就是说，![wtx+b](http://data.apachecn.org/img/AiLearning/ml/6.SVM/hu_5.png "wtx+b") 结果应该大于 0 的时候小于 0 ，应该小于 0 的时候大于 0 。这时候有一个错误损失，也就是说对于所有错误的分类，他们的平方和（least squared error） 为: ![平方和](http://data.apachecn.org/img/AiLearning/ml/6.SVM/hu_8.png "平方和") , 最小二乘法的目标就是让这个值趋于最小，对 ![w](http://data.apachecn.org/img/AiLearning/ml/6.SVM/w.png "w") 求导取 0 ，采用梯度下降算法，可以求出错误平方和的极值，求出最优的 ![w](http://data.apachecn.org/img/AiLearning/ml/6.SVM/w.png "w") ，也就是求出最优的超平面。（可以证明，如果基函数是指数族函数，求出的超平面是全局最优的）。
+传统方法是根据最小二乘错误法（least squared error），首先随便定选取一个随机平面，也就是随机选取 ![w](img/w.png "w") 和 ![b](img/b.png "b")，然后想必会在训练集中产生大量的错误分类，也就是说，![wtx+b](img/hu_5.png "wtx+b") 结果应该大于 0 的时候小于 0 ，应该小于 0 的时候大于 0 。这时候有一个错误损失，也就是说对于所有错误的分类，他们的平方和（least squared error） 为: ![平方和](img/hu_8.png "平方和") , 最小二乘法的目标就是让这个值趋于最小，对 ![w](img/w.png "w") 求导取 0 ，采用梯度下降算法，可以求出错误平方和的极值，求出最优的 ![w](img/w.png "w") ，也就是求出最优的超平面。（可以证明，如果基函数是指数族函数，求出的超平面是全局最优的）。
 
 那我们 SVM 算法的思路是怎样的呢？
 
@@ -174,7 +174,7 @@ d<D,米粒
 
 第一，它 “夹” 在两类样本点之间；第二，它离两类样本点中所有 “离它最近的点” ，都离它尽可能的远。如图所示: 
 
-![hu_2](http://data.apachecn.org/img/AiLearning/ml/6.SVM/hu_2.jpg "hu_2")
+![hu_2](img/hu_2.jpg "hu_2")
 
 在虚线上的点，就是我们所找到的离分解超平面最近的样本点，X 类中找到了一个，O 类找到了两个。我们需要分类超平面离这三个样本点都尽可能的远，也就是说，它处在两条虚线的中间。这就是我们找到的分界超平面。
 
@@ -184,13 +184,13 @@ d<D,米粒
 
 首先我们需要把刚刚说的最大间隔分类器的思想用数学公式表达出来。先定义几何间隔的概念，几何间隔就是在多维空间中一个多维点到一个超平面的距离，根据向量的知识可以算出来: 
 
-![hu_3](http://data.apachecn.org/img/AiLearning/ml/6.SVM/hu_3.png "hu_3")
+![hu_3](img/hu_3.png "hu_3")
 
-然后对于所有的支持向量，使他们到超平面 ![hu_5](http://data.apachecn.org/img/AiLearning/ml/6.SVM/hu_5.png "hu_5") 的距离最大，也就是
+然后对于所有的支持向量，使他们到超平面 ![hu_5](img/hu_5.png "hu_5") 的距离最大，也就是
 
-![hu_4](http://data.apachecn.org/img/AiLearning/ml/6.SVM/hu_4.png "hu_4")
+![hu_4](img/hu_4.png "hu_4")
 
-因为对于所有支持向量，他们 ![hu_5](http://data.apachecn.org/img/AiLearning/ml/6.SVM/hu_5.png "hu_5") 的值都是一定的，我们假设恒等于 1 ，那么上式变成了 ![hu_6](http://data.apachecn.org/img/AiLearning/ml/6.SVM/hu_6.png "hu_6") ,并且对于所有的样本点，满足 ![hu_10](http://data.apachecn.org/img/AiLearning/ml/6.SVM/hu_10.png "hu_10") 的约束，因此，可以利用拉格朗日乘数法计算出它的极值。也就是求出这个超平面。
+因为对于所有支持向量，他们 ![hu_5](img/hu_5.png "hu_5") 的值都是一定的，我们假设恒等于 1 ，那么上式变成了 ![hu_6](img/hu_6.png "hu_6") ,并且对于所有的样本点，满足 ![hu_10](img/hu_10.png "hu_10") 的约束，因此，可以利用拉格朗日乘数法计算出它的极值。也就是求出这个超平面。
 
 推导过程略为复杂，详细了解可以参考凸二次规划知识，结合 SMO 算法理解 SVM 计算超平面的详细过程。
 
@@ -203,13 +203,13 @@ d<D,米粒
 * 左边是求解基本的SVM问题
 * 右边是相关扩展
 
-![k_1](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_1.jpg "k_1")
+![k_1](img/k_1.jpg "k_1")
 
 <b>什么是 SVM ？</b>
 
 Support Vector Machine, 一个普通的 SVM 就是一条直线罢了，用来完美划分 linearly separable 的两类。但这又不是一条普通的直线，这是无数条可以分类的直线当中最完美的，因为它恰好在两个类的中间，距离两个类的点都一样远。而所谓的 Support vector 就是这些离分界线最近的『点』。如果去掉这些点，直线多半是要改变位置的。可以说是这些 vectors （主，点点） support （谓，定义）了 machine （宾，分类器）...
 
-![k_2](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_2.jpg "k_2")
+![k_2](img/k_2.jpg "k_2")
 
 所以谜底就在谜面上啊朋友们，只要找到了这些最靠近的点不就找到了 SVM 了嘛。
 
@@ -223,45 +223,45 @@ Support Vector Machine, 一个普通的 SVM 就是一条直线罢了，用来完
 
 于是自然而然可以得到重要表达 <b>I. direct representation</b>
 
-![k_7](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_7.png "k_7")
+![k_7](img/k_7.png "k_7")
 
 （可以把 margin 看作是 boundary 的函数，并且想要找到使得是使得 margin 最大化的boundary，而 margin(*) 这个函数是: 输入一个 boundary ，计算（正确分类的）所有苹果和香蕉中，到 boundary 的最小距离。）
 
 又有最大又有最小看起来好矛盾。实际上『最大』是对这个整体使用不同 boundary 层面的最大，『最小』是在比较『点』的层面上的最小。外层在比较 boundary 找最大的 margin ，内层在比较点点找最小的距离。
 
-其中距离，说白了就是点到直线的距离；只要定义带正负号的距离，是 {苹果+1} 面为正 {香蕉-1} 面为负的距离，互相乘上各自的 label ![k_8](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_8.png "k_8") ，就和谐统一民主富强了。
+其中距离，说白了就是点到直线的距离；只要定义带正负号的距离，是 {苹果+1} 面为正 {香蕉-1} 面为负的距离，互相乘上各自的 label ![k_8](img/k_8.png "k_8") ，就和谐统一民主富强了。
 
-![k_9](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_9.png "k_9")
+![k_9](img/k_9.png "k_9")
 
 到这里为止已经说完了所有关于SVM的直观了解，如果不想看求解，可以跳过下面一大段直接到 objective function 。
 
 直接表达虽然清楚但是求解无从下手。做一些简单地等价变换（分母倒上来）可以得到 <b>II. canonical representation </b> （敲黑板）
 
-![k_10](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_10.png "k_10")
+![k_10](img/k_10.png "k_10")
 
 要得到 <b>III. dual representation</b> 之前需要大概知道一下拉格朗日乘子法 (method of lagrange multiplier)，它是用在有各种约束条件(各种 "subject to" )下的目标函数，也就是直接可以求导可以引出 dual representation（怎么还没完摔）
 
-![k_11](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_11.png "k_11")
+![k_11](img/k_11.png "k_11")
 
 稍微借用刚刚数学表达里面的内容看个有趣的东西: 
 
 还记得我们怎么预测一个新的水果是苹果还是香蕉吗？我们代入到分界的直线里，然后通过符号来判断。
 
-刚刚w已经被表达出来了也就是说这个直线现在变成了:  ![k_12](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_12.png "k_12")
+刚刚w已经被表达出来了也就是说这个直线现在变成了:  ![k_12](img/k_12.png "k_12")
 
-看似仿佛用到了所有的训练水果，但是其中 ![k_13](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_13.png "k_13") 的水果都没有起到作用，剩下的就是小部分靠边边的 Support vectors 呀。
+看似仿佛用到了所有的训练水果，但是其中 ![k_13](img/k_13.png "k_13") 的水果都没有起到作用，剩下的就是小部分靠边边的 Support vectors 呀。
 
 <b>III. dual representation</b>
 
-![k_14](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_14.png "k_14")
+![k_14](img/k_14.png "k_14")
 
 <b>如果香蕉和苹果不能用直线分割呢？</b>
 
-![k_3](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_3.jpg "k_3")
+![k_3](img/k_3.jpg "k_3")
 
 Kernel trick. 
 
-其实用直线分割的时候我们已经使用了 kernel ，那就是线性 kernel , ![k_15](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_15.png "k_15")
+其实用直线分割的时候我们已经使用了 kernel ，那就是线性 kernel , ![k_15](img/k_15.png "k_15")
 
 如果要替换 kernel 那么把目标函数里面的内积全部替换成新的 kernel function 就好了，就是这么简单。
 
@@ -269,13 +269,13 @@ Kernel trick.
 
 <b>如果香蕉和苹果有交集呢？</b>
 
-![k_4](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_4.jpg "k_4")
+![k_4](img/k_4.jpg "k_4")
 
-![k_16](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_16.png "k_16")
+![k_16](img/k_16.png "k_16")
 
 <b>如果还有梨呢？</b>
 
-![k_5](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_5.jpg "k_5")
+![k_5](img/k_5.jpg "k_5")
 
 可以每个类别做一次 SVM: 是苹果还是不是苹果？是香蕉还是不是香蕉？是梨子还是不是梨子？从中选出可能性最大的。这是 one-versus-the-rest approach。
 
@@ -289,7 +289,7 @@ Kernel trick.
 
 <p>最后送一张图我好爱哈哈哈 (Credit: Burr Settles)</p>
 
-![k_6](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_6.png "k_6")
+![k_6](img/k_6.png "k_6")
 
 <p>[1] Bishop C M. Pattern recognition[J]. Machine Learning, 2006, 128.</p>
 <p>[2] Friedman J, Hastie T, Tibshirani R. The elements of statistical learning[M]. Springer, Berlin: Springer series in statistics, 2001.</p>
@@ -311,7 +311,7 @@ Kernel trick.
 
 SVM 的基本原理基本上已经说的差不多了，下面咱们就来看看 SVM 在实际应用该如何使用了。幸运的是，在 python 下面，sklearn 提供了一个非常好用的机器学习算法，我们调用相关的包就好啦。
 
-![sklearn_map](http://data.apachecn.org/img/AiLearning/ml/6.SVM/ml_map.png "sklearn")
+![sklearn_map](img/ml_map.png "sklearn")
 
 
 ## 小结

docs/ml/6.md

 # 第6章 支持向量机
 <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default"></script>
 
-![支持向量机_首页](http://data.apachecn.org/img/AiLearning/ml/6.SVM/SVM_1.jpg)
+![支持向量机_首页](img/SVM_1.jpg)
 
 ## 支持向量机 概述
 
@@ -14,14 +14,14 @@
 * 要给左右两边的点进行分类
 * 明显发现: 选择D会比B、C分隔的效果要好很多。
 
-![线性可分](http://data.apachecn.org/img/AiLearning/ml/6.SVM/SVM_3_linearly-separable.jpg)
+![线性可分](img/SVM_3_linearly-separable.jpg)
 
 
 ## 支持向量机 原理
 
 ### SVM 工作原理
 
-![k_2](http://data.apachecn.org/img/AiLearning/ml/6.SVM/k_2.jpg "k_2")
+![k_2](img/k_2.jpg "k_2")
 
 对于上述的苹果和香蕉，我们想象为2种水果类型的炸弹。（保证距离最近的炸弹，距离它们最远）
 
@@ -32,7 +32,7 @@
 * 数据可以通过画一条直线就可以将它们完全分开，这组数据叫`线性可分(linearly separable)`数据，而这条分隔直线称为`分隔超平面(separating hyperplane)`。
 * 如果数据集上升到1024维呢？那么需要1023维来分隔数据集，也就说需要N-1维的对象来分隔，这个对象叫做`超平面(hyperlane)`，也就是分类的决策边界。
 
-![分隔超平面](http://data.apachecn.org/img/AiLearning/ml/6.SVM/SVM_2_separating-hyperplane.jpg)
+![分隔超平面](img/SVM_2_separating-hyperplane.jpg)
 
 ### 寻找最大间隔
 
@@ -65,7 +65,7 @@ Support Vector Machines: Slide 12 Copyright © 2001, 2003, Andrew W. Moore Why M
 * 分类的结果:  $$f(x)=sign(w^Tx+b)$$  (sign表示>0为1，<0为-1，=0为0) 
 * 点到超平面的`几何间距`: $$d(x)=(w^Tx+b)/||w||$$  （||w||表示w矩阵的二范数=> $$\sqrt{w^T*w}$$, 点到超平面的距离也是类似的）
 
-![点到直线的几何距离](http://data.apachecn.org/img/AiLearning/ml/6.SVM/SVM_4_point2line-distance.jpg)
+![点到直线的几何距离](img/SVM_4_point2line-distance.jpg)
 
 > 拉格朗日乘子法
 
@@ -96,7 +96,7 @@ Support Vector Machines: Slide 12 Copyright © 2001, 2003, Andrew W. Moore Why M
     * 先求:  $$min_{w, b} L(w,b,\alpha)=\frac{1}{2} * ||w||^2 + \sum_{i=1}^{n} \alpha_i * [1 - label * (w^Tx+b)]$$
     * 就是求`L(w,b,a)`关于[w, b]的偏导数, 得到`w和b的值`，并化简为: `L和a的方程`。
     * 参考:  如果公式推导还是不懂，也可以参考《统计学习方法》李航-P103<学习的对偶算法>
-    ![计算拉格朗日函数的对偶函数](http://data.apachecn.org/img/AiLearning/ml/6.SVM/SVM_5_Lagrangemultiplier.png)
+    ![计算拉格朗日函数的对偶函数](img/SVM_5_Lagrangemultiplier.png)
 * 终于得到课本上的公式:  $$max_{\alpha} \left( \sum_{i=1}^{m} \alpha_i - \frac{1}{2} \sum_{i, j=1}^{m} label_i \ast label_j \ast \alpha_i \ast \alpha_j \ast <x_i, x_j> \right) $$
 * 约束条件:  $$a>=0$$ 并且 $$\sum_{i=1}^{m} a_i \ast label_i=0$$
 
@@ -104,12 +104,12 @@ Support Vector Machines: Slide 12 Copyright © 2001, 2003, Andrew W. Moore Why M
 
 参考地址: http://blog.csdn.net/wusecaiyun/article/details/49659183
 
-![松弛变量公式](http://data.apachecn.org/img/AiLearning/ml/6.SVM/SVM_松弛变量.jpg)
+![松弛变量公式](img/SVM_松弛变量.jpg)
 
 * 我们知道几乎所有的数据都不那么干净, 通过引入松弛变量来 `允许数据点可以处于分隔面错误的一侧`。
 * 约束条件:  $$C>=a>=0$$ 并且 $$\sum_{i=1}^{m} a_i \ast label_i=0$$
 * 总的来说: 
-    * ![松弛变量](http://data.apachecn.org/img/AiLearning/ml/6.SVM/松弛变量.png) 表示 `松弛变量`
+    * ![松弛变量](img/松弛变量.png) 表示 `松弛变量`
     * 常量C是 `惩罚因子`, 表示离群点的权重（用于控制“最大化间隔”和“保证大部分点的函数间隔小于1.0” ）
         * $$label*(w^Tx+b) > 1$$ and alpha = 0 (在边界外，就是非支持向量)
         * $$label*(w^Tx+b) = 1$$ and 0< alpha < C (在分割超平面上，就支持向量)
@@ -351,7 +351,7 @@ def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
 * 核函数并不仅仅应用于支持向量机，很多其他的机器学习算法也都用到核函数。最流行的核函数: 径向基函数(radial basis function)
 * 径向基函数的高斯版本，其具体的公式为: 
 
-![径向基函数的高斯版本](http://data.apachecn.org/img/AiLearning/ml/6.SVM/SVM_6_radial-basis-function.jpg)
+![径向基函数的高斯版本](img/SVM_6_radial-basis-function.jpg)
 
 ### 项目案例: 手写数字识别的优化（有核函数）
 

docs/ml/7.md

 # 第7章 集成方法 ensemble method
 
-![利用AdaBoost元算法提高分类](http://data.apachecn.org/img/AiLearning/ml/7.AdaBoost/adaboost_headPage.jpg "利用AdaBoost元算法提高分类")
+![利用AdaBoost元算法提高分类](img/adaboost_headPage.jpg "利用AdaBoost元算法提高分类")
 
 ## 集成方法: ensemble method（元算法: meta algorithm） 概述
 
@@ -52,7 +52,7 @@
 3. 然后统计子决策树的投票结果，得到最终的分类 就是 随机森林的输出结果。
 4. 如下图，假设随机森林中有3棵子决策树，2棵子树的分类结果是A类，1棵子树的分类结果是B类，那么随机森林的分类结果就是A类。
 
-![数据重抽样](http://data.apachecn.org/img/AiLearning/ml/7.RandomForest/数据重抽样.jpg)
+![数据重抽样](img/数据重抽样.jpg)
 
 > 待选特征的随机化
 
@@ -63,7 +63,7 @@
 左边是一棵决策树的特征选取过程，通过在待选特征中选取最优的分裂特征（别忘了前文提到的ID3算法，C4.5算法，CART算法等等），完成分裂。<br/>
 右边是一个随机森林中的子树的特征选取过程。<br/>
 
-![特征重抽样](http://data.apachecn.org/img/AiLearning/ml/7.RandomForest/特征重抽样.jpg)
+![特征重抽样](img/特征重抽样.jpg)
 
 > 随机森林 开发流程
 
@@ -317,7 +317,7 @@ def evaluate_algorithm(dataset, algorithm, n_folds, *args):
 
 > AdaBoost 工作原理
 
-![AdaBoost 工作原理](http://data.apachecn.org/img/AiLearning/ml/7.AdaBoost/adaboost_illustration.png "AdaBoost 工作原理")
+![AdaBoost 工作原理](img/adaboost_illustration.png "AdaBoost 工作原理")
 
 > AdaBoost 开发流程
 
@@ -344,7 +344,7 @@ def evaluate_algorithm(dataset, algorithm, n_folds, *args):
 
 > 项目流程图
 
-![AdaBoost代码流程图](http://data.apachecn.org/img/AiLearning/ml/7.AdaBoost/adaboost_code-flow-chart.jpg "AdaBoost代码流程图")
+![AdaBoost代码流程图](img/adaboost_code-flow-chart.jpg "AdaBoost代码流程图")
 
 基于单层决策树构建弱分类器
 * 单层决策树(decision stump, 也称决策树桩)是一种简单的决策树。
@@ -399,11 +399,11 @@ def loadDataSet(fileName):
 过拟合(overfitting, 也称为过学习)
 * 发现测试错误率在达到一个最小值之后有开始上升，这种现象称为过拟合。
 
-![过拟合](http://data.apachecn.org/img/AiLearning/ml/7.AdaBoost/过拟合.png)
+![过拟合](img/过拟合.png)
 
 * 通俗来说: 就是把一些噪音数据也拟合进去的，如下图。
 
-![过拟合](http://data.apachecn.org/img/AiLearning/ml/7.AdaBoost/过拟合图解.png)
+![过拟合](img/过拟合图解.png)
 
 > 训练算法: 在数据上，利用 adaBoostTrainDS() 函数训练出一系列的分类器
 
@@ -466,7 +466,7 @@ D （样本权重）的目的是为了计算错误概率:  weightedError = D.T*e
   样本的权重值: 如果一个值误判的几率越小，那么 D 的样本权重越小
 ```
 
-![AdaBoost算法权重计算公式](http://data.apachecn.org/img/AiLearning/ml/7.AdaBoost/adaboost_alpha.png "AdaBoost算法权重计算公式")
+![AdaBoost算法权重计算公式](img/adaboost_alpha.png "AdaBoost算法权重计算公式")
 
 > 测试算法: 我们拥有两个数据集。在不采用随机抽样的方法下，我们就会对 AdaBoost 和 Logistic 回归的结果进行完全对等的比较。
 
@@ -556,7 +556,7 @@ ROC Curves
 
 * ROC 曲线: 最佳的分类器应该尽可能地处于左上角
 
-![ROC曲线](http://data.apachecn.org/img/AiLearning/ml/7.AdaBoost/ROC曲线.png)
+![ROC曲线](img/ROC曲线.png)
 
 * 对不同的 ROC 曲线进行比较的一个指标是曲线下的面积(Area Unser the Curve, AUC). 
 
@@ -615,7 +615,7 @@ python实现可以查阅[UnbalancedDataset](https://github.com/scikit-learn-cont
 
 * 基于代价函数的分类器决策控制: `TP*(-5)+FN*1+FP*50+TN*0`
 
-![代价函数](http://data.apachecn.org/img/AiLearning/ml/7.AdaBoost/代价函数.png)
+![代价函数](img/代价函数.png)
 
 这种方式叫做 cost sensitive learning，Weka 中相应的框架可以实现叫[CostSensitiveClassifier](http://weka.sourceforge.net/doc.dev/weka/classifiers/meta/CostSensitiveClassifier.html)
 

docs/ml/8.md

 # 第8章 预测数值型数据: 回归
 <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default"></script>
 
-![预测数值型数据回归首页](http://data.apachecn.org/img/AiLearning/ml/8.Regression/预测数值型数据回归首页.png "回归Regression首页")
+![预测数值型数据回归首页](img/预测数值型数据回归首页.png "回归Regression首页")
 
 ## 回归（Regression） 概述
 
@@ -30,11 +30,11 @@ HorsePower = 0.0015 * annualSalary - 0.99 * hoursListeningToPublicRadio
 
 平方误差可以写做（其实我们是使用这个函数作为 loss function）: 
 
-![平方误差](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_18.png)
+![平方误差](img/LinearR_18.png)
 
-用矩阵表示还可以写做 ![平方误差_2](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_19.png) 。如果对 w 求导，得到 ![平方误差_3](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_20.png) ，令其等于零，解出 w 如下（具体求导过程为: http://blog.csdn.net/nomadlx53/article/details/50849941 ）:
+用矩阵表示还可以写做 ![平方误差_2](img/LinearR_19.png) 。如果对 w 求导，得到 ![平方误差_3](img/LinearR_20.png) ，令其等于零，解出 w 如下（具体求导过程为: http://blog.csdn.net/nomadlx53/article/details/50849941 ）:
 
-![回归系数的最佳估计计算公式](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_1.png)
+![回归系数的最佳估计计算公式](img/LinearR_1.png)
 
 #### 1.1、线性回归 须知概念
 
@@ -42,7 +42,7 @@ HorsePower = 0.0015 * annualSalary - 0.99 * hoursListeningToPublicRadio
 
 因为我们在计算回归方程的回归系数时，用到的计算公式如下: 
 
-![回归系数的最佳估计计算公式](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_1.png)
+![回归系数的最佳估计计算公式](img/LinearR_1.png)
 
 需要对矩阵求逆，因此这个方程只在逆矩阵存在的时候适用，我们在程序代码中对此作出判断。
 判断矩阵是否可逆的一个可选方案是: 
@@ -88,7 +88,7 @@ HorsePower = 0.0015 * annualSalary - 0.99 * hoursListeningToPublicRadio
 
 根据下图中的点，找出该数据的最佳拟合直线。
 
-![线性回归数据示例图](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_2.png "线性回归数据示例图")
+![线性回归数据示例图](img/LinearR_2.png "线性回归数据示例图")
 
 数据格式为: 
 
@@ -178,7 +178,7 @@ def regression1():
 
 ##### 1.5.3、线性回归 拟合效果
 
-![线性回归数据效果图](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_3.png "线性回归数据效果图")
+![线性回归数据效果图](img/LinearR_3.png "线性回归数据效果图")
 
 
 ### 2、局部加权线性回归
@@ -187,21 +187,21 @@ def regression1():
 
 一个方法是局部加权线性回归（Locally Weighted Linear Regression，LWLR）。在这个算法中，我们给预测点附近的每个点赋予一定的权重，然后与 线性回归 类似，在这个子集上基于最小均方误差来进行普通的回归。我们需要最小化的目标函数大致为:
 
-![局部加权线性回归回归系数公式](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_21.png)
+![局部加权线性回归回归系数公式](img/LinearR_21.png)
 
 目标函数中 w 为权重，不是回归系数。与 kNN 一样，这种算法每次预测均需要事先选取出对应的数据子集。该算法解出回归系数 w 的形式如下: 
 
-![局部加权线性回归回归系数公式](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_4.png)
+![局部加权线性回归回归系数公式](img/LinearR_4.png)
 
 其中 W 是一个矩阵，用来给每个数据点赋予权重。$\hat{w}$ 则为回归系数。 这两个是不同的概念，请勿混用。
 
 LWLR 使用 “核”（与支持向量机中的核类似）来对附近的点赋予更高的权重。核的类型可以自由选择，最常用的核就是高斯核，高斯核对应的权重如下: 
 
-![局部加权线性回归高斯核](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_23.png)
+![局部加权线性回归高斯核](img/LinearR_23.png)
 
 这样就构建了一个只含对角元素的权重矩阵 **w**，并且点 x 与 x(i) 越近，w(i) 将会越大。上述公式中包含一个需要用户指定的参数 k ，它决定了对附近的点赋予多大的权重，这也是使用 LWLR 时唯一需要考虑的参数，下面的图给出了参数 k 与权重的关系。
 
-![参数k与权重的关系](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_6.png)
+![参数k与权重的关系](img/LinearR_6.png)
 
 上面的图是 每个点的权重图（假定我们正预测的点是 x = 0.5），最上面的图是原始数据集，第二个图显示了当 k = 0.5 时，大部分的数据都用于训练回归模型；而最下面的图显示当 k=0.01 时，仅有很少的局部点被用于训练回归模型。
 
@@ -222,7 +222,7 @@ LWLR 使用 “核”（与支持向量机中的核类似）来对附近的点
 
 我们仍然使用上面 线性回归 的数据集，对这些点进行一个 局部加权线性回归 的拟合。
 
-![局部加权线性回归数据示例图](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_2.png)
+![局部加权线性回归数据示例图](img/LinearR_2.png)
 
 数据格式为: 
 
@@ -340,7 +340,7 @@ def regression2():
 
 ##### 2.2.3、局部加权线性回归 拟合效果
 
-![局部加权线性回归数据效果图](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_7.png)
+![局部加权线性回归数据效果图](img/LinearR_7.png)
 
 上图使用了 3 种不同平滑值绘出的局部加权线性回归的结果。上图中的平滑系数 k =1.0，中图 k = 0.01，下图 k = 0.003 。可以看到，k = 1.0 时的使所有数据等比重，其模型效果与基本的线性回归相同，k=0.01时该模型可以挖出数据的潜在规律，而 k=0.003时则考虑了太多的噪声，进而导致了过拟合现象。
 
@@ -452,7 +452,7 @@ def abaloneTest():
 
 ### 4、缩减系数来 “理解” 数据
 
-如果数据的特征比样本点还多应该怎么办？是否还可以使用线性回归和之前的方法来做预测？答案是否定的，即我们不能再使用前面介绍的方法。这是因为在计算 ![矩阵求逆](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_8.png) 的时候会出错。
+如果数据的特征比样本点还多应该怎么办？是否还可以使用线性回归和之前的方法来做预测？答案是否定的，即我们不能再使用前面介绍的方法。这是因为在计算 ![矩阵求逆](img/LinearR_8.png) 的时候会出错。
 
 如果特征比样本点还多(n > m)，也就是说输入数据的矩阵 x 不是满秩矩阵。非满秩矩阵求逆时会出现问题。
 
@@ -460,14 +460,14 @@ def abaloneTest():
 
 #### 4.1、岭回归
 
-简单来说，岭回归就是在矩阵 ![矩阵_1](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_9.png) 上加一个 λI 从而使得矩阵非奇异，进而能对 ![矩阵_2](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_10.png ) 求逆。其中矩阵I是一个 n * n （等于列数） 的单位矩阵，
+简单来说，岭回归就是在矩阵 ![矩阵_1](img/LinearR_9.png) 上加一个 λI 从而使得矩阵非奇异，进而能对 ![矩阵_2](img/LinearR_10.png ) 求逆。其中矩阵I是一个 n * n （等于列数） 的单位矩阵，
 对角线上元素全为1，其他元素全为0。而λ是一个用户定义的数值，后面会做介绍。在这种情况下，回归系数的计算公式将变成: 
 
-![岭回归的回归系数计算](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_11.png )
+![岭回归的回归系数计算](img/LinearR_11.png )
 
 岭回归最先用来处理特征数多于样本数的情况，现在也用于在估计中加入偏差，从而得到更好的估计。这里通过引入 λ 来限制了所有 w 之和，通过引入该惩罚项，能够减少不重要的参数，这个技术在统计学中也叫作 `缩减(shrinkage)`。
 
-![岭回归](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_22.png)
+![岭回归](img/LinearR_22.png)
 
 缩减方法可以去掉不重要的参数，因此能更好地理解数据。此外，与简单的线性回归相比，缩减法能取得更好的预测效果。
 
@@ -551,7 +551,7 @@ def regression3():
 
 ##### 4.1.2、岭回归在鲍鱼数据集上的运行效果
 
-![岭回归的运行效果](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_12.png)
+![岭回归的运行效果](img/LinearR_12.png)
 
 上图绘制出了回归系数与 log(λ) 的关系。在最左边，即 λ 最小时，可以得到所有系数的原始值（与线性回归一致）；而在右边，系数全部缩减为0；在中间部分的某值将可以取得最好的预测效果。为了定量地找到最佳参数值，还需要进行交叉验证。另外，要判断哪些变量对结果预测最具有影响力，在上图中观察它们对应的系数大小就可以了。
 
@@ -560,13 +560,13 @@ def regression3():
 
 在增加如下约束时，普通的最小二乘法回归会得到与岭回归一样的公式: 
 
-![lasso_1](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_13.png)
+![lasso_1](img/LinearR_13.png)
 
 上式限定了所有回归系数的平方和不能大于 λ 。使用普通的最小二乘法回归在当两个或更多的特征相关时，可能会得到一个很大的正系数和一个很大的负系数。正是因为上述限制条件的存在，使用岭回归可以避免这个问题。
 
 与岭回归类似，另一个缩减方法lasso也对回归系数做了限定，对应的约束条件如下: 
 
-![lasso_2](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_14.png)
+![lasso_2](img/LinearR_14.png)
 
 唯一的不同点在于，这个约束条件使用绝对值取代了平方和。虽然约束形式只是稍作变化，结果却大相径庭: 在 λ 足够小的时候，一些系数会因此被迫缩减到 0.这个特性可以帮助我们更好地理解数据。
 
@@ -633,7 +633,7 @@ def regression4():
 
 ##### 4.3.2、逐步线性回归在鲍鱼数据集上的运行效果
 
-![逐步线性回归运行效果](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_15.png)
+![逐步线性回归运行效果](img/LinearR_15.png)
 
 逐步线性回归算法的主要优点在于它可以帮助人们理解现有的模型并作出改进。当构建了一个模型后，可以运行该算法找出重要的特征，这样就有可能及时停止对那些不重要特征的收集。最后，如果用于测试，该算法每100次迭代后就可以构建出一个模型，可以使用类似于10折交叉验证的方法比较这些模型，最终选择使误差最小的模型。
 
@@ -646,13 +646,13 @@ def regression4():
 
 任何时候，一旦发现模型和测量值之间存在差异，就说出现了误差。当考虑模型中的 “噪声” 或者说误差时，必须考虑其来源。你可能会对复杂的过程进行简化，这将导致在模型和测量值之间出现 “噪声” 或误差，若无法理解数据的真实生成过程，也会导致差异的产生。另外，测量过程本身也可能产生 “噪声” 或者问题。下面我们举一个例子，我们使用 `线性回归` 和 `局部加权线性回归` 处理过一个从文件导入的二维数据。
 
-![生成公式](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_16.png)
+![生成公式](img/LinearR_16.png)
 
 其中的 N(0, 1) 是一个均值为 0、方差为 1 的正态分布。我们尝试过仅用一条直线来拟合上述数据。不难想到，直线所能得到的最佳拟合应该是 3.0+1.7x 这一部分。这样的话，误差部分就是 0.1sin(30x)+0.06N(0, 1) 。在上面，我们使用了局部加权线性回归来试图捕捉数据背后的结构。该结构拟合起来有一定的难度，因此我们测试了多组不同的局部权重来找到具有最小测试误差的解。
 
 下图给出了训练误差和测试误差的曲线图，上面的曲面就是测试误差，下面的曲线是训练误差。我们根据 预测鲍鱼年龄 的实验知道: 如果降低核的大小，那么训练误差将变小。从下图开看，从左到右就表示了核逐渐减小的过程。
 
-![偏差方差图](http://data.apachecn.org/img/AiLearning/ml/8.Regression/LinearR_17.png)
+![偏差方差图](img/LinearR_17.png)
 
 一般认为，上述两种误差由三个部分组成: 偏差、测量误差和随机噪声。局部加权线性回归 和 预测鲍鱼年龄 中，我们通过引入了三个越来越小的核来不断增大模型的方差。
 

docs/ml/9.md

 # 第9章 树回归
 <script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default"></script>
 
-![预测数值型数据回归首页](http://data.apachecn.org/img/AiLearning/ml/9.TreeRegression/TreeRegression_headPage_xy.png "树回归首页")
+![预测数值型数据回归首页](img/TreeRegression_headPage_xy.png "树回归首页")
 
 ## 树回归 概述
 
@@ -124,10 +124,10 @@ data1.txt 文件中存储的数据格式如下:
 > 分析数据: 绘出数据的二维可视化显示结果，以字典方式生成树
 
 基于 CART 算法构建回归树的简单数据集  
-![基于 CART 算法构建回归树的简单数据集](http://data.apachecn.org/img/AiLearning/ml/9.TreeRegression/RegTree_1.png)  
+![基于 CART 算法构建回归树的简单数据集](img/RegTree_1.png)  
 
 用于测试回归树的分段常数数据集  
-![用于测试回归树的分段常数数据集](http://data.apachecn.org/img/AiLearning/ml/9.TreeRegression/RegTree_2.png)  
+![用于测试回归树的分段常数数据集](img/RegTree_2.png)  
 
 
 > 训练算法: 构造树的数据结构
@@ -376,7 +376,7 @@ def prune(tree, testData):
 
 决策树相比于其他机器学习算法的优势之一在于结果更易理解。很显然，两条直线比很多节点组成一棵大树更容易解释。模型树的可解释性是它优于回归树的特点之一。另外，模型树也具有更高的预测准确度。
 
-![分段线性数据](http://data.apachecn.org/img/AiLearning/ml/9.TreeRegression/RegTree_3.png)
+![分段线性数据](img/RegTree_3.png)
 
 将之前的回归树的代码稍作修改，就可以在叶节点生成线性模型而不是常数值。下面将利用树生成算法对数据进行划分，且每份切分数据都能很容易被线性模型所表示。这个算法的关键在于误差的计算。
 
@@ -451,7 +451,7 @@ def linearSolve(dataSet):
 
 ### 3.3、模型树 运行结果
 
-![模型树运行结果](http://data.apachecn.org/img/AiLearning/ml/9.TreeRegression/RegTree_4.png)
+![模型树运行结果](img/RegTree_4.png)
 
 
 ## 4、树回归 项目案例
@@ -490,7 +490,7 @@ def linearSolve(dataSet):
 
 > 分析数据: 绘出数据的二维可视化显示结果，以字典方式生成树
 
-![骑自行车速度和智商之间的关系](http://data.apachecn.org/img/AiLearning/ml/9.TreeRegression/RegTree_5.png)
+![骑自行车速度和智商之间的关系](img/RegTree_5.png)
 
 > 训练算法: 模型树的构建
 
@@ -598,7 +598,7 @@ R^2 判定系数就是拟合优度判定系数，它体现了回归模型中自
 
 如果能让用户不需要任何指令就可以按照他们自己的方式来分析数据，就不需要对数据做出过多解释。其中一个能同时支持数据呈现和用户交互的方式就是构建一个图形用户界面(GUI，Graphical User Interface)，如图9-7所示。
 
-![GUI示例图](http://data.apachecn.org/img/AiLearning/ml/9.TreeRegression/GUI示例图.png "GUI示例图")
+![GUI示例图](img/GUI示例图.png "GUI示例图")
 
 ### 5.2、用 Tkinter 创建 GUI
 
@@ -613,7 +613,7 @@ MatPlotlib 的构建程序包含一个前端，也就是面向用户的一些代
 
 ### 5.4、用treeExplore 的GUI构建的模型树示例图
 
-![取得更好预测效果的GUI示例图](http://data.apachecn.org/img/AiLearning/ml/9.TreeRegression/GUI更好的示例图.png "取得更好预测效果的GUI示例图")
+![取得更好预测效果的GUI示例图](img/GUI更好的示例图.png "取得更好预测效果的GUI示例图")
 
 [完整代码地址](https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/9.RegTrees/treeExplore.py): <https://github.com/apachecn/AiLearning/blob/master/src/py2.x/ml/9.RegTrees/treeExplore.py>