├── README.md
├── week1.md
├── week10.md
├── week2.md
├── week3.md
├── week4.md
├── week5.md
├── week6.md
├── week7.md
├── week8-1.md
├── week8-2.md
├── week9-1.md
└── week9-2.md
/README.md:
--------------------------------------------------------------------------------
1 | > 记录学习`吴恩达`机器学习视频的笔记，主要是参考视频和`李航博士`的《统计学习方法》、`周志华老师`的《机器学习》以及`黄海广博士`的相关资料。以示感谢！
2 |
3 | 脑图为主要的学习内容
4 |
5 | 
6 |
--------------------------------------------------------------------------------
/week1.md:
--------------------------------------------------------------------------------
1 | 吴恩达笔记-第一周
2 |
3 | 在第一周中讲解的内容包含：
4 |
5 | - 监督学习和无监督学习
6 | - 单变量线性回归问题
7 | - 代价函数
8 | - 梯度下降算法
9 |
10 |
11 |
12 | ### 监督学习Supervised Learning
13 |
14 | #### 利用监督学习预测波士顿房价（回归问题）
15 |
16 | - 大多数情况下，可能会拟合直线
17 | - 有时候用二次曲线去拟合效果可能会更好的
18 |
19 | 
20 |
21 | 在监督学习中，我们给学习算法一个数据集，比如一系列房子的数据，给定数据集中每个样本的正确价格，即它们实际的售价然后运用学习算法，算出更多的答案，我们需要估算一个连续值的结果，这属于**回归问题**
22 |
23 |
24 |
25 | #### 利用监督学习来推测乳腺癌良性与否（分类问题）
26 |
27 | 
28 |
29 | - 横轴表示肿瘤的大小
30 | - 纵轴表示1表示恶性，0表示良性
31 |
32 | 机器学习的问题就在于，估算出肿瘤是恶性的或是良性的概率，属于**分类问题**。
33 |
34 | 分类指的是，我们试着推测出离散的输出值：0或1良性或恶性，而事实上在分类问题中，输出可能不止两个值。
35 |
36 | 比如说可能有三种乳腺癌，所以希望预测离散输出0、1、2、3。0 代表良性，1 表示第1类乳腺癌，2表示第2类癌症，3表示第3类，也是分类问题。
37 |
38 | #### 应用
39 |
40 | - 垃圾邮件问题
41 | - 疾病分类问题
42 |
43 | -----
44 |
45 | ### 无监督学习Unsupervised Learning
46 |
47 | - 监督学习中，数据是有标签的
48 | - 无监督学习中，数据是没有标签，主要提到了聚类算法
49 |
50 | 
51 |
52 | #### 应用
53 |
54 | - 基因学的理解应用
55 | - 社交网络分析
56 | - 组织大型计算机集群
57 | - 细分市场
58 | - 新闻事件分类
59 |
60 | -----
61 |
62 | ### 单变量线性回归Linear Regression with One Variable
63 |
64 | #### 房价问题
65 |
66 | 横轴是不同的房屋面积，纵轴是房屋的出售价格。
67 |
68 | 监督学习：对于每个数据来说，给出了正确的答案。在监督学习中，我们有一个给定的数据，叫做**训练集training set**
69 |
70 | 回归问题：根据之前的数据，预测出一个准确的输出值。
71 |
72 | 分类问题：预测离散的输出值，例如寻找癌症肿瘤，并想要确定肿瘤是良性的还是恶性的，属于0/1离散输出的问题
73 |
74 | 
75 |
76 | #### 监督学习工作模式
77 |
78 | 
79 |
80 | 学习过程解释：
81 |
82 | - 将训练集中的房屋价格喂给学习算法
83 | - 学习算法工作，输出一个函数，用h表示
84 | - h表示hypothesis，代表的是学习算法的解决方案或者函数。
85 | - h根据输入的x值得到y值，因此h是x到的y的一个函数映射
86 | - 可能的表达式：$h_{\theta}(x)=\theta_0+\theta_1x$，只有一个特征或者出入变量，称为**单变量线性回归问题**
87 |
88 | ### 代价函数cost function
89 |
90 | 代价函数也称之为**平方误差函数，平方误差代价函数**
91 |
92 | #### 函数解释
93 |
94 | - m：训练样本的个数
95 | - $h_{\theta}(x)=\theta_0+\theta_1x$：假设函数
96 | - $\theta_0$ 和$\theta_1$：表示两个模型参数，即直线的斜率和y轴上的截距
97 |
98 | 
99 |
100 | #### 建模误差
101 |
102 | ##### 建模目标
103 |
104 | 1. 图中红色的点表示真实值$y_i$，真实的数据集
105 | 2. $h(x)$表示的是通过模型得到的预测值
106 | 3. 目标：选择出可以使得建模误差的平方和能够最小的模型参数
107 |
108 | $$
109 | J(\theta_0,\theta_1)=\frac{1}{2m}\sum^m_{i=1}(h_{\theta}(x^{(i)})-y^{(i)})^2
110 | $$
111 |
112 | 
113 |
114 | 
115 |
116 |
117 |
118 | #### 代价函数直观解释1
119 |
120 | 本例中是通过假设$\theta_0=0$来进行，假设函数$h(x)$是关于x的函数，代价函数$J(\theta_0,\theta_1)$是关于$\theta$的函数，使得代价函数最小化
121 |
122 | 
123 |
124 | #### 代价函数直观解释2
125 |
126 | 通过等高线图来进行解释。通过绘制出等高线图可以看出来，必定存在某个点，使得代价函数最小
127 |
128 | 
129 |
130 | 
131 |
132 | ### 梯度下降Gradient Descent
133 |
134 | #### 思想
135 |
136 | > 梯度下降是一个用来求函数最小值的算法。
137 |
138 | - 背后的思想：开始随机选取一个参数的组合$(\theta_0,\theta_1,…,\theta_n)$计算代价函数，然后我们寻找下一个能让代价函数值下降最多的参数组合。
139 |
140 | - 持续这么做，直到一个局部最小值（**local minimum**），因为并没有尝试完所有的参数组合，所以不能确定得到的局部最小值是否是全局最小值（**global minimum**）
141 | - 
142 |
143 |
144 |
145 | 
146 |
147 |
148 |
149 | #### 批量梯度下降**batch gradient descent**
150 |
151 | 算法公式为
152 |
153 | 
154 |
155 | **特点：需要同步更新两个参数**
156 |
157 | #### 梯度下降直观解释
158 |
159 | 算法公式：$$\theta_j:=\theta_j-\alpha \frac {\partial J(\theta)}{\partial \theta_j}$$
160 |
161 | 具体描述：对$\theta$赋值，使得$J(\theta)$按照梯度下降最快的方向进行，一直迭代下去，最终得到局部最小值。
162 |
163 | 学习率：$\alpha$是学习率它决定了我们沿着能让代价函数下降程度最大的方向向下迈出的步子有多大。
164 |
165 | - 学习率太小：收敛速度慢需要很长的时间才会到达全局最低点
166 | - 学习率太大：可能越过最低点，甚至可能无法收敛
167 |
168 | 
169 |
170 | 
171 |
172 | ### 梯度下降的线性回归GradientDescent-For-LinearRegression
173 |
174 | 梯度下降是很常用的算法，它不仅被用在线性回归上和线性回归模型、平方误差代价函数。将梯度下降和代价函数相结合。
175 |
176 | #### 梯度下降VS线性回归算法
177 |
178 | 
179 |
180 | 对之前的线性回归问题运用梯度下降法，关键在于求出代价函数的导数，即：
181 | $$
182 | \frac {\partial J(\theta_0,\theta_1)}{\partial \theta_j}=\frac{1}{2m}\frac {\partial \sum^m_{i=1}(h_{\theta}(x^{(i)})-y^{(i)})^2}{\partial \theta_j}
183 | $$
184 | $j=0$：
185 | $$
186 | \frac {\partial J(\theta_0,\theta_1)}{\partial \theta_0}=\frac{1}{m}\sum^m_{i=1}(h_\theta{(x^{(i)})-y^{(i)}})
187 | $$
188 | $j=1$:
189 | $$
190 | \frac {\partial J(\theta_0,\theta_1)}{\partial \theta_1}=\sum^{m}_{i=1}((h_\theta(x^{(i)})-y^{(i)})\cdot x^{(i)})
191 | $$
192 | 因此将算法改成：
193 | $$
194 | \theta_0 := \theta_0- \alpha \frac{1}{m}\sum^m_{i=1}(h_\theta{(x^{(i)})-y^{(i)}})
195 | $$
196 |
197 | $$
198 | \theta_1 := \theta_1- \alpha \frac {1}{m}\sum^{m}_{i=1}((h_\theta(x^{(i)})-y^{(i)})\cdot x^{(i)})
199 | $$
200 |
201 | 这种梯度下降的算法称之为“批量梯度下降算法”，主要特点：
202 |
203 | - 在梯度下降的每一步中，我们都用到了所有的训练样本
204 | - 在梯度下降中，在计算微分求导项时，我们需要进行求和运算,需要对所有m个训练样本求和
--------------------------------------------------------------------------------
/week10.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: 吴恩达笔记12
3 | top: false
4 | cover: false
5 | toc: true
6 | mathjax: true
7 | copyright: true
8 | date: 2019-12-09 16:11:28
9 | password:
10 | summary:
11 | tags:
12 | - OCR
13 | - 滑动窗口
14 | categories:
15 | - Machine learning
16 | - 吴恩达
17 | ---
18 |
19 |
20 | 本周主要是介绍了两个方面的内容，一个是如何进行大规模的机器学习，另一个是关于图片文字识别OCR 的案例
21 |
22 |
23 |
24 | ### 大规模机器学习(Large Scale Machine Learning)
25 |
26 | 在低方差的模型中，增加数据集的规模可以帮助我们获取更好的结果。但是当数据集增加到100万条的大规模的时候，我们需要考虑：大规模的训练集是否真的有必要。获取1000个训练集也可以获得更好的效果，通过绘制学习曲线来进行判断。
27 |
28 | 
29 |
30 |
31 |
32 | #### 随机梯度下降法Stochastic Gradient Descent
33 |
34 | 如果需要对大规模的数据集进行训练，可以尝试使用随机梯度下降法来代替批量梯度下降法。随机梯度下降法的代价函数是
35 | $$
36 | \operatorname{Cost}\left(\theta,\left(x^{(i)}, y^{(i)}\right)\right)=\frac{1}{2}\left(h_{\theta}\left(x^{(i)}\right)-y^{(i)}\right)^{2}
37 | $$
38 | 具体算法的过程为
39 |
40 | 1. 先对训练集进行随机的洗牌操作，打乱数据的顺序
41 | 2. 重复如下过程：
42 |
43 | 
44 |
45 | 3. 随机梯度下降算法是每次计算之后更新参数$\theta$，不需要现将所有的训练集求和。
46 |
47 | **算法可能存在的问题**
48 |
49 | > 不是每一步都是朝着”正确”的方向迈出的。因此算法虽然会逐渐走向全 局最小值的位置，但是可能无法站到那个最小值的那一点，而是在最小值点附近徘徊。
50 |
51 | 
52 |
53 |
54 |
55 | #### 小批量梯度下降 Mini-Batch Gradient Descent
56 |
57 | 小批量梯度下降算法是介于批量梯度下降算法和梯度下降算法之间的算法。每计算常数b次训练实例，便更新一次参数$\theta$。参数b通常在2-100之间。
58 |
59 | 
60 |
61 | #### 随机梯度下降收敛
62 |
63 | 随机梯度下降算法的调试和学习率$\alpha$的选取
64 |
65 | - 在**批量梯度下降算法**中，可以令代价函数$J$为迭代次数的函数，绘制图表，根据图表来 判断梯度下降是否收敛；大规模的训练集情况下，此举不现实，计算代价太大
66 | - 在随机梯度下降中，更新$\theta$之前都计算一次代价，然后迭代$X$后求出$X$对训练实例的计算代价的平均值，最后绘制次数$X$和代价平均值之间的图像
67 |
68 | 
69 |
70 |
71 |
72 | 随着不断地靠近全局最小值，通过减小学习率，迫使算法收敛而非在最小值最近徘徊。
73 |
74 | 
75 |
76 | #### 映射化简和数据并行Map Reduce and Data Parallelism
77 |
78 | 映射化简和数据并行对于大规模机器学习问题而言是非常重要的概念。如果我们能够将我们的数据集分配给不多台 计算机，让每一台计算机处理数据集的一个子集，然后我们将计所的结果汇总在求和。这样 的方法叫做**映射简化**。
79 |
80 | 如果任何学习算法能够表达为对训练集的函数求和，那么便能将这个任务分配给多台计算机（或者同台计算机的不同CPU核心），达到加速处理的目的。比如400个训练实例，分配给4台计算机进行处理：
81 |
82 | 
83 |
84 | ### 图片文字识别(Application Example: Photo OCR)
85 |
86 | #### 问题描述和流程图
87 |
88 | 图像文字识别应用所作的事是从一张给定的图片中识别文字。
89 |
90 | 
91 |
92 | 基本步骤包含：
93 |
94 | 1. **文字侦测(Text detection)**——将图片上的文字与其他环境对象分离开来
95 | 2. **字符切分(Character segmentation)**——将文字分割成一个个单一的字符
96 | 3. **字符分类(Characterclassification)**——确定每一个字符是什么 可以用任务流程图来表
97 |
98 | 每项任务可以有不同的团队来负责处理。
99 |
100 | 
101 |
102 | #### 滑动窗口Sliding windows
103 |
104 | ##### 图片识别
105 |
106 | 滑动窗口是一项用来从图像中抽取对象的技术。看一个栗子：
107 |
108 | 
109 |
110 | 如果我们需要从上面的图形中提取出来行人：
111 |
112 | - 用许多固定尺寸的图片来训练一个能够准确识别行人的**模型**
113 | - 用上面训练识别行人的模型时所采用的**图片尺寸**在我们要进行行人识别的图片上进行**剪裁**
114 | - 剪裁得到的切片交给模型，让**模型判断是否为行人**
115 | - 重复循环上述的操作步骤，直至将图片全部检测完。
116 |
117 | ##### 文字识别
118 |
119 | 滑动窗口技术也被用于文字识别。
120 |
121 | - 首先训练模型能够区分字符与非字符
122 | - 然后运用滑动窗口技术识别字符
123 | - 完成字符的识别，将识别得出的区域进行扩展
124 | - 将重叠的区域进行合并，以宽高比作为过滤条件，过滤掉高度比宽度更大的区域
125 |
126 | 
127 |
128 | 上述步骤是**文字侦察阶段**，接下来通过训练出一个模型来讲文字分割成一个个字符，需要的训练集由单个字符的图片和两个相连字符之间的图片来训练模型。
129 |
130 | 
131 |
132 | 训练完成之后，可以通过滑动窗口技术来进行字符识别。该阶段属于**字符切分阶段**。
133 |
134 | 
135 |
136 | 最后通过利用神经网络、支持向量机、或者逻辑回归等算法训练出一个分类器，属于是**字符分类阶段**。
137 |
138 | #### 获取大量数据和人工数据
139 |
140 | > 如果我们的模型是低方差的，那么获得更多的数据用于训练模型，是能够有更好的效果。
141 |
142 | 获取大量数据的方法有
143 |
144 | - 人工数据合成
145 | - 手动收集、标记数据
146 | - 众包
147 |
148 | #### 上限分析Ceiling Analysis
149 |
150 | 在机器学习的应用中，我们通常需要通过几个步骤才能进行最终的预测，我们如何能够 知道哪一部分最值得我们花时间和精力去改善呢?这个问题可以通过上限分析来回答。
151 |
152 | 
153 |
154 | 回到文字识别的应用中，流程图如下：
155 |
156 | 我们发现每个部分的输出都是下个部分的输入。在上限分析中，我们选取其中的某个部分，手工提供100%争取的输出结果，然后看整体的效果提升了多少。
157 |
158 | - 如果提升的比例比较明显，可以考虑在这个方向投入更过的时间和经历
159 | - 如果提升的效果微乎其微，意味着某个部分已经做的足够好了
160 |
161 | 
162 |
--------------------------------------------------------------------------------
/week2.md:
--------------------------------------------------------------------------------
1 | 吴恩达笔记-第二周
2 |
3 | 本周主要讲解的内容是：
4 |
5 | - 多维特征
6 | - 多变量梯度下降
7 | - 梯度下降法实践
8 | - 正规方程
9 |
10 |
11 |
12 | ----
13 |
14 | ### 多维特征Multiple Features
15 |
16 | 还是利用房价模型的例子，增加了更多的特征，比如：房间楼层、房间数量、地理位置等，构成了一个含有多个变量的模型
17 |
18 | 
19 |
20 | n：代表的是特征的数量
21 |
22 | $x^{(i)}$：代表第$i$个训练实例，是特征矩阵中的第$i$行，是一个**向量vector**
23 |
24 | $x^{(i)}_{j}$：表示的是第$i$个训练实例的第$j$个特征；i表示行，j表示列
25 |
26 | **支持多变量的假设$h$表示为：**
27 | $$
28 | h_{\theta}(x)=\theta_0+\theta_1x_1+…+\theta_nx_n
29 | $$
30 | 为了简化公式，引入$x_0=1$，公式转化为：
31 | $$
32 | h_{\theta}(x)=\theta_0x_0+\theta_1x_1+…+\theta_nx_n
33 | $$
34 | 特征矩阵X 的维度是$m*(n+1)$，公式简化为：
35 | $$
36 | h_{\theta}{(x)}=\theta^{T}X
37 | $$
38 |
39 | ----
40 |
41 | ### 多变量梯度下降
42 |
43 | #### 算法目标
44 |
45 | 与单变量线性回归类似，在多变量线性回归中，构建一个代价函数，则这个代价函数是所有**建模误差的平方和**，即：
46 | $$
47 | J(\theta_0,\theta_1,...,\theta_n)=\frac{1}{2m}\sum^m_{i=1}(h_{\theta}(x^{(i)})-y^{(i)})^2
48 | $$
49 | 其中
50 | $$
51 | h_\theta(x)=\theta^T{X}=\theta_0+\theta_1x_1+…+\theta_nx_n
52 | $$
53 |
54 | #### 算法过程
55 |
56 | **原始形式：**
57 | $$
58 | \theta_j:=\theta_j-\alpha \frac {\partial J(\theta_0,\theta_1,...,\theta_n)}{\partial \theta_j}
59 | $$
60 | **将代价函数$J$带进去：**
61 | $$
62 | \theta_j:=\theta_j-\frac{1}{2m} \alpha \frac {\partial \sum^m_{i=1}(h_{\theta}(x^{(i)})-y^{(i)})^2}{\partial \theta_j}
63 | $$
64 | **求导数之后：**
65 | $$
66 | \theta_j:=\theta_j-\frac{1}{m} \alpha \sum^m_{i=1}((h_{\theta}(x^{(i)})-y^{(i)})\cdot x_j^{(i)}
67 | $$
68 | 其中$j\in{(0,1,2,…,n)}$
69 |
70 | 当$n \geq 1$时：
71 | $$
72 | \theta_0:=\theta_0-\frac{1}{m} \alpha \sum^m_{i=1}((h_{\theta}(x^{(i)})-y^{(i)})\cdot x_0^{(i)}
73 | $$
74 |
75 | $$
76 | \theta_1:=\theta_1-\frac{1}{m} \alpha \sum^m_{i=1}((h_{\theta}(x^{(i)})-y^{(i)})\cdot x_1^{(i)}
77 | $$
78 |
79 | $$
80 | \theta_2:=\theta_2-\frac{1}{m} \alpha \sum^m_{i=1}((h_{\theta}(x^{(i)})-y^{(i)})\cdot x_2^{(i)}
81 | $$
82 |
83 | 
84 |
85 |
86 |
87 | **Python代码**
88 |
89 | 给定特征矩阵X，输出y，学习率$\theta$，求代价函数$J$
90 |
91 | ```python
92 | import numpy as np
93 |
94 | def computeCost(X,y,theta):
95 | inner = np.power(((X * theta.T) - y), 2) # 求解每个平方项
96 | return np.sum(inner) / (2 / lne(X)) # 求和再除以2*len(X)
97 | ```
98 |
99 | ### 梯度下降法实践
100 |
101 | #### 特征缩放
102 |
103 | 面对多维度特征问题，我们需要保证这些特征具有相近的尺度，帮助梯度下降算法更快地收敛。
104 |
105 | 以房价问题为例，假设仅用两个特征，房屋的尺寸和数量，以两个参数分别为横纵坐标，假设尺寸在0-2000平方英尺，数量在0-5之间。
106 |
107 | 绘制代价函数的等高线图能，看出图像会显得很扁，梯度下降算法需要非常多次的迭代才能收敛。
108 |
109 | 
110 |
111 | **解决办法**：将所有的特征的尺度尽量缩放到-1到1之间，令：
112 | $$
113 | x_n=\frac{x_n-u_n}{s_n}
114 | $$
115 | 其中$u_n$为平均值，$s_n$为标准差
116 |
117 | 
118 |
119 | #### 均值归一化
120 |
121 | 
122 |
123 | #### 学习率问题
124 |
125 | 梯度下降算法的每次迭代受到学习率的影响
126 |
127 | - 如果学习率过小，则达到收敛所需的迭代次数会非常高，收敛速度非常慢
128 | - 如果学习率过大，每次迭代可能不会减小代价函数，可能会越过局部最小值导致无法收敛
129 |
130 | 常用学习率包含：$\alpha=0.01, 0.03, 0.1, 0.31, 3,10$
131 |
132 | ### 特征和多项式回归
133 |
134 | 如房价预测问题，
135 | $$
136 | h_{\theta}{(x)} = \theta_0+\theta_1 \cdot宽度 + \theta_2 \cdot 深度
137 | $$
138 | 同时房屋面积=宽度 * 深度
139 |
140 | 
141 |
142 |
143 |
144 | 在实际拟合数据的时候，可能会选择二次或者三次方模型；如果采用多项式回归模型，在运行梯度下降法之前，特征缩放很有必要。
145 |
146 | 
147 |
148 | ### 正规方程 Normal Equation
149 |
150 | #### 梯度下降缺点
151 |
152 | 需要多次迭代才能达到局部最优解
153 |
154 | 
155 |
156 | #### 正规方程demo
157 |
158 | 正规方程具有不可逆性
159 |
160 | 正规方程就是通过求解下面例子中的方程找出使得代价函数最小参数$\theta$
161 | $$
162 | \theta=(X^TX)^{-1}X^Ty
163 | $$
164 | 
165 |
166 | **不可逆矩阵不能使用正规方程求解**
167 |
168 | #### Normal Equation VS Gradient Descent
169 |
170 | | 梯度下降 | 正规方程 |
171 | | :-------------------------- | :----------------------------------------------------------- |
172 | | 需要选择学习率$\theta$ | 不需要 |
173 | | 需要多次迭代 | 一次运算得出 |
174 | | 当特征数量n大时也能较好适用 | 需要计算 $(X^TX)^{-1}$如果特征数量n较大则运算代价大
矩阵逆的计算时间复杂度为$O(n^3)$，通常小于10000建议用正规方程 |
175 | | 适用于各种类型的模型 | 只适用于线性模型，不适合逻辑回归模型等其他模型 |
176 |
177 | 
178 |
179 | #### 参数$\theta$求解过程
180 |
181 | **目标任务**
182 | $$
183 | \theta=(X^TX)^{-1}X^Ty
184 | $$
185 | 其中：
186 | $$
187 | J(\theta)=\frac{1}{2m}\sum^m_{i=1}(h_{\theta}(x^{(i)})-y^{(i)})^2
188 | $$
189 |
190 | $$
191 | h_\theta(x)=\theta^T{X}=\theta_0x_0+\theta_1x_1+…+\theta_nx_n
192 | $$
193 |
194 | **具体过程：**
195 |
196 | 1. 将代价函数$J(\theta)$的向量表达式转成矩阵表达式
197 |
198 | $$
199 | J(\theta) = \frac{1}{2}(X\theta-y)^2
200 | $$
201 |
202 | - X为m行n列（m个样本个数，n个特征个数）
203 | - $\theta$为n行1列的矩阵
204 | - y为m行1列的矩阵
205 |
206 | 2. $J(\theta)$做变换：
207 |
208 | $$
209 | \begin{align}
210 | J(\theta)
211 | & = \frac{1}{2}{(X\theta-y)}^T(X\theta-y) \\
212 | & = \frac {1}{2}{(\theta^TX^T-y^T)(X\theta-y)} \\
213 | & = \frac {1}{2}{(\theta^TX^TX\theta-\theta^TX^Ty-y^TX\theta+y^Ty)}
214 | \end{align}
215 | $$
216 |
217 | 3. 在进行求解偏导的过程中会用到的公式
218 |
219 | $$
220 | \frac {\partial AB}{\partial B} = A^T
221 | $$
222 |
223 | $$
224 | \frac {\partial X^TAX}{\partial X}=2AX
225 | $$
226 |
227 | 4. 求导
228 |
229 | $$
230 | \begin{align}
231 | \frac{\partial J(\theta)}{\partial \theta}
232 | & =\frac{1}{2}(2X^TX\theta-X^Ty-(y^TX)^T-0) \\
233 | & = \frac{1}{2}(2X^TX\theta-X^Ty-X^Ty-0) \\
234 | & = X^TX\theta-X^Ty \\
235 |
236 | \end{align}
237 | $$
238 |
239 | 令上面的导数等于0，得到$\theta$
240 |
241 |
242 |
243 | #### Python实现
244 |
245 | ```python
246 | import numpy as np
247 |
248 | def normalEquation(X, y):
249 | theta = np.linalg.inv(X.T@X)@X.T@Y # X.T@X等价于X.T.dot(X) @等价于.dot
250 | return theta
251 | ```
252 |
253 |
--------------------------------------------------------------------------------
/week3.md:
--------------------------------------------------------------------------------
1 | **吴恩达笔记-第三周**
2 |
3 | 主要讲解的内容包含：
4 | - 逻辑回归
5 | - 代价函数
6 | - 线性回归和逻辑回归的比较
7 | - 正则化问题
8 |
9 |
10 |
11 |
12 |
13 | ### 一、逻辑回归
14 |
15 | #### 分类问题
16 |
17 | 假设预测的变量y是离散的值，需要使用逻辑回归（Logistic Regression，LR）的算法，**实际上它是一种分类算法**
18 |
19 | ##### 二元分类问题
20 |
21 | 将因变量(**dependent variable**)可能属于的两个类分别称为负向类（**negative class**）和正向类（**positive class**），因变量y的取值只能在0和1之间，其中0表示负类，1表示正类
22 |
23 | 
24 |
25 | #### 假说表示Hypothesis Representation
26 |
27 | 分类器的输出值在0和1之间，因此，希望找出一个满足某个性质的假设函数，这个性质是它的预测值要在0和1之间。
28 |
29 |
30 |
31 | 
32 |
33 |
34 |
35 |
36 |
37 | 
38 |
39 | 引入一个新的模型：逻辑回归。该模型的输出变量范围始终在0和1之间。 逻辑回归模型的假设是：
40 | $$
41 | h(\theta) = g(\theta^TX)
42 | $$
43 | 其中X代表的是特征向量g的逻辑函数，常用的S型函数（上图的右边，sigmoid function）公式为
44 | $$
45 | g(z)= \frac{1}{1+e^{-z}}
46 | $$
47 | Python代码实现sigmod激活函数：
48 |
49 | ```python
50 | import numpy as np
51 |
52 | def sigmod(z):
53 | return 1 / (1 + np.exp(-z))
54 | ```
55 |
56 | $$
57 | h_\theta(x)=g(z)= \frac{1}{1+e^{-\theta^TX}}
58 | $$
59 |
60 | $h_{\theta}(x)$作用是对于给定的输入变量，根据选择的参数计算输出变量=1的可能性，即：$h_{\theta}(x)=P(y=1|x;\theta)$
61 |
62 | 例如：对于给定的x，通过已经确定的参数计算得出$h_{\theta}(x)=0.7$，则表示有70%的几率y属于正类
63 |
64 |
65 |
66 | #### 决策边界decision boundary
67 |
68 | ##### 解释逻辑回归
69 |
70 | 1. 在逻辑回归中$h \geq 0.5$预测$y=1$；反之y=0
71 |
72 | 2. 在激活函数$g(z)$中：
73 |
74 | 当$z \geq 0$则$g(z) \geq 0.5$
75 |
76 | 当$z < 0$则$g(z) < 0.5$
77 |
78 | 3. 又因为$z=\theta^Tx$，则$\theta^Tx \geq 0$则y=1；反之y=0
79 |
80 | ##### 实例demo
81 |
82 | 在下图的中实例中，参数$\theta$满足[-3,1,1]，当$-3+x_1+x_2 \geq0$，即$x_1+x_2\geq3$时，模型预测y=1；说明此时：直线$x_1+x_2=3$就是决策边界
83 |
84 | 
85 |
86 | **复杂的模型边界问题**
87 |
88 | 
89 |
90 |
91 |
92 | ### 二、代价函数Cost Function
93 |
94 | #### 如何拟合LR模型的参数$\theta$
95 |
96 | 
97 |
98 | **1. 线性模型**中代价函数是模型误差的**平方和**
99 | $$
100 | J(\theta)=\frac{1}{2m}\sum^m_{i=1}(h_{\theta}(x^{(i)})-y^{(i)})^2
101 | $$
102 |
103 |
104 |
105 | 如果直接使用线性模型中的代价函数，即误差平方和，得到的代价函数是个**"非凸函数"**，但是实际上我们期望看的是凸函数（右边）
106 |
107 | 
108 |
109 | 2. **重新定义逻辑回归的代价函数**
110 |
111 | $$
112 | h_\theta(x)=g(\theta^TX)= \frac{1}{1+e^{-\theta^TX}}
113 | $$
114 |
115 | $$
116 | J(\theta)=\frac{1}{m}\sum^m_{i=1}Cost(h_\theta(x^{(i)}),y^{(i)})
117 | $$
118 |
119 | $$
120 | Cost(h_\theta(x), y) =
121 | \begin{cases}
122 | -\log(h_\theta(x)), & \text{y=1} \\
123 | -\log(1-h_\theta(x)), & \text{y=0} \\
124 | \end{cases}
125 | $$
126 |
127 | 将上面的两个式子进行合并：
128 | $$
129 | Cost(h_\theta(x), y)=-y\log(h_\theta(x))-(1-y)\log(1-h_\theta(x))
130 | $$
131 | 
132 |
133 | 3. $h_\theta(x)$和$Cost(h_\theta(x),y)$之间的关系
134 |
135 | 根据y的不同取值来进行分别判断，同时需要注意的是：假设函数h的取值只在[0,1]之间
136 |
137 | 
138 |
139 | **y=1的情形**
140 |
141 | 
142 |
143 |
144 | **y=0的情形**
145 |
146 | 
147 |
148 |
149 |
150 | #### Python代码实现代价函数
151 |
152 | 利用`Python`实现下面的代价函数
153 |
154 | - `first` 表示的是右边第一项
155 | - `second` 表示的是右边第二项
156 |
157 | $$
158 | Cost(h_\theta(x), y)=-y\log(h_\theta(x))-(1-y)\log(1-h_\theta(x))
159 | $$
160 |
161 |
162 |
163 | ```python
164 | import numpy as np
165 |
166 | def cost(theta, X, y):
167 | # 实现代价函数
168 |
169 | theta=np.matrix(theta)
170 | X = np.matrix(X)
171 | y = np.matrxi(y)
172 |
173 | first = np.multiply(-y, np.log(sigmod(X * theta.T)))
174 | second = np.multiply((1 - y), np.log(1-sigmod(X * theta.T)))
175 |
176 | return np.sum(first - second) / (len(X))
177 | ```
178 |
179 | #### 利用梯度下降来求解LR最小参数
180 |
181 | **LR中的代价函数是**
182 | $$
183 | J(\theta)=-\frac{1}{m}\sum^m_{i=1}[-y^{(i)}\log(h_\theta(x^{(i)}))-(1-y^{(i)})\log(1-h_\theta(x^{i}))]
184 | $$
185 | **最终结果**
186 | $$
187 | \frac{\partial J(\theta)}{\partial \theta_j}=\frac{1}{m}\sum^m_{i=1}[h_\theta(x^{(i)})-y^{(i)}]x_j^{(i)}
188 | $$
189 | **具体过程**
190 |
191 | 
192 |
193 | 不断地迭代更新$\theta_{j}$
194 | $$
195 | \theta_{j} := \theta_j-\alpha\frac{\partial J(\theta)}{\partial \theta_j}
196 | $$
197 |
198 | $$
199 | \theta_{j} := \theta_j-\alpha\frac{1}{m}\sum^m_{i=1}[h_\theta(x^{(i)})-y^{(i)}]x_j^{(i)}
200 | $$
201 |
202 | 如果存在n个特征，也就是$\theta=[\theta_0,\theta_1,…,\theta_n]^T$。那么就需要根据上面的式子从0-n来更新所有的$\theta$
203 |
204 | ### 三、线性回归 VS 逻辑回归
205 |
206 | 1. 假设的定义规则发生变化
207 |
208 | 线性回归：
209 | $$
210 | h_{\theta}{(x)}=\theta^TX=\theta_0x_0+...+\theta_nx_n
211 | $$
212 | 逻辑回归：
213 | $$
214 | h_\theta{(x)}= \frac{1}{1+e^{-\theta^TX}}
215 | $$
216 |
217 | > 因此，即使更新参数的规则看起来基本相同，但由于假设的定义发生了变化，所以逻辑函数的梯度下降，跟线性回归的梯度下降实际上是两个完全不同的东西。
218 |
219 | #### 其他求解代价函数最小的算法
220 |
221 | - 共轭梯度conjugate gradient
222 | - 局部优化法**Broyden fletcher goldfarb shann,BFGS**
223 | - **有限内存局部优化法(LBFGS)**
224 |
225 | ### 四、多类别分类one-vs-all
226 |
227 | 实际中的例子
228 |
229 | > 假如现在需要一个学习算法能自动地将邮件归类到不同的文件夹里，或者说可以自动地加上标签，那么需要一些不同的文件夹，或者不同的标签来完成这件事，来区分开来自工作、朋友、家人或者有关兴趣爱好的邮件，那么，就有了这样一个分类问题：其类别有4个，分别用$y=1,2,3,4$ 来代表。
230 |
231 | 
232 |
233 | ### 五、正则化问题Regularization
234 |
235 | #### 正则化基础
236 |
237 | > 正则化技术主要是为了解决过拟合的问题。**过拟合指的是**：对样本数据具有很好的判断能力，但是对新的数据预测能力很差。
238 |
239 | 
240 |
241 | - 第一个模型是一个线性模型，欠拟合，不能很好地适应我们的训练集
242 |
243 | - 第三个模型是一个四次方的模型，过于强调拟合原始数据，而丢失了算法的本质：预测新数据
244 | - 中间的模型似乎最合适
245 |
246 | 如果是多项式拟合，x的次数越高，拟合的效果越好，但是相应的预测能力就可能变差。**对于过拟合的处理：**
247 |
248 | 1. 丢弃一些不能正确预测的特征。可以是手工选择保留哪些特征，或者使用一些模型选择的算法，例如**PCA**
249 | 2. 正则化。 保留所有的特征，但是减少参数的大小（**magnitude**）
250 |
251 | 
252 |
253 |
254 |
255 | #### 加入正则化参数
256 |
257 | 在模型$h_\theta(x)=\theta_0+\theta_1x_1+\theta_2x_2+\theta_3x_3+\theta_4x_4$中，主要是高次项产生的过拟合问题：
258 |
259 | 
260 |
261 | 加入正则化参数后能够防止过拟合问题，其中$\lambda$是正则化参数**Regularization Parameter**
262 | $$
263 | J(\theta)=\frac{1}{2m}\sum^m_{i=1}(h_{\theta}(x^{(i)})-y^{(i)})^2+\lambda \sum^n_{j=1}\theta^2_{j}
264 | $$
265 | **Attention**：一般地，不对$\theta_0$进行惩罚；加上正则化参数实际上是对参数$\theta$进行惩罚。经过正则化处理后的模型和原模型的对比：
266 |
267 | 
268 |
269 | - 如果$\lambda$过大，所有的参数最小化，模型变成了$h_\theta(x)=\theta_0$，造成了过拟合
270 |
271 | #### 正则化线性回归Regularized Linear Regression
272 |
273 | 正则化线性回归的代价函数
274 | $$
275 | J(\theta)=\frac{1}{2m}\sum^m_{i=1}[(h_{\theta}(x^{(i)})-y^{(i)})^2+\lambda \sum^n_{j=1}\theta^2_{j}]
276 | $$
277 |
278 |
279 | **Attention：在线性回归中，不对$\theta_0$进行正则化**
280 | $$
281 | {\theta_0}:={\theta_0}-a\frac{1}{m}\sum\limits_{i=1}^{m}{(({h_\theta}({{x}^{(i)}})-{{y}^{(i)}})x_{0}^{(i)}}
282 | $$
283 | 当$j=1,2,…,n$时
284 | $$
285 | {\theta_j}:={\theta_j}-a[\frac{1}{m}\sum\limits_{i=1}^{m}{(({h_\theta}({{x}^{(i)}})-{{y}^{(i)}})x_{j}^{\left( i \right)}}+\frac{\lambda }{m}{\theta_j}] ；j=1,2,...,n
286 | $$
287 | **调整下变成：**
288 | $$
289 | {\theta_j}:={\theta_j}(1-\frac{\lambda }{m})-a\frac{1}{m}\sum\limits_{i=1}^{m}{(({h_\theta}({{x}^{(i)}})-{{y}^{(i)}})x_{j}^{\left( i \right)}}
290 | $$
291 |
292 |
293 | #### 正则化逻辑回归Regularized Logistic Regression
294 |
295 | LR问题两种优化方法：
296 |
297 | - 梯度下降法
298 | - 更高级优化算法
299 |
300 | **加上正则惩罚项后的代价函数为：**
301 | $$
302 | J(\theta)=\frac{1}{m}\sum^m_{i=1}[-y^{(i)}\log(h_\theta(x^{(i)}))-(1-y^{(i)})\log(1-h_\theta(x^{i}))]+\frac{\lambda}{2m}\sum^n_{j=1}\theta^2_j
303 | $$
304 |
305 | #### python代码实现
306 |
307 | ```python
308 | import numpy as np
309 |
310 | # 实现代价函数
311 | def costReg(theta, X, y, lr):
312 | theta= np.matrix(theta)
313 | X = np.matrix(X)
314 | y = np.matrix(y)
315 |
316 | first = np.multiply(-y, np.log(sigmoid(X * theta.T)))
317 | second = np.multiply((1 - y), np.log(1 - sigmoid(X * theta.T)))
318 | reg = (lr / (2 * len(X)) * np.sum(np.power(theta[:, 1:theta.shape[1]], 2)) # theta[:, 1:theta.shape[1]] 代表的是 \theta_j
319 | return np.sum(first - second) / len((X)) + reg
320 | ```
321 |
322 |
323 |
324 | 通过求导，得到梯度下降算法，本质上就是对$\theta$的不断更新：
325 | $$
326 | {\theta_0}:={\theta_0}-a\frac{1}{m}\sum\limits_{i=1}^{m}{(({h_\theta}({{x}^{(i)}})-{{y}^{(i)}})x_{0}^{(i)}})
327 | $$
328 |
329 | $$
330 | {\theta_j}:={\theta_j}-a[\frac{1}{m}\sum\limits_{i=1}^{m}{({h_\theta}({{x}^{(i)}})-{{y}^{(i)}})x_{j}^{\left( i \right)}}+\frac{\lambda }{m}{\theta_j}] ； j=1,2,...,n
331 | $$
332 |
333 |
--------------------------------------------------------------------------------
/week4.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: 吴恩达笔记4
3 | top: false
4 | cover: false
5 | toc: true
6 | mathjax: true
7 | copyright: true
8 | date: 2019-11-27 23:29:01
9 | password:
10 | summary:
11 | tags:
12 | - ML
13 | - 神经网络
14 | categories:
15 | - Machine learning
16 | - 吴恩达
17 | ---
18 |
19 |
20 |
21 | 吴恩达笔记4
22 |
23 | 在本章节中主要讲解的是神经网络的基础知识：
24 |
25 | - 非线性假设
26 | - 神经元和大脑
27 | - 模型表示
28 | - 特征和直观理解
29 | - 多类分类问题
30 |
31 |
32 |
33 | ### 非线性假设Non-linear Hypotheses
34 |
35 |
36 |
37 | 线性回归和逻辑回归的缺点：**特征太多的时候，计算负荷会非常大**
38 |
39 |
40 |
41 | 假设我们希望训练一个模型来识别视觉对象（例如识别一张图片上是否是一辆汽车），我们怎样才能这么做呢？一种方法是我们利用很多汽车的图片和很多非汽车的图片，然后利用这些图片上一个个像素的值（饱和度或亮度）来作为特征。
42 |
43 | 
44 |
45 |
46 |
47 | 
48 |
49 |
50 |
51 | 假设采用的是50*50像素的小图片，将所有的像素视为特征，则有2500个特征。普通的逻辑回归模型不能处理的，需要使用神经网络。
52 |
53 |
54 |
55 | ### 神经元和大脑
56 |
57 | 
58 |
59 | ### 模型表示
60 |
61 | #### 模型表示1
62 |
63 | 每个神经元是可以被认为一个处理单元/神经核**processing unit**/**Nucleus**，主要包含：
64 |
65 | - 多个输入/树突（**input**/**Dendrite**
66 | - 一个输出/轴突（**output**/**Axon**）
67 |
68 | > 神经网络是大量神经元相互链接并通过电脉冲来交流的一个网络
69 |
70 |
71 |
72 | 
73 |
74 |
75 |
76 | 1. 神经网络模型建立在很多神经元之上，每一个神经元又是一个个学习模型
77 | 2. 神经元称之为激活单元**activation unit**；在神经网络中，参数又可被成为权重（**weight**）
78 | 3. 类似神经元的神经网络
79 |
80 | 
81 |
82 | #### 神经网络
83 |
84 | 下图是逻辑回归模型作为自身学习模型的神经元示例
85 |
86 | 
87 |
88 |
89 |
90 | **类似神经元的神经网络结构**
91 |
92 |
93 |
94 | 
95 |
96 | - $x_1,x_2,x_3$是输入单元，将原始数据输入给它们
97 |
98 | - **几个比较基础的概念**
99 |
100 | - 输入层：数据节点所在的层
101 | - 网络层：输出$h_i$连同它的网络层参数$w,b$
102 | - 隐藏层：网络层中间的层
103 | - 输出层：最后一层
104 | - 偏置单元：bias unit，每层加上偏置单元
105 |
106 |
107 |
108 | 上面模型的激活单元和输出分别表示为：
109 |
110 | 
111 |
112 |
113 |
114 | **三个激活单元：**
115 | $$
116 | a^{(2)}_1 = g(\Theta^{(1)}_{10}x_0+\Theta^{(1)}_{11}x_1+\Theta^{(1)}_{12}x_2+\Theta^{(1)}_{13}x_3)
117 | $$
118 |
119 | $$
120 | a^{(2)}_2 = g(\Theta^{(1)}_{20}x_0+\Theta^{(1)}_{21}x_1+\Theta^{(1)}_{22}x_2+\Theta^{(1)}_{23}x_3)
121 | $$
122 |
123 | $$
124 | a^{(2)}_3 = g(\Theta^{(1)}_{30}x_0+\Theta^{(1)}_{31}x_1+\Theta^{(1)}_{32}x_2+\Theta^{(1)}_{33}x_3)
125 | $$
126 |
127 |
128 |
129 | **输出的表达式为：**
130 | $$
131 | h_{\Theta}^{(x)} = g(\Theta^{(2)}_{10}a^{(2)}_0)+g(\Theta^{(2)}_{11}a^{(2)}_1)+g(\Theta^{(2)}_{12}a^{(2)}_2)+g(\Theta^{(2)}_{13}a^{(2)}_3)
132 | $$
133 |
134 |
135 | >将特征矩阵的每行（一个训练实例）喂给了神经网络，最终需要将整个训练集都喂给神经网络。这种从左到右计算的算法称之为：**前向传播法FORWARD PROPAGATION**
136 |
137 |
138 |
139 | #### 模型标记的记忆方法
140 |
141 | - $a^{(j)}_i$表示的是第$j$层的第$i$个激活单元
142 |
143 | - $\theta^{(j)}$代表从第$j$层映射到第$j+1$层的权重矩阵；例如：上图所示的神经网络中$\theta^{(1)}$的尺寸为 3*4。其尺寸具体表示为
144 |
145 | - 以第$j$ 层的激活单元数量为**行数**
146 |
147 | - 以第 $j+1$层的激活单元数+1为**列数**的矩阵
148 |
149 |
150 |
151 | #### 模型表示2
152 |
153 | **（FORWARD PROPAGATION** ) 相对于使用循环来编码，利用向量化的方法会使得计算更为简便。
154 | $$
155 | x=\begin{bmatrix}x_0\\ x_1\\ x_2\\x_3\\ \end{bmatrix}
156 | $$
157 |
158 | $$
159 | z^{(2)}=\begin{bmatrix}z_1^{(2)}\\ z_2^{(2)}\\ z_3^{(2)}\\\end{bmatrix}
160 | $$
161 |
162 | 其中
163 | $$
164 | z^{(2)}=\Theta^{(1)}x
165 | $$
166 | 就是上面三个激活单元式子中的括号里面部分
167 | $$
168 | a^{(2)}=g(z^{(2)})
169 | $$
170 | 将输入$x$看成是$a^{(1)}$，则
171 | $$
172 | z^{(2)}=\Theta^{(1)} a^{(1)}
173 | $$
174 |
175 | $$
176 | a^{(2)}=g(z^{(2)})
177 | $$
178 |
179 | $$
180 | z^{(3)}=\Theta^{(2)} a^{(2)}
181 | $$
182 |
183 | 那么输出h可以表示为
184 | $$
185 | h_{\Theta}(x)=a^{(3)}=g(z^{(3)})
186 | $$
187 |
188 |
189 | 
190 |
191 |
192 |
193 | ### 特征和直观理解
194 |
195 | 神经网络中，单层神经元（无中间层）的计算可用来表示逻辑运算，比如逻辑与(**AND**)、逻辑或(**OR**)
196 |
197 | #### 实现逻辑”与AND”
198 |
199 | | x_1 | x_2 | h |
200 | | ---- | ---- | ---- |
201 | | 0 | 0 | 0 |
202 | | 0 | 1 | 0 |
203 | | 1 | 0 | 0 |
204 | | 1 | 1 | 1 |
205 |
206 | 
207 |
208 | #### 实现逻辑"或OR"
209 |
210 | | x_1 | x_2 | h |
211 | | ---- | ---- | ---- |
212 | | 0 | 0 | 0 |
213 | | 0 | 1 | 1 |
214 | | 1 | 0 | 1 |
215 | | 1 | 1 | 1 |
216 |
217 | 
218 |
219 | #### 实现逻辑“非not”
220 |
221 | 
222 |
223 |
224 |
225 | ### 多类分类问题
226 |
227 | 当输出中不止有两中分类时，比如使用神经网络算法来识别路人、汽车、摩托车等。
228 |
229 | 
230 |
231 | - 输入向量有3个维度，两个中间层
232 | - 输出层有4个神经元表示4中分类，也就是每一个数据在输出层都会出现$[a,b,c,d]^T$，且$[a,b,c,d]$中仅有一个为1，表示当前类
233 |
234 |
235 |
236 | ### TF中解决办法
237 |
238 | 上述多类分类问题和TF中手写数字问题类似，解决办法如下：
239 |
240 | - 将输出设置为$d_{out}$个输出节点的向量，$d_{out}$与类别数相同
241 | - 让第$i \in [1,d_{out}]$个输出值表示当前样本属于类别i的概率P
242 | - **如果属于第$i$类，索引为$i$的位置设置为1，其余为0！！！！**
243 | - 下图中：对于所有猫的图片，数字编码是0，one-hot编码为[1,0,0,0]；其他类推
244 |
245 | 
246 |
247 | 3. 手写数字图片数据
248 |
249 | 总类别数是10，即输出节点总数值$d_{out}=10$，假设某个样本的类别是i，即图片中的数字是$i$，需要一个长度为10的向量$y$，索引号为$i$的位置设置为1，其余是0。
250 |
251 | - 0的one-hot编码是[1,0,0,0,….]
252 | - 1的one-hot编码是[0,1,0,0,….]
253 | - 其余类推
254 |
--------------------------------------------------------------------------------
/week5.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: 吴恩达笔记5
3 | top: false
4 | cover: false
5 | toc: true
6 | mathjax: true
7 | copyright: true
8 | date: 2019-11-29 15:13:57
9 | password:
10 | summary:
11 | tags:
12 | - Backpropagation Algorithm
13 | - 神经网络
14 | categories:
15 | - Machine learning
16 | - 吴恩达
17 | ---
18 |
19 |
20 |
21 | week5-神经网络学习Neural Networks Learning
22 |
23 | ### 神经网络代价函数
24 |
25 | #### 参数解释
26 |
27 | 对几个参数的标记方法进行说明解释
28 |
29 | - m：训练样本个数
30 | - x，y：输入和输出信号
31 | - L：代表神经网络层数
32 | - $S_I$：每层的神经元个数
33 | - $S_l$：表示输出神经元个数
34 |
35 |
36 |
37 | 
38 |
39 | #### 分类讨论
40 |
41 | 主要是两类：二分类和多类分类
42 |
43 | 二类分类：$S_L=0,y=0/1$；输出是一个实数
44 |
45 | $K$类分类：$S_L=k,y_i=1$表示分到第$i$类的情况。输出是一个多维向量
46 |
47 | #### 代价函数
48 |
49 | 逻辑斯蒂回归中的代价函数
50 | $$
51 | J(\theta)=-\frac{1}{m}\sum^m_{i=1}[y^{(i)}\log(h_\theta(x^{(i)}))+(1-y^{(i)})\log(1-h_\theta(x^{i}))]+\frac{\lambda}{2m}\sum^n_{j=1}\theta^2_j
52 | $$
53 | 在逻辑斯蒂回归中，只有一个输出变量称之为标量`scalar`。
54 |
55 | 但是在神经网络中会有多个输出变量，$h_\theta(x)$是一个$K$维的向量。
56 |
57 | 假设函数$h_\theta(x) \in R^K;h_\theta(x)=i^{th}$ output；表示的是第$i$个输出，代价函数为：
58 | $$
59 | J(\Theta)=-\frac{1}{m}[\sum^m_{i=1}\sum^h_{k=1}[y^{(i)}_k\log(h_\Theta(x^{(i)}))_k+(1-y^{(i)}_k)\log(1-h_\Theta(x^{i}))_k]+\frac{\lambda}{2m}\sum^{L-1}_{l=1}\sum^{s_l}_{i=1}\sum^{s_l+1}_{j=1}(\Theta_{ji}^{(l)})^2
60 | $$
61 | 解释说明：
62 |
63 | 1. 期望通过代价函数来观察算法预测的结果和真实情况的误差
64 | 2. 每行特征会有$K$个预测，利用循环对每行进行预测
65 | 3. 在$K$个预测中选择出可能性最高的那个，将其和实际的数据$y$进行比较
66 | 4. 正则化项是排除了每个偏置$\theta_0$之后，每层$\theta$矩阵的求和
67 | 5. 参数$j$（由$s_l+1$层的激活单元数决定）循环所有的行，$i$（由$s_l$层的激活单元数决定）循环所有的列
68 |
69 |
70 |
71 | ### 反向传播法Backpropagation Algorithm
72 |
73 | 
74 |
75 | 为了计算神经网络中代价函数的偏导数$\frac{\partial J(\Theta)}{\partial \Theta_{ij^{(l)}}}$，需要使用反向传播法
76 |
77 | - 首先计算最后一层的误差
78 | - 再一层层地反向求出各层的误差，直到倒数第二层
79 |
80 | #### 前向传播栗子
81 |
82 | 假设有一个数据样本$(x^{(1)},y^{(1)})$，神经网络是4层的，其中$K=S_L=L=4$
83 |
84 | 
85 |
86 | 前向传播法就是通过一层层地按照神经网络的顺序从输入层到输出层计算下去。
87 |
88 | #### 反向传播栗子
89 |
90 | 
91 |
92 | 1. 从最后一层的误差开始计算：误差=激活单元的预测$a^{(4)}$和实际值之间的$y^{(k)}$之间的误差；用$\delta$表示误差，**误差=模型预测值-真实值**
93 |
94 | 2. $$
95 | \delta^{(4)} = a^{(4)} -y
96 | $$
97 |
98 | 前一层的误差
99 |
100 | $$
101 | \delta^{(3)} = (\Theta^{(3)})^T\theta^{(4)}*g^`(z^{(3)})
102 | $$
103 |
104 | 其中$g^`(z^{(3)})$是$S$型函数的导数
105 | $$
106 | g^`(z^{(3)})=a^{(3)}*(1-a^{(3)})
107 | $$
108 |
109 | 3. 再前一层的误差
110 |
111 | $$
112 | \delta^{(2)} = (\Theta^{(2)})^T\theta^{(3)}*g^`(z^{(2)})
113 | $$
114 |
115 | 第一层是输入变量，不存在误差
116 |
117 | 4. 假设$\lambda=0$，如果不做正则化处理时
118 |
119 | $$
120 | \frac{\partial J(\Theta)}{\partial \Theta_{ij}^{l}}=a_j^{(l)}\theta_i^{(l+1)}
121 | $$
122 |
123 | 上面的式子中各个上下标的含义：
124 |
125 | $l$代表的是第几层
126 |
127 | $j$代表的是计算层中的激活单元的下标
128 |
129 | $i$代表的是误差单元的下标
130 |
131 | #### 算法
132 |
133 | 
134 |
135 | - 利用正向传播方法计算每层的激活单元
136 | - 利用训练集的真实结果与神经网络的预测结果求出最后一层的误差
137 | - 最后利用该误差运用反向传播法计算出直至第二层的所有误差。
138 | - 在求出$\triangle ^{(l)}_{ij}$之后，便可以计算代价函数的偏导数$D^{(l)}_{ij}$
139 |
140 |
141 |
142 | ### 反向传播的直观理解
143 |
144 | #### 前向传播原理
145 |
146 | - 2个输入单元；2个隐藏层（不包含偏置单元）；1个输出单元
147 | - 上标$i$表示的是第几层，下标表示的是第几个特征或者说属性
148 |
149 | **图中有个小问题，看截图的右下角！！！**
150 |
151 | 
152 |
153 | **结论**
154 | $$
155 | Z^{(3)}_{1}=\Theta_{10}^{(2)}*1+\Theta_{11}^{(2)}*a^{(2)}_1+\Theta_{12}^{(2)}*a^{(2)}_2
156 | $$
157 |
158 | #### 反向传播原理
159 |
160 | 
161 |
162 | 
163 |
164 | ### 参数展开
165 |
166 | 上面的式子中实现了怎么利用反向传播法计算代价函数的导数，在这里介绍怎么将参数从矩阵形式展开成向量形式
167 |
168 | 
169 |
170 | 
171 |
172 | ### 梯度检验
173 |
174 | 如何求解在某点的导数
175 |
176 | 
177 |
178 | 在代价函数中怎么对某个参数$\theta$求导
179 |
180 | 
181 |
182 | ### 神经网络小结
183 |
184 | #### 首要工作
185 |
186 | 在构建神经网络的时候，首先考虑的是**如何选择网络结构**：多少层和每层多少个神经单元
187 |
188 | - 第一层的单元数即我们训练集的特征数量。
189 |
190 | - 最后一层的单元数是我们训练集的结果的类的数量。
191 |
192 | - 如果隐藏层数大于1，确保每个隐藏层的单元个数相同，通常情况下隐藏层单元的个数越多越好。
193 |
194 | #### 训练神经网络步骤
195 |
196 | 1. 参数的**随机初始化**
197 | 2. 利用**正向传播**方法计算所有的$h_{\theta}(x)$
198 | 3. 编写**计算代价函数** $J$的代码
199 | 4. 利用**反向传播**方法计算所有偏导数
200 | 5. 利用**数值检验**方法检验这些偏导数
201 | 6. 使用**优化算法来最小化代价函数**
202 |
--------------------------------------------------------------------------------
/week6.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: 吴恩达笔记6
3 | top: false
4 | cover: false
5 | toc: true
6 | mathjax: true
7 | copyright: true
8 | date: 2019-12-01 15:42:41
9 | password:
10 | summary:
11 | tags:
12 | - bias
13 | - variance
14 | - Learning Curves
15 | - ML
16 | categories:
17 | - Machine learning
18 | - 吴恩达
19 | ---
20 |
21 |
22 | ### 应用机器学习的建议
23 |
24 | > 当我们运用训练好了的模型来预测未知数据的时候发现有较大的误差，我们下一步可以做什么？
25 |
26 | - 获得更多的训练样本
27 | - 尝试减少特征的数量
28 | - 尝试获得更多的特征
29 | - 尝试增加多项式特征
30 | - 尝试减少正则化程度$\lambda$
31 | - 尝试增加正则化程度$\lambda$
32 |
33 |
34 |
35 | 
36 |
37 | #### 评估假设Evaluating a Hypothesis
38 |
39 | 当学习的算法时候，考虑的是如何选择参数来使得训练误差最小化。在模型建立的过程中很容易遇到过拟合的问题，那么如何评估模型是否过拟合呢？
40 |
41 | 为了检验算法是否过拟合，将数据集分成训练集和测试集，通常是7：3的比例。关键点是训练集和测试集均要含有各种类型的数据，通常我们要对数据进行“洗牌”，然后再分成训练集和测试集。
42 |
43 | 
44 |
45 | 当我们在训练集上得到我们的学习模型之后，就需要使用测试集合来检验该模型，有两种不同的方法：
46 |
47 | 1. 线性回归模型：利用测试数据计算代价函数$J$
48 | 2. 逻辑回归模型：
49 | - 先利用测试数据计算代价函数$J_{test}{(\theta)} $
50 | - 在针对每个测试集样本计算误分类的比率，再求平均值
51 |
52 |
53 |
54 | 
55 |
56 |
57 | 
58 |
59 |
60 |
61 |
62 | #### 模型选择和交叉验证
63 |
64 | ##### 交叉验证
65 |
66 | 交叉验证集合指的是：使用**60%**的数据作为**训练集**，使用 **20%**的数据作为**交叉验证集**，使用**20%**的数据作为**测试集**
67 |
68 | 
69 |
70 | ##### 模型选择
71 |
72 | - 使用训练集训练出10个模型
73 | - 用10个模型分别对**交叉验证集**计算得出交（代价函数的值）
74 | - 选取**代价函数值最小**的模型
75 | - 用上面步骤中选出的模型，对测试集计算得出推广误差（代价函数的值）
76 | - 训练误差表示为：
77 |
78 | $$
79 | J_{train}(\theta) = \frac{1}{2m}\sum_\limits{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})^2
80 | $$
81 |
82 | - 交叉验证误差（通过交叉验证数据集得到的）表示为：
83 |
84 | 
85 |
86 |
87 | - 测试误差
88 |
89 | 
90 |
91 |
92 |
93 | 
94 |
95 | #### 诊断方差和偏差Diagnosing Bias vs. Variance
96 |
97 | 如果一个算法的运行结果不是很理想，只有两种情况：要么偏差过大，要么方差过大。换句话就是说，要么出现欠拟合，要么出现过拟合。
98 |
99 | 
100 |
101 |
102 |
103 | 通过训练集和交叉验证集的**代价函数误差**和**多项式的次数**绘制在同张图中：
104 |
105 | 
106 |
107 | **1. 高偏差阶段**
108 |
109 | 交叉验证集和训练集的代价函数误差都是很大，近似相等；
110 |
111 | **2. 高方差阶段**
112 |
113 | **交叉验证集的误差远大于训练集的误差**，训练集的误差很低
114 |
115 |
116 |
117 | ### 正则化和偏差/方差Regularization and Bias_Variance
118 |
119 | #### 正则化基础
120 |
121 | > 正则化技术主要是为了解决过拟合的问题。**过拟合指的是**：对样本数据具有很好的判断能力，但是对新的数据预测能力很差。
122 |
123 | 
124 |
125 | - 第一个模型是一个线性模型，欠拟合，不能很好地适应我们的训练集
126 | - 第三个模型是一个四次方的模型，过于强调拟合原始数据，而丢失了算法的本质：预测新数据
127 | - 中间的模型似乎最合适
128 |
129 | #### 栗子
130 |
131 | 假设我们需要对下图中的多项式进行拟合，需要正则化项
132 |
133 | 
134 |
135 |
136 |
137 | - 当$\lambda$很大的时候，出现高偏差，假设$h_\theta(x)$是一条直线
138 | - 当$\lambda$很小约为0的时候，出现高方差
139 |
140 | 
141 |
142 |
143 |
144 | 
145 |
146 | 如果是多项式拟合，x的次数越高，拟合的效果越好，但是相应的预测能力就可能变差。**对于过拟合的处理：**
147 |
148 | 1. 丢弃一些不能正确预测的特征。可以是手工选择保留哪些特征，或者使用一些模型选择的算法，例如**PCA**
149 | 2. 正则化。 保留所有的特征，但是减少参数的大小（**magnitude**）
150 |
151 | 
152 |
153 |
154 |
155 | #### 加入正则化参数
156 |
157 | 在模型$h_\theta(x)=\theta_0+\theta_1x_1+\theta_2x_2+\theta_3x_3+\theta_4x_4$中，主要是高次项产生的过拟合问题：
158 |
159 | 
160 |
161 | 加入正则化参数后能够防止过拟合问题，其中$\lambda$是正则化参数**Regularization Parameter**
162 | $$
163 | J(\theta)=\frac{1}{2m}\sum^m_{i=1}(h_{\theta}(x^{(i)})-y^{(i)})^2+\lambda \sum^n_{j=1}\theta^2_{j}
164 | $$
165 | **Attention**：一般地，不对$\theta_0$进行惩罚；加上正则化参数实际上是对参数$\theta$进行惩罚。经过正则化处理后的模型和原模型的对比：
166 |
167 | 
168 |
169 | - 如果$\lambda$过大，所有的参数最小化，模型变成了$h_\theta(x)=\theta_0$，造成了过拟合
170 |
171 | #### 参数$\lambda$的选择
172 |
173 | 1. 使用训练集训练出多个不同程度的正则化模型
174 | 2. 用多个模型分别对交叉验证集计算的出交叉验证误差
175 | 3. 选择得出交叉验证误差**最小**的模型
176 | 4. 运用步骤3中选出模型对测试集计算得出推广误差
177 |
178 | ### 学习曲线 Learning Curves
179 |
180 | > 使用学习曲线来判断某一个学习算法是否处于偏差、方差问题。
181 | >
182 | > 学习曲线是将**训练集误差**和**交叉验证集误差**作为**训练集样本数量**$m$的函数绘制的图表
183 |
184 |
185 | $$
186 | J_{train}(\theta) = \frac{1}{2m}\sum_{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})^2
187 | $$
188 |
189 |
190 | $$
191 | J_{cv}{(\theta)} = \frac{1}{2m_{cv}}\sum_\limits{i=1}^{m}(h_{\theta}(x^{(i)}_{cv})-y^{(i)}_{cv})^2
192 | $$
193 |
194 | #### 训练样本m和代价函数J的关系
195 |
196 | 从下图1中看出结果
197 |
198 | - 样本越少，训练集误差很小，交叉验证集误差很大
199 | - 当样本逐渐增加的时候，二者的差别逐渐减小
200 |
201 | 说明：在高偏差、欠拟合的情况下，增加样本数量没效果
202 |
203 | 
204 |
205 | 在高方差的情况下，增加数量可以提高算法效果
206 |
207 | 
208 |
209 | #### 总结
210 |
211 | 1. 获得更多的训练样本——解决高方差
212 | 2. 尝试减少特征的数量——解决高方差
213 | 3. 尝试获得更多的特征——解决高偏差
214 | 4. 尝试增加多项式特征——解决高偏差
215 | 5. 尝试减少正则化程度λ——解决高偏差
216 | 6. 尝试增加正则化程度λ——解决高方差
217 |
218 |
219 |
220 | #### 神经网络的方差和偏差
221 |
222 | 较小的神经网络，参数少，容易出现高偏差和欠拟合；
223 |
224 | 较大的神经网络，参数多，容易出现高方差和过拟合
225 |
226 | > 通常选择较大的神经网络并采用正则化处理会比采用较小的神经网络效果要好
227 |
228 | 
229 |
230 | ### 查准率和查全率
231 |
232 | | | **预测值** | | |
233 | | :--------- | :--------- | :----------- | ----------- |
234 | | | | **Positive** | **Negtive** |
235 | | **实际值** | **True** | **TP** | **FN** |
236 | | | **False** | **FP** | **TN** |
237 |
238 | 查准率`precision`：实际和预测同时为正例 / 预测值全部为正例
239 | $$
240 | P=\frac{TP}{TP+FP}
241 | $$
242 | 查全率`recall`：实际和预测同时为正例 / 实际值全部为正例
243 | $$
244 | R = \frac{TP}{TP+FN}
245 | $$
246 |
247 |
248 | **查全率和查准率是一对矛盾的量**，一个高的话，另一个必定低，关系图如下：
249 |
250 | 
251 |
252 | 查全率和查准率之间的平衡点，一般是使用$F_1$系数表示
253 | $$
254 | F_1=\frac{2PR}{P+R}
255 | $$
256 |
257 |
--------------------------------------------------------------------------------
/week7.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: 吴恩达笔记7
3 | top: false
4 | cover: false
5 | toc: true
6 | mathjax: true
7 | copyright: true
8 | date: 2019-12-03 23:24:39
9 | password:
10 | summary:
11 | tags:
12 | - SVM
13 | categories:
14 | - Machine learning
15 | - 吴恩达
16 | ---
17 |
18 |
19 |
20 | Week7-SVM
21 |
22 | 本周主要是讲解了支持向量机SVM的相关知识点
23 |
24 | - 硬间隔
25 | - 支持向量
26 | - 软间隔
27 | - 对偶问题
28 |
29 |
30 |
31 | ### 优化目标Optimization Objectives
32 |
33 | 主要是讲解如何从逻辑回归慢慢的推导出本质上的支持向量机。逻辑回归的假设形式：
34 |
35 | 
36 |
37 | - 左边是假设函数
38 | - 右边是`Sigmoid`激活函数
39 |
40 | 令$z=\theta^Tx$，如果满足：
41 |
42 | 1. 若$y=1$，希望$h(\theta)$约为1，将样本正确分类，那么z必须满足$z>>0$
43 | 2. 若$y=0$，希望$h(\theta)$约为0，将样本正确分类，那么z必须满足$z<<0$
44 |
45 | > 样本正确分类指的是：假设函数h(x)得到的结果和真实值y是一致的
46 |
47 | 
48 |
49 | 总代价函数通常是对所有的训练样本进行求和，并且每个样本都会为总代价函数增加上式的最后一项（还有个系数$\frac{1}{m}$，系数忽略掉）
50 |
51 | 1. 如果$y=1$，目标函数中只有第一项起作用，得到了表达式
52 | $$
53 | y=1-log(1-\frac{1}{1+e^{-z}})
54 | $$
55 |
56 | ### 支持向量机
57 |
58 | 
59 |
60 | 根据逻辑回归推导得到的支持向量机的公式
61 | $$
62 | min C\sum^m_{i=1}[y^{(i)}cost_1(\theta^Tx^{(i)})+(1-y^{(i)})cost_0(\theta^Tx^{(i)}]+\frac{1}{2}\sum^n_{i=1}\theta_{j}^2
63 | $$
64 | 两个$cost$函数是上面提到的两条直线。
65 |
66 | 对于逻辑回归，在目标函数中有两项：第一个是训练样本的代价，第二个是正则化项
67 |
68 | ### 大边界的直观解释
69 |
70 | 下面是支持向量机的代价函数模型。
71 |
72 | 
73 |
74 | #### SVM决策边界
75 |
76 | 
77 |
78 | **SVM鲁棒性**：间隔最大化，是一种大间距分类器。
79 |
80 | 
81 |
82 |
83 |
84 | 
85 |
86 | 关于上图的解释：
87 |
88 | 1. C太大的话，将是粉色的线
89 | 2. C不是过大的话，将是黑色的线
90 |
91 | > 大间距分类器的描述，仅仅是从直观上给出了正则化参数C非常大的情形，C的作用类似于之前使用过的正则化参数$\frac{1}{\lambda}$
92 |
93 | - C较大，可能导致过拟合，高方差
94 | - C较小，可能导致低拟合，高偏差
95 |
96 |
97 |
98 | #### 硬间隔模型
99 |
100 | 
101 |
102 |
103 |
104 | ### 间隔和支持向量
105 |
106 | 注释：本文中全部采用列向量$w=(w_1,w_2,…,w_n)$
107 |
108 | 给定一个样本训练集$D=\{(x_1,y_1),(x_2,y_2),…,(x_m,y_m)\}$，其中$y_i \in \{-1,+1\}$分类学习的基本思想就是：基于训练集D在样本空间上找到一个划分的超平面
109 |
110 | 
111 |
112 | 上面红色的线是最好的。所产生的分类结果是最鲁棒的，最稳定的，泛化能力是最好的。
113 |
114 | 划分超平面的的线性描述：
115 | $$
116 | w \cdot x+b=0
117 | $$
118 | $w$称之为法向量（看做是列向量），决定平面的方向；$b$是位移项，决定了超平面和原点之间的距离。
119 |
120 | 空间中任意一点$x$到超平面$(w,b)$的距离是
121 | $$
122 | r=\frac{|w \cdot x + b|}{||w||}
123 | $$
124 | 在$+$区域的点满足$y=+1$：
125 | $$
126 | w \cdot x_+ + b \geq1
127 | $$
128 | 在$-$区域的点满足$y=-1$：
129 | $$
130 | w \cdot x_- + b \leq-1
131 | $$
132 | 综合上面的两个式子有：
133 | $$
134 | y(w \cdot x_+ + b )-1 \geq0
135 | $$
136 |
137 | #### 支持向量
138 |
139 | 距离超平面最近的几个点（带上圆圈的几个点）称之为“支持向量support vector”，这个点到超平面到距离称之为“间隔margin”
140 |
141 | 刚好在决策边界上的点（下图中带上圆圈的点）满足上式中的等号成立：
142 | $$
143 | y_i(w \cdot x + b) -1=0
144 | $$
145 |
146 |
147 | 
148 |
149 |
150 |
151 | #### 间距margin
152 |
153 | 求解间距`margin`就是求解向量$(x_+-x_-)$在法向量上的投影
154 | $$
155 | \begin{align}margin& = (x_+-x_-)\cdot \frac{w}{||w||} \\& = \frac {(x_+ \cdot w-x_-\cdot w}{||w||}\end{align}
156 | $$
157 | 决策边界上的正例表示为：
158 | $$
159 | y_i=+1 \rightarrow 1*(w\cdot x_+ +b) - 1 =0 \rightarrow w\cdot x_+ =1-b
160 | $$
161 | 决策边界行的负例表示为：
162 | $$
163 | y_i=-1 \rightarrow -1*(w\cdot x_- +b) - 1 =0 \rightarrow w\cdot x_- =-1-b
164 | $$
165 | 将两个结果带入`margin` 的表达式中
166 | $$
167 | margin=\frac {1-b-(-1-b)}{||w||}=\frac{2}{||w||}
168 | $$
169 |
170 |
171 | 
172 |
173 |
174 |
175 | #### SVM的基本模型
176 |
177 | 最大间隔化只需要将$||w||$最小化即可
178 | $$
179 | \min_{w,b}\frac{1}{2}||w||^2 \\s.t. y_i(w\cdot x_i+b) \geq 1 ;i=1,2,...,m
180 | $$
181 |
182 | ### SVM-对偶模型
183 |
184 | #### 模型参数推导
185 |
186 | 希望求解上面基本模型对应超平面的模型
187 | $$
188 | f(x)= w\cdot x+b
189 | $$
190 | 利用拉格朗日乘子$\alpha_i$，改成拉格朗日函数
191 | $$
192 | L(w,b,\alpha)=\frac{1}{2}||w||^2+\sum^m_{i=1}\alpha_i(1-y_i(w^Tx_i+b))
193 | $$
194 | 分别对$w,b$求导，可以得到
195 | $$
196 | w = \sum^m_{i=1}\alpha_iy_ix_i \\ 0 = \sum^m_{i=1}\alpha_iy_i
197 | $$
198 |
199 |
200 | #### 对偶模型
201 |
202 | 原始问题是极大
203 | $$
204 | \min_{w,b}\max_{\alpha}L(w,b,\alpha)\rightarrow\max_{\alpha}\min_{w,b}L(w,b,\alpha)
205 | $$
206 | 最大值问题：带入拉格朗日函数中，得到对偶问题（全部是关于$\alpha$系数）
207 | $$
208 | \max _{\alpha}\sum^m_{i=1}\alpha_i-\frac{1}{2}\sum^m_{i=1}\sum^m_{j=1}\alpha_i\alpha_jy_i y_jx_i^Tx_j \\s.t. \sum^m_{i=1}\alpha_iy_i=0 \\\alpha_i \geq0;i=1,2,...,m
209 | $$
210 | 转换一下，变成最小值问题（上面的式子加上负号）：
211 | $$
212 | \min _{\alpha}\frac{1}{2}\sum^m_{i=1}\sum^m_{j=1}\alpha_i\alpha_jy_i y_jx_i^Tx_j - \sum^m_{i=1}\alpha_i\\s.t. \sum^m_{i=1}\alpha_iy_i=0 \\\alpha_i \geq0;i=1,2,...,m
213 | $$
214 |
215 |
216 | 那么超平面的模型
217 | $$
218 | \begin{align}f(x)& = w\cdot x+b \\& = \sum^m_{i=1}\alpha_iy_ix_i^Tx+b \end{align}
219 | $$
220 |
221 |
222 | ### SMO算法
223 |
224 | #### 思想
225 |
226 | SMO算法指的是`Sequential Minimal Optimization`，序列最小优化算法。算法的根本思路是：
227 |
228 | 所有的$\alpha$满足$\sum^m_{i=1}\alpha_iy_i=0 $：
229 |
230 | 1. 先选取需要更新的变量$\alpha_i$和$\alpha_j$
231 | 2. 固定变量$\alpha_i$和$\alpha_j$以外的参数，求解更新后的变量$\alpha_i$和$\alpha_j$
232 |
233 | $$
234 | \alpha_iy_i+\alpha_jy_j=c
235 | $$
236 |
237 | 其中$c$使得上式成立：
238 | $$
239 | c= \sum_{k \neq i,j}\alpha_ky_k
240 | $$
241 |
242 | 3. 将变量$\alpha_i$和$\alpha_j$的其中一个用另一个来表示，得到关于$\alpha_i$的单变量二次规划问题，就可以求出来变量$\alpha_i$
243 |
244 | ### 软间隔最大化
245 |
246 | 上面的结论和推导都是针对的线性可分的数据。线性不可分数据意味着某些样本点$(x_i,y_i)$不再满足函数间隔大于等于1的约束条件，比如下图中的红圈中的点，故引入了松弛变量$\xi_i \geq0$，满足：
247 | $$
248 | y_i(w \cdot x_i +b) +\xi_i \geq 1 \\ y_i(w \cdot x_i +b) \geq 1-\xi_i
249 | $$
250 | 
251 |
252 | 因此，**目标函数**由原来的$\frac{1}{2}||w||^2$变成了
253 | $$
254 | \frac{1}{2}||w||^2+C\sum^N_{i=1}\xi _i
255 | $$
256 | 其中$C\geq0$是惩罚项参数，C值越大对误分类的越大，C越小对误分类的惩罚越小。
257 |
--------------------------------------------------------------------------------
/week8-1.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: 吴恩达笔记8-KMeans
3 | top: false
4 | cover: false
5 | toc: true
6 | mathjax: true
7 | copyright: true
8 | date: 2019-12-04 22:10:56
9 | password:
10 | summary:
11 | tags:
12 | - K-Means
13 | - cluster
14 | - 聚类
15 | - 无监督
16 | categories:
17 | - Machine learning
18 | - 吴恩达
19 | ---
20 |
21 |
22 |
23 | Week8-聚类与降维
24 |
25 | 本周的主要知识点是无监督学习中的两个重点：聚类和降维。本文中主要介绍的是聚类中的K均值算法，包含：
26 |
27 | - 算法思想
28 | - 图解K-Means
29 | - sklearn实现
30 | - Python实现
31 |
32 |
33 |
34 | ### 无监督学习unsupervised learning
35 |
36 | #### 无监督学习简介
37 |
38 | 聚类和降维是无监督学习方法，在无监督学习中数据是没有标签的。
39 |
40 | 比如下面的数据中，横纵轴都是$x$，没有标签（输出$y$）。在非监督学习中，我们需要将一系列无标签的训练数据，输入到一个算法中，快速这个数据的中找到其内在数据结构。
41 |
42 | 
43 |
44 | #### 无监督学习应用
45 |
46 | - 市场分割
47 | - 社交网络分析
48 | - 组织计算机集群
49 | - 了解星系的形成
50 |
51 | 
52 |
53 | ### 聚类
54 |
55 | #### 聚类clustering
56 |
57 | 聚类试图将数据集中的样本划分成若干个通常是不相交的子集，称之为“簇cluster”。聚类可以作为一个单独过程，用于寻找数据内部的分布结构，也能够作为其他学习任务的前驱过程。聚类算法涉及到的两个问题：**性能度量和距离计算**
58 |
59 | #### 性能度量
60 |
61 | 聚类性能度量也称之为“有效性指标”。希望“物以类聚”。聚类的结果是“簇内相似度高”和“簇间相似度低”。
62 |
63 | 常用的**外部指标**是：
64 |
65 | 1. Jaccard 系数
66 | 2. FM 系数
67 | 3. Rand 系数
68 |
69 | 上述3个系数的值都在[0,1]之间，越小越好
70 |
71 | 常用的**内部指标**是：
72 |
73 | 1. DB指数
74 | 2. Dunn指数
75 |
76 | DBI的值越小越好，Dunn的值越大越好。
77 |
78 |
79 |
80 | #### 距离计算
81 |
82 | $x_i,x_j$的$L_p$的距离定义为
83 | $$
84 | L_p(x_i,x_j)=(\sum_{l=1}^{n}|x_i^{(l)}-x_j^{(l)}|^p)^\frac{1}{p}
85 | $$
86 |
87 |
88 | 规定：$p\geq1$，常用的距离计算公式有
89 |
90 | - 当$p=2$时，即为`欧式距离`，比较常用，即：
91 | $$
92 | L_2(x_i,x_j)=(\sum_{l=1}^{n}|x_i^{(l)}-x_j^{(l)}|^2)^\frac{1}{2}
93 | $$
94 |
95 |
96 | - 当$p=1$时，即`曼哈顿距离`，即：
97 | $$
98 | L_1(x_i,x_j)=(\sum_{l=1}^{n}|x_i^{(l)}-x_j^{(l)}|
99 | $$
100 |
101 | - 当$p$趋于无穷，为`切比雪夫距离`，它是各个坐标距离的最大值：
102 | $$
103 | L_{\infty}(x_i,x_j)=\mathop {max}\limits_{l}|x_i^{(l)}-x_j^{(l)}|
104 | $$
105 |
106 | #### 余弦相似度
107 |
108 |
109 | $$
110 | \cos (\theta)=\frac{x^{T} y}{|x| \cdot|y|}=\frac{\sum_{i=1}^{n} x_{i} y_{i}}{\sqrt{\sum_{i=1}^{n} x_{i}^{2}} \sqrt{\sum_{i=1}^{n} y_{i}^{2}}}
111 | $$
112 |
113 | #### Pearson皮尔逊相关系数
114 |
115 | $$
116 | \rho_{X Y}=\frac{\operatorname{cov}(X, Y)}{\sigma_{X} \sigma_{Y}}=\frac{E\left[\left(X-\mu_{X}\right)\left(Y-\mu_{Y}\right)\right]}{\sigma_{X} \sigma_{Y}}=\frac{\sum_{i=1}^{n}\left(x-\mu_{X}\right)\left(y-\mu_{Y}\right)}{\sqrt{\sum_{i=1}^{n}\left(x-\mu_{X}\right)^{2}} \sqrt{\sum_{i=1}^{n}\left(y-\mu_{Y}\right)^{2}}}
117 | $$
118 |
119 |
120 |
121 | ### K-均值算法
122 |
123 | #### 算法思想
124 |
125 | K-均值，也叫做`k-means`算法，最常见的聚类算法，算法接受一个未标记的数据集，然后将数据聚类成不同的组。 假设将数据分成n个组，方法为：
126 |
127 | - 随机选择K个点，称之为“聚类中心”
128 | - 对于数据集中的每个数据，按照距离K个中心点的距离，将其和距离最近的中心点关联起来，与同个中心点关联的所有点聚成一类。
129 | - 计算上面步骤中形成的类的平均值，将该组所关联的中心点移动到平均值的位置
130 | - 重复上面两个步骤，直到中心点不再变化。
131 |
132 | #### 图解K-means
133 |
134 | 1. 给定需要划分的数据，随机确定两个聚类中心点
135 | 2. 计算其他数据和这两个中心点的距离，划入距离小的类中，假设两个类是$C_1,C_2$
136 | 3. 确定上述步骤中两个类是$C_1,C_2$的均值，这个均值就是新的聚类中心
137 | 4. 重复：计算数据和这两个中心点的距离，划入距离小的类中，形成新的类；再确定新的聚类中心
138 | 5. 直至中心点不再变化，结束
139 |
140 | 
141 |
142 |
143 |
144 | 
145 |
146 |
147 |
148 | 
149 |
150 |
151 |
152 | 
153 |
154 | 
155 |
156 | **全过程**
157 |
158 | 
159 |
160 | #### K-mean算法过程
161 |
162 | 吴恩达视频的中的伪代码为
163 |
164 | ```python
165 | repeat {
166 | for i= to m
167 | # 计算每个样例属于的类
168 | c(i) := index (from 1 to K) of cluster centroid closest to x(i)
169 |
170 | for k = 1 to K
171 | # 聚类中心的移动，重新计算该类的质心
172 | u(k) := average (mean) of points assigned to cluster K
173 | }
174 | ```
175 |
176 | 西瓜书中的伪代码
177 |
178 | 
179 |
180 | #### 优化目标Optimization Objective
181 |
182 | K-均值最小化问题，是要最小化所有的数据点与其所关联的聚类中心点之间的距离之和，因此 K-均值的代价函数（**畸变函数Distortion function**）
183 | $$
184 | J\left(c^{(1)}, \ldots, c^{(m)}, \mu_{1}, \ldots, \mu_{K}\right)=\frac{1}{m} \sum_{i=1}^{m}\left\|X^{(i)}-\mu_{c^{(i)}}\right\|^{2}
185 | $$
186 | 其中$u_{c^{(i)}}$代表的是$x^{(i)}$最近的聚类中心点。优化目标就是找出使得代价函数最小的$c^{(1)},c^{(2)},…,c^{(m)}$和$\mu^1,\mu^2,…,\mu^k$，即：
187 |
188 | 
189 |
190 | #### 随机初始化
191 |
192 | 在运行`K-均值算法`的之前，首先要随机初始化所有的聚类中心点：
193 |
194 | - 选择$K < m$，即聚类中心的个数小于训练样本的实例数量
195 | - 随机训练$K$个训练实例，然后令K个聚类中心分别和这K个训练实例相等
196 |
197 | 关于K-means的局部最小值问题：
198 |
199 | 
200 |
201 |
202 |
203 | ### Scikit learn 实现K-means
204 |
205 | #### make_blobs数据集
206 |
207 | `make_blobs`聚类数据生成器`make_blobs`方法常被用来生成聚类算法的测试数据。它会根据用户指定的**特征数量、中心点数量、范围**等来生成几类数据。
208 |
209 | ### 主要参数
210 |
211 | ```python
212 | sklearn.datasets.make_blobs(n_samples=100, n_features=2,centers=3, cluster_std=1.0, center_box=(-10.0, 10.0), shuffle=True, random_state=None)[source]
213 | ```
214 |
215 | - n_samples是待生成的样本的总数
216 | - n_features是每个样本的特征数
217 | - centers表示类别数
218 | - cluster_std表示每个类别的方差
219 |
220 | ```python
221 | import numpy as np
222 | import matplotlib.pyplot as plt
223 | ```
224 |
225 |
226 | ```python
227 | # 导入 KMeans 模块和数据集
228 | from sklearn.cluster import KMeans
229 | from sklearn.datasets import make_blobs
230 | ```
231 |
232 |
233 | ```python
234 | # 定义画布
235 | plt.figure(figsize=(12,12))
236 | ```
237 |
238 | ```python
239 | # 定义样本量和随机种子
240 | n_samples = 1500
241 | random_state = 170
242 |
243 | # X是测试数据集，y是目标分类标签0，1，2
244 | X, y = make_blobs(n_samples=n_samples, random_state=random_state)
245 | ```
246 |
247 |
248 | ```python
249 | X
250 | ```
251 |
252 |
253 | array([[-5.19811282e+00, 6.41869316e-01],
254 | [-5.75229538e+00, 4.18627111e-01],
255 | [-1.08448984e+01, -7.55352273e+00],
256 | ...,
257 | [ 1.36105255e+00, -9.07491863e-01],
258 | [-3.54141108e-01, 7.12241630e-01],
259 | [ 1.88577252e+00, 1.41185693e-03]])
260 |
261 |
262 | ```python
263 | y
264 | ```
265 |
266 |
267 | array([1, 1, 0, ..., 2, 2, 2])
268 |
269 |
270 | ```python
271 | # 预测值的簇类
272 | y_pred = KMeans(n_clusters=2, random_state=random_state).fit_predict(X)
273 | ```
274 |
275 |
276 | ```python
277 | y_pred
278 | ```
279 |
280 |
281 | array([0, 0, 1, ..., 0, 0, 0], dtype=int32)
282 |
283 |
284 | ```python
285 | X[:,0] # 所有行的第1列数据
286 | ```
287 |
288 |
289 | array([ -5.19811282, -5.75229538, -10.84489837, ..., 1.36105255,
290 | -0.35414111, 1.88577252])
291 |
292 |
293 | ```python
294 | # 子图1的绘制
295 | plt.subplot(221)
296 | plt.scatter(X[:, 0], X[:, 1], c=y_pred)
297 | plt.title("incorrrect Number of Blods")
298 | ```
299 |
300 | 
301 |
302 |
303 |
304 | ```python
305 | transformation = [[0.60834549, -0.63667341],[-0.40887718, 0.85253229]]
306 | X_aniso = np.dot(X, transformation)
307 | y_pred = KMeans(n_clusters=3, random_state=random_state).fit_predict(X_aniso)
308 | ```
309 |
310 |
311 | ```python
312 | # 子图2的绘制
313 | plt.subplot(222)
314 | plt.scatter(X_aniso[:, 0], X_aniso[:, 1], c=y_pred)
315 | plt.title("Anisotropicly Distributed Blobs")
316 | ```
317 |
318 | 
319 |
320 | ```python
321 | X_varied, y_varied = make_blobs(n_samples=n_samples,
322 | cluster_std=[1.0,2.5,0.5],random_state=random_state)
323 | y_pred = KMeans(n_clusters=3, random_state=random_state).fit_predict(X_varied)
324 | ```
325 |
326 |
327 | ```python
328 | plt.subplot(223)
329 | plt.scatter(X_varied[:, 0], X_varied[:, 1], c=y_pred)
330 | plt.title("Unequal Variance")
331 | ```
332 |
333 | 
334 |
335 |
336 |
337 | ```python
338 | X_filtered = np.vstack((X[y == 0][:500],
339 | X[y == 1][:100],
340 | X[y == 2][:10]))
341 | y_pred = KMeans(n_clusters=3,random_state=random_state).fit_predict(X_filtered)
342 | ```
343 |
344 |
345 | ```python
346 | plt.subplot(224)
347 | plt.scatter(X_filtered[:, 0],
348 | X_filtered[:, 1],
349 | c=y_pred)
350 | plt.title("Unevenly Sized Blobs")
351 | plt.show()
352 | ```
353 |
354 |
355 | 
356 |
357 | #### python实现KNN算法
358 |
359 | ```python
360 | import numpy as np
361 | import random
362 | import pandas as pd
363 | import re
364 | import matplotlib.pyplot as plt
365 |
366 | def show_fig():
367 | dataSet = loadDataSet()
368 | fig = plt.figure()
369 | ax = fig.add_subplot(111)
370 | ax.scatter(dataSet[:, 0], dataSet[:, 1])
371 | plt.show()
372 |
373 | def calcuDistance(vec1, vec2):
374 | # 步骤1：定义欧式距离的公式
375 | # 计算两个向量之间的欧式距离：根号下[(x_1-x_2)^2+(y_1-y_2)^2+...+(x_n-y_n)^2]
376 | # ver1 - ver2：表示两个向量的对应元素相减
377 | return np.sqrt(np.sum(np.square(vec1 - vec2))) #注意这里的减号
378 |
379 | def loadDataSet():
380 | # 导入数据集，填写路径
381 | dataSet = np.loadtxt("/Users/peter/skl/cluster/dataset.csv")
382 | print(dataSet)
383 | return dataSet
384 |
385 | def initCentroids(dataSet, k):
386 | # 步骤2：初始化质心
387 | # dataset: 传入的数据
388 | # k: 选择分类的质心个数（也就是簇的个数）
389 | dataSet = list(dataSet)
390 | return random.sample(dataSet, k) # 使用random模块，随机选取k个样本数据
391 |
392 | def minDistance(dataSet, centroidList):
393 | # 步骤3：计算每个实例 item 和 centroidList 中k个质心的距离
394 | # 找出上面距离的最小值，并且加入相应的簇类中，总共k个簇
395 | clusterDict = dict() # 用于保存簇类结果
396 | clusterDict = dict() # dict保存簇类结果
397 | k = len(centroidList)
398 | for item in dataSet:
399 | vec1 = item
400 | flag = -1
401 | minDis = float("inf") # 初始化为最大值
402 | for i in range(k):
403 | vec2 = centroidList[i]
404 | distance = calcuDistance(vec1, vec2) # error
405 | if distance < minDis:
406 | minDis = distance
407 | flag = i # 循环结束时， flag保存与当前item最近的蔟标记
408 | if flag not in clusterDict.keys():
409 | clusterDict.setdefault(flag, [])
410 | clusterDict[flag].append(item) #加入相应的类别中
411 | return clusterDict #不同的类别
412 |
413 | def getCentroids(clusterDict):
414 | #重新计算k个质心
415 | centroidList = []
416 | for key in clusterDict.keys():
417 | centroid = np.mean(clusterDict[key], axis=0)
418 | centroidList.append(centroid)
419 | return centroidList #得到新的质心
420 |
421 |
422 | def getVar(centroidList, clusterDict):
423 | # 计算各蔟集合间的均方误差
424 | # 将蔟类中各个向量与质心的距离累加求和
425 | sum = 0.0
426 | for key in clusterDict.keys():
427 | vec1 = centroidList[key]
428 | distance = 0.0
429 | for item in clusterDict[key]:
430 | vec2 = item
431 | distance += calcuDistance(vec1, vec2)
432 | sum += distance
433 | return sum
434 |
435 | def showCluster(centroidList, clusterDict):
436 | # 展示聚类结果
437 | colorMark = ['or', 'ob', 'og', 'ok', 'oy', 'ow'] # 不同簇类标记，o表示圆形，另一个表示颜色
438 | centroidMark = ['dr', 'db', 'dg', 'dk', 'dy', 'dw']
439 |
440 | for key in clusterDict.keys():
441 | plt.plot(centroidList[key][0], centroidList[key][1], centroidMark[key], markersize=12) #质心点
442 | for item in clusterDict[key]:
443 | plt.plot(item[0], item[1], colorMark[key])
444 | plt.show()
445 |
446 |
447 | def main():
448 | dataSet = loadDataSet()
449 | centroidList = initCentroids(dataSet, 4)
450 | clusterDict = minDistance(dataSet, centroidList)
451 | # # getCentroids(clusterDict)
452 | # showCluster(centroidList, clusterDict)
453 | newVar = getVar(centroidList, clusterDict)
454 | oldVar = 1 # 当两次聚类的误差小于某个值是，说明质心基本确定。
455 |
456 | times = 2
457 | while abs(newVar - oldVar) >= 0.00001:
458 | centroidList = getCentroids(clusterDict)
459 | clusterDict = minDistance(dataSet, centroidList)
460 | oldVar = newVar
461 | newVar = getVar(centroidList, clusterDict)
462 | times += 1
463 | showCluster(centroidList, clusterDict)
464 |
465 | if __name__ == '__main__':
466 | show_fig()
467 | main()
468 | ```
469 |
--------------------------------------------------------------------------------
/week8-2.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: 吴恩达笔记9-PCA
3 | top: false
4 | cover: false
5 | toc: true
6 | mathjax: true
7 | copyright: true
8 | date: 2019-12-05 15:52:15
9 | password:
10 | summary:
11 | tags:
12 | - PCA
13 | - 降维
14 | categories:
15 | - Machine learning
16 | - 吴恩达
17 | ---
18 |
19 | > 在现实高维数据情况下，会有数据样本稀疏、距离计算困难等问题，被称为“维数灾难”。解决的方法就是降维，也称之为“维数约简”，即通过某种数据方法将原始高维属性空间转成一个低维“子空间”。在这个子空间中，样本密度大大提高，将高维空间中的一个低维“嵌入”。
20 |
21 |
22 |
23 | 
24 |
25 | ### 降维Dimensionality Reduction
26 |
27 | 数据降维主要是有两个动机：
28 |
29 | - 数据压缩Data Compression
30 | - 数据可视化Data Visualization
31 |
32 | #### 数据压缩Data Compression
33 |
34 | 
35 |
36 | 
37 |
38 | 上图解释：
39 |
40 | 1. 在一个三维空间中的特征向量降至二维的特征向量。
41 | 2. 将三维投影到一个二维的平面上，迫使所有的数据都在同一个平面上。
42 | 3. 这样的处理过程可以被用于把任何维度的数据降到任何想要的维度，例如将1000维的特征降至100维。
43 |
44 | #### 数据可视化Data Visualization
45 |
46 | 降维能够帮助我们进行数据的可视化工作。
47 |
48 | 
49 |
50 | 
51 |
52 | 上面图的解释：
53 |
54 | 1. 假设给定数据，具有多个不同的属性
55 | 2. 某些属性表示的含义可能相同，在图形中可以放到同一个轴上，进行数据的降维
56 |
57 |
58 |
59 | ### PCA- Principal Component Analysis
60 |
61 | 在**PCA**中，要做的是找到一个方向向量（**Vector direction**），当把所有的数据都投射到该向量上时，PCA的关键点就是找到一个投影平面使得投影误差最小化。方向向量是一个经过原点的向量，而投射误差是从特征向量向该方向向量作垂线的长度。
62 |
63 | 
64 |
65 |
66 |
67 | 
68 |
69 | #### PCA与线性回归的区别
70 |
71 | 1. 线性回归中的纵轴是预测值，PCA中特征属性
72 | 2. 误差不同：PCA是投射误差，线性回归是尝试最小化预测误差。
73 | 3. 线性回归的目的是预测结果，PCA是不做任何分析。
74 |
75 | 
76 |
77 | #### PCA算法
78 |
79 |
80 | >主成分分析中，首先对给定数据进行规范化，使得数据每一变量的平均值为0，方差为1。
81 | >
82 | >之后对数据进行**正交变换**，用来由线性相关表示的数据，通过正交变换变成若干个线性无关的新变量表示的数据。
83 | >
84 | >新变量是可能的正交变换中变量的方差和(信息保存)最大的，方差表示在新变量上信息的大小。将新变量一次成为第一主成分，第二主成分等。通过主成分分析，可以利用主成分近似地表示原始数据，便是对数据降维。
85 |
86 | PCA算法中从n维到k维的过程是
87 |
88 | - **均值归一化**。计算所有特征的均值，令$x_j=x_j-\mu_j$，如果特征不在一个数量级上，需要除以标准差
89 | - 计算**协方差矩阵 covariance matrix**
90 |
91 | $$
92 | \Sigma: \quad \sum=\frac{1}{m} \sum_{i=1}^{n}\left(x^{(i)}\right)\left(x^{(i)}\right)^{T}
93 | $$
94 |
95 | - 计算协方差矩阵$\sum$的**特征向量 eigenvectors**
96 |
97 | 
98 |
99 | 在西瓜书中的描述为
100 |
101 | 
102 |
103 | #### 主成分个数确定
104 |
105 | 关于`PCA`算法中主成分个数`k`的确定，一般是根据公式：
106 | $$
107 | \frac{\frac{1}{m} \sum_{i=1}^{m}\left\|x^{(i)}-x_{a p p r o x}^{(i)}\right\|^{2}}{\frac{1}{m} \sum_{i=1}^{m}\left\|x^{(i)}\right\|^{2}} \leq 0.01
108 | $$
109 | 不等式右边的`0.01`可以是`0.05`，或者`0.1`等，都是比较常见的。当为`0.01`的时候，表示保留了`99%`的方差数据，即大部分的数据特征被保留了。
110 |
111 | 
112 |
113 | 
114 |
115 | 当给定了个数k，协方差矩阵S中求解出来的各个特征值满足公式
116 | $$
117 | 1- \frac{\sum^k_{i=1}S_{ii}}{\sum^n_{i=1}S_{ii}} \leq0.01
118 | $$
119 |
120 | $$
121 | \frac{\sum^k_{i=1}S_{ii}}{\sum^n_{i=1}S_{ii}} \geq 0.99
122 | $$
123 |
124 | 这个和上面的公式是等价的。
125 |
126 | #### 重建的压缩表示
127 |
128 | 重建的压缩表示`Reconstruction from Compressed Representation`指的是将数据从低维还原到高维的过程。
129 |
130 | 
131 |
132 | 上图中有两个样本$s^{(1)},x^{(2)}$。通过给定的实数$z$，满足$z=U_{r e d u c e}^{T} x$，将指定的点位置映射到一个三维曲面，反解前面的方程：
133 | $$
134 | x_{\text {appox}}=U_{\text {reduce}} \cdot z, x_{\text {appox}} \approx x
135 | $$
136 |
137 | #### PCA特点
138 |
139 | 1. PCA本质上是将方差最大的方向作为主要特征，让这些特征在不同正交方向上没有相关性。
140 | 2. PCA是一种无参数技术
141 |
142 | #### Python实现PCA
143 |
144 | 利用numpy库实现PCA算法
145 |
146 | ```python
147 | import numpy as np
148 | import matplotlib.pyplot as plt
149 | import pandas as pd
150 |
151 | def loadData(filename):
152 | # 文件加载函数
153 | df = pd.read_table(filename, seq='\t')
154 | return np.array(df) # 一定要返回array数组
155 |
156 | def showData(dataMat, reconMat):
157 | # 图片显示函数
158 | fig = plt.figure() # 画布
159 | ax = fig.add_subplot(111) # 子图显示
160 | ax.scatter(dataMat[:, 0], dataMat[:, 1], c='green') # 散点图
161 | ax.scatter(np.array(reconMat[:, 0]), reconMat[:, 1], c='red')
162 | plt.show()
163 |
164 | def pca(dataMat, topNfeat): # topNfeat就是需要筛选的前K个主成分
165 | # 1. 样本中心化过程：所有样本属性减去属性的平均值
166 | meanVals = np.mena(dataMat, axis=0) # 平均值
167 | meanRemoved = dataMat - meanVals # 中心化之后的数据
168 |
169 | # 2.计算样本的协方差矩阵 XXT
170 | covmat = np.cov(meanRemoved, rowvar=0)
171 | print(covmat)
172 |
173 | # 3. 对协方差矩阵做特征值分解，求出特征向量和特征值，并且将特征值从大到小排序，筛选出topNfeat个
174 | # np.mat 实际上就是创建矩阵
175 | # np.linalg.eig 求解矩阵特征向量和特征值
176 | eigVals, eigVects = np.linalg.eig(np.mat(covmat))
177 | eigValInd = np.argsort(eigVals) # 将特征值进行排序，argsort返回的是索引
178 | eigValInd = eigValInd[:-(topNfeat + 1):-1] # 比如前7个，[:-8:-1]
179 | redEigVects = eigVects[:, eigValInd] # 取前topNfeat大的特征值所对应的特征向量
180 |
181 | # 将数据转换到低维空间中
182 | lowDataMat = meanRemoved * redEigVects # 只有topNfeat维，降维之后的数据
183 | reconMat = (lowDataMat * redEigVects.T) + meanVals # 重构数据
184 | return np.array(lowDataMat), np.array(reconMat)
185 |
186 | # 主函数部分
187 | if __name__ == "__main__":
188 | dataMat = loadDataSet(filepath) # 填写文件路径
189 | loadDataMat, reconMat = pca(dataMat, 1)
190 | # showData(dataMat, lowDataMat)
191 | showData(dataMat, reconMat)
192 | print(lowDataMat)
193 | ```
194 |
195 | ### sklearn中实现PCA
196 |
197 | > Linear dimensionality reduction using Singular Value Decomposition of the data to project it to a lower dimensional space. The input data is centered but not scaled for each feature before applying the SVD.
198 |
199 | [用sklearn学习PCA](https://www.cnblogs.com/pinard/p/6243025.html)
200 |
201 | #### 实现模块
202 |
203 | 在`scikit-learn`中，与`PCA`相关的类都在`sklearn.decomposition`包中。最常用的`PCA`类就是`sklearn.decomposition.PCA`。
204 |
205 | ```python
206 | class sklearn.decomposition.PCA(n_components=None, # 降维后的特征数目，直接指定一个整数
207 | copy=True,
208 | whiten=False, # 判断是否进行白化。白化：对降维后的数据的每个特征进行归一化，让方差都为1。默认是不白化
209 | svd_solver='auto', # 指定奇异值分解SVD的方法
210 | tol=0.0,
211 | iterated_power='auto',
212 | random_state=None)
213 | ```
214 |
215 | #### demo
216 |
217 | 利用`PCA`进行`IRIS`数据的分类
218 |
219 | ```python
220 | import numpy as np
221 | import matplotlib.pyplot as plt
222 | from mpl_toolkits.mplot3d import Axes3D # 3D模块
223 | from sklearn import decomposition # 压缩模块
224 | from sklearn import datasets
225 |
226 | np.random.seed(5)
227 |
228 | centers = [[1,1], [-1,-1], [1,-1]]
229 | iris = datasets.load_iris() # 导入数据
230 |
231 | X = iris.data # 样本空间
232 | y = iris.target # 输出
233 |
234 | fig = plt.figure(1, figsize=(4,3))
235 | plt.clf()
236 | ax = Axes3D(fig, rect=[0,0,.95,1], elev=48, azim=134)
237 |
238 | plt.cla()
239 | pca = decomposition.PCA(n_components=3)
240 | pca.fit(X)
241 | X = pca.transform(X)
242 |
243 | for name, label in [('Setosa', 0), ('Versicolour', 1), ('Virginica', 2)]:
244 | ax.text3D(X[y == label, 0].mean(),
245 | X[y == label, 1].mean() + 1.5,
246 | X[y == label, 2].mean(), name,
247 | horizontalalignment = 'center',
248 | bbox = dict(alpha=.5, edgecolor='w', facecolor='w'))
249 |
250 | y = np.choose(y, [1,2,0]).astype(np.float)
251 | ax.scatter(X[:, 0], X[:, 1], X[:, 2], c=y, cmap=plt.cm.nipy_spectral, edgecolor='k')
252 |
253 | ax.w_xaxis.set_ticklabels([])
254 | ax.w_yaxis.set_ticklabels([])
255 | ax.w_zaxis.set_ticklabels([])
256 |
257 | plt.show()
258 | ```
259 |
260 | 
261 |
--------------------------------------------------------------------------------
/week9-1.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: 吴恩达笔记10-异常检测
3 | top: false
4 | cover: false
5 | toc: true
6 | mathjax: true
7 | copyright: true
8 | date: 2019-12-06 11:35:39
9 | password:
10 | summary:
11 | tags:
12 | - 异常检测
13 | categories:
14 | - Machine learning
15 | - 吴恩达
16 | ---
17 |
18 | Week9-异常检测
19 |
20 |
21 | > “黑中有白，白中有黑，没有绝对的白，也没有绝对的黑，黑可衬白，白可映黑。万物皆可转换”。
22 |
23 | 本文中对异常检测算法做了小结，主要包含：
24 |
25 | 1. 问题产生
26 | 2. 高斯分布
27 | 3. 算法使用场景
28 | 4. 八种无监督异常检测技术
29 | 5. 异常检测和监督学习对比
30 | 6. 特征选择
31 |
32 |
33 |
34 |
35 |
36 | ### 异常检测Novelty Detection
37 |
38 | > 异常是相对于其他观测数据而言有明显偏离的，以至于怀疑它与正常点不属于同一个数据分布。
39 |
40 | 异常检测是一种**用于识别不符合预期行为的异常模式的技术**，又称之为异常值检测。在商业中也有许多应用，如网络入侵检测（识别可能发出黑客攻击的网络流量中的特殊模式）、系统健康性监测、信用卡交易欺诈检测、设备故障检测、风险识别等
41 |
42 | #### 问题动机
43 |
44 | 异常检测主要是运用于非监督学习的算法。问题的引出：通过飞机的检测开始。
45 |
46 | > 检测飞机的引擎制造商生产了一批飞机引擎，测试了其中的一些特征变量，比如引擎运转时产生的热量，或者引擎的振动等，假设有m个引擎，$x^{(1)},x^{(2)},…,x^{(m)}$。绘制出如下图表：
47 |
48 | 
49 |
50 | 对于给定的数据集，需要检测$x_{test}$是不是异常的，即这个测试数据不属于这组数据的几率是多少。从上图看出，在蓝色圈内属于该组的概率高，越是偏远的概率，属于该组的可能性就越低。
51 | $$
52 | \text { if } \quad p(x)\left\{\begin{array}{ll}{<\varepsilon} & {\text { anomaly }} \\ {>=\varepsilon} & {\text { normal }}\end{array}\right.
53 | $$
54 | 另外两个异常检测的应用例子是
55 |
56 | - 识别欺骗行为，通过用户多久登陆一次、访问过的页面、发布帖子的数量等建立模型，通过模型来识别那些不符合该模型的用户。
57 | - 检测数据中心的使用情况：内存使用、被访问的磁盘数量、CPU负载等
58 |
59 | #### 高斯分布
60 |
61 | 高斯分布也叫正态分布。分布满足：
62 | $$
63 | x \sim N\left(\mu, \sigma^{2}\right)
64 | $$
65 | 概率密度函数为
66 | $$
67 | p\left(x, \mu, \sigma^{2}\right)=\frac{1}{\sqrt{2 \pi} \sigma} \exp \left(-\frac{(x-\mu)^{2}}{2 \sigma^{2}}\right)
68 | $$
69 | 均值$\mu$为
70 | $$
71 | \mu=\frac{1}{m} \sum_{i=1}^{m} x^{(i)}
72 | $$
73 | 方差$\sigma^2$为
74 | $$
75 | \sigma^{2}=\frac{1}{m} \sum_{i=1}^{m}\left(x^{(i)}-\mu\right)^{2}
76 | $$
77 | **高斯分布的样例为**
78 |
79 | 
80 |
81 | 当均值$\mu$相同的时候
82 |
83 | - 方差的平方越大，图形是矮胖的
84 | - 方差的平方越小，图形是瘦高型的
85 |
86 | #### 使用场景
87 |
88 | 异常检测算法的使用场景一般是三种：
89 |
90 | 1. 在做特征工程的时候需要**对异常的数据做过滤**，防止对归一化等处理的结果产生影响
91 | 2. 对**没有标记输出**的特征数据**做筛选**，找出异常的数据
92 | 3. 对有标记输出的特征数据做二分类时，由于某些类别的训练**样本非常少，类别严重不平衡**，此时也可以考虑用非监督的异常点检测算法来做
93 |
94 | #### 算法
95 |
96 | 算法的具体过程是
97 |
98 | 1. 对于给定的数据集$x^{(1)}, x^{(2)}, \ldots, x^{(m)}$，计算每个特征的$\mu;\sigma^2$
99 | $$
100 | \mu_j=\frac{1}{m} \sum_{i=1}^{m} x^{(i)}_j
101 | $$
102 |
103 |
104 | $$
105 | \sigma^{2}_j=\frac{1}{m} \sum_{i=1}^{m}\left(x^{(i)}_j-\mu_j\right)^{2}
106 | $$
107 |
108 | 
109 |
110 | 2. 利用高斯分布进行计算$p(x)$
111 |
112 | $$
113 | p(x)=\Pi^n_{j=1}p(x_j;\mu_j;\sigma^2_j)=\Pi^n_{j=1}\frac{1}{\sqrt{2 \pi} \sigma_j} \exp \left(-\frac{(x_j-\mu_j)^{2}}{2 \sigma^{2}_j}\right)
114 | $$
115 |
116 | 3. 两个特征的训练集及特征非部分情况
117 |
118 | 
119 |
120 | 4. 三维图表示的是密度函数，$z$轴为根据两个特征的值估计的$p(x)$的值
121 |
122 | 
123 |
124 | 当 $p(x) > \varepsilon$时候，预测是正常数据， 否则为异常
125 |
126 | #### 异常算法的设计
127 |
128 | > 当我们开发一个异常检测系统时，从带标记（异常或正常）的数据着手
129 | >
130 | > - 从其中选择一部分正常数据用于构建训练集
131 | > - 然后用剩下的正常数据和异常数据混合的数据构成交叉检验集和测试集。
132 |
133 | ### 八种无监督异常检测技术
134 |
135 | 1. 基于统计的异常检测技术
136 | 1. MA滑动平均法
137 | 2. 3—Sigma（拉依达准则）
138 | 2. 基于密度的异常检测
139 | 3. 基于聚类的异常检测
140 | 4. 基于K-Means聚类的异常检测
141 | 5. One Class SVM的异常检测
142 | 6. Isolation Forest的异常检测
143 | 7. PCA+MD的异常检测
144 | 8. AutoEncoder异常检测
145 |
146 | ### 异常检测和监督学习对比
147 |
148 | 异常检测中采用的也是带标记的数据，和监督学习类似。二者对比为：
149 |
150 | | 异常检测 | 监督学习 |
151 | | :----------------------------------------------------------- | :----------------------------------------------------------- |
152 | | 非常少量的正向类（异常数据 $y=1$）,
大量的负向类（$y=0$） | 同时有大量的正向类和负向类 |
153 | | 许多不同种类的异常，非常难。根据非常 少量的正向类数据来训练算法。 | 有足够多的正向类实例，足够用于训练 算法，未来遇到的正向类实例可能与训练集中的非常近似。 |
154 | | 未来遇到的异常可能与已掌握的异常、非常的不同。 | |
155 | | 例如： 欺诈行为检测 生产（例如飞机引擎）检测数据中心的计算机运行状况 | 例如：邮件过滤器 天气预报 肿瘤分类 |
156 |
157 |
158 |
159 | 当**正样本的数量很少**，甚至有时候是0，即出现了太多没见过的不同的异常类型，对于这些问题，通常应该使用的算法就是异常检测算法。
160 |
161 | ### 特征选择
162 |
163 | 异常检测算法是基于高斯分布的。当然不满足高斯分布也能处理，但是最好转成高斯分布。误差分析是特征选择中很重要的点。
164 |
165 | 有些异常数据可能出现较高的$p(x)$的值，被算法当做是正常数据。通过误差分析，增加新的特征得到新的算法，帮助我们更好地进行异常检测。
166 |
167 | 
168 |
169 | 新特征获取：通过原有特征进行组合，得到新的特征
170 |
171 | ### 参考资料
172 |
173 | 1. 李航-统计学习方法
174 | 2. [八种无监督异常检测技术](https://www.csuldw.com/2019/03/24/2019-03-24-anomaly-detection-introduction/)
175 |
176 |
177 |
--------------------------------------------------------------------------------
/week9-2.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: 吴恩达笔记10-推荐系统
3 | top: false
4 | cover: false
5 | toc: true
6 | mathjax: true
7 | copyright: true
8 | date: 2019-12-08 23:17:42
9 | password:
10 | summary:
11 | tags:
12 | - 推荐系统
13 | - 协同过滤
14 | categories:
15 | - Machine learning
16 | - 吴恩达
17 | ---
18 |
19 | ### 推荐系统 Recommender Systems
20 |
21 | #### 推荐系统概述
22 |
23 | 常见的推荐系统有三种主要的应用常景
24 |
25 | - 个性化推荐：常以“推荐”、“猜你喜欢”、“发现”等形式出现，一般放在首页位置
26 | - 相关推荐：常以“相关推荐”、“看了还看”等形式出现，一般放在内容详情页
27 | - 热门推荐：基于各种数据进行计算，得到的排行榜，支持全局排行以及分类排行等，位置不限
28 |
29 |
30 |
31 | 推荐系统对用户的核心价值，主要表现在：
32 |
33 | 1. 帮助用户便捷、快速地筛选出感兴趣的内容
34 | 2. 在用户陌生的领域里面提供参考意见
35 | 3. 满足用户的好奇心
36 |
37 | 推荐系统的**主要工作**是：
38 |
39 | - 首先它基于用户的兴趣，根据**用户的历史行为**做兴趣的挖掘，把物品和用户的**个性化偏好**进行匹配。
40 | - 然后通过**推荐算法或者技术**把信息进行过滤，解决用户的**过载问题**。
41 | - 当用户有**新的行为**发生时，比如点击或者搜索之后，能及时进一步**捕捉用户的兴趣**。
42 | - 选择合适的场景，**个性化**或者相关的、热门的，来给用户进行推荐。
43 |
44 | > 个性化推荐系统解决的是用户很内容的关联关系，它是二者之间的桥梁。基于用户的兴趣偏好，把用户感兴趣的物品或者视频、资讯等推荐给用户，给用户带来沉浸式的体验。
45 |
46 | ------
47 |
48 | #### 问题形式化
49 |
50 | > 推荐系统应用的十分广泛：如果你考虑网站像亚马逊，或网飞公司或易趣，或**iTunes Genius**，有很多的网站或系统试图推荐新产品给用户。如，亚马逊推荐新书给你，网飞公司试图推荐新电影给你，等等。这些推荐系统，根据浏览你过去买过什么书，或过去评价过什么电影来判断。这些系统会带来很大一部分收入，比如为亚马逊和像网飞这样的公司。因此，对推荐系统性能的改善，将对这些企业的有实质性和直接的影响。
51 |
52 | **通过一个栗子来了解推荐系统**
53 |
54 | 假使我们是一个电影供应商，我们有 5 部电影和 4 个用户，我们要求用户为电影打分
55 |
56 | 
57 |
58 | 前三部是爱情片，后面两部是动作片。Alice和Bob更倾向于爱情片，Carol和Dave更倾向于动作片。一些标记
59 |
60 | - $n_u$用户的数量
61 | - $n_m$电影的数量
62 | - $r(i,j)$如果用户j给电影i评过份则$r(i,j)=1$
63 | - $y^{(i,j)}$代表的是用户j给电影i的评分
64 | - $m_j$表示的是用户j评过分的电影总数
65 |
66 | #### 基于内容的推荐系统Content Based Recommendations
67 |
68 | 在一个基于内容的推荐系统算法中，我们假设对于我们希望推荐的东西有一些数据，这些数据是有关这些东西的特征。现在假设电影有两个特征：
69 |
70 | - $x_1$浪漫程度
71 | - $x_2$动作程度
72 |
73 | 
74 |
75 | 那么每部电影都有一个特征向量，如第一部电影的是[0,9 0]
76 |
77 | 针对特征来构建一个推荐系统算法。假设使用的是线性回归模型，针对每个用户使用该模型，$\theta^{(1)}$表示的是第一个用户的模型的参数。定义如下：
78 |
79 | - $\theta^{(j)}$第$j$个用户的参数向量
80 | - $x^{(i)}$电影的$i$的特征向量
81 |
82 | 针对电影$i$和用户$j$，预测评分标准
83 | $$
84 | (\theta^{(j)})^Tx^{(i)}
85 | $$
86 | 代价函数可以表示为（针对用户j）：**误差平方和+正则化项**
87 | $$
88 | \min_{\theta(j)}\frac{1}{2}\sum_{i:r(i,j)=1}((\theta^{(j)})^Tx^{(i)}-y^{(i,j)}) + \frac {\lambda}{2}(\theta^{(j)}_k)^2
89 | $$
90 | 其中$i:r(i,j)$表示只计算用户$j$评过分的电影。**针对所有用户**的代价函数求和：
91 | $$
92 | \min_{\theta(1),...,\theta^{(n_u)}}\frac{1}{2}\sum^{n_u}_{j=1}\sum_{i:r(i,j)=1}((\theta^{(j)})^Tx^{(i)}-y^{(i,j)}) ^2+ \frac {\lambda}{2}\sum^{n_u}_{j=1}\sum^n_{k=1}(\theta^{(j)}_k)^2
93 | $$
94 | 使用梯度下降法求出最优解，更新参数$\theta^{(j)}_{(k)}$
95 | $$
96 | \theta^{(j)}_{(k)} := \theta^{(j)}_{(k)} - \alpha\sum_{i:r(i,j)=1}((\theta^{(j)})^Tx^{(i)}-y^{(i,j)})x^{(i)}_k ; k=0
97 | $$
98 |
99 | $$
100 | \theta^{(j)}_{(k)} := \theta^{(j)}_{(k)} - \alpha(\sum_{i:r(i,j)=1}((\theta^{(j)})^Tx^{(i)}-y^{(i,j)})x^{(i)}_k+\lambda\theta^{(j)}_k) ; k\neq0
101 | $$
102 |
103 | ### 协同过滤Collaborative Filtering
104 |
105 | 上面基于内容的过滤算法是通过电影的特征，使用特征来训练出每个用户的参数。相反，如果使用用户的参数，也可以学习得出电影的特征：
106 | $$
107 | \min_{x(1),...,x^{(n_m)}}\frac{1}{2}\sum^{n_m}_{i=1}\sum_{j:r(i,j)=1}((\theta^{(j)})^Tx^{(i)}-y^{(i,j)}) ^2+ \frac {\lambda}{2}\sum^{n_m}_{i=1}\sum^n_{k=1}(x^{(j)}_k)^2
108 | $$
109 | 如果没有用户的参数和电影的特征，协同过滤算法便可以同时学习这两者。
110 | $$
111 | J(x^{(1)},...x^{(n)},\theta^{(1),...,\theta^{(n_u)}}) = \frac{1}{2}\sum_{i,j:r(i,j)=1}((\theta^{(j)})^Tx^{(i)}-y^{(i,j)}) ^2+\frac {\lambda}{2}\sum^{n_m}_{i=1}\sum^n_{k=1}(x^{(j)}_k)^2+\frac {\lambda}{2}\sum^{n_u}_{j=1}\sum^n_{k=1}(\theta^{(j)}_k)^2
112 | $$
113 |
114 | 对代价函数求出偏导数的结果是：
115 | $$
116 | x^{(j)}_{(k)} := x^{(j)}_{(k)} - \alpha(\sum_{j:r(i,j)=1}((\theta^{(j)})^Tx^{(i)}-y^{(i,j)})\theta^{(i)}_k+\lambda x^{(j)}_k)
117 | $$
118 |
119 | $$
120 | \theta^{(j)}_{(k)} := \theta^{(j)}_{(k)} - \alpha(\sum_{i:r(i,j)=1}((\theta^{(j)})^Tx^{(i)}-y^{(i,j)})x^{(i)}_k+\lambda\theta^{(j)}_k)
121 | $$
122 |
123 | 协同过滤算法的过程：
124 |
125 | 1. 初始化$x，\theta$为很小的值
126 | 2. 使用梯度下降算法最小化代价函数$\min J(x,\theta)$
127 | 3. 训练完算法后，预测用户j给电影i的评分
128 |
129 | ### 向量化：低秩矩阵分解Vectorization_ Low Rank Matrix Factorization
130 |
131 | 协同过滤算法可以做的事情：
132 |
133 | 1. 给出一件商品，找到与之类似的商品
134 | 2. 当一个用户浏览了一件产品，找出类似的商品推荐给他
135 |
136 | 假设5部电影，4位用户，存放在矩阵中：
137 |
138 | | **Movie** | **Alice (1)** | **Bob (2)** | **Carol (3)** | **Dave (4)** |
139 | | :------------------- | :------------ | :---------- | :------------ | :----------- |
140 | | Love at last | 5 | 5 | 0 | 0 |
141 | | Romance forever | 5 | ? | ? | 0 |
142 | | Cute puppies of love | ? | 4 | 0 | ? |
143 | | Nonstop car chases | 0 | 0 | 5 | 4 |
144 | | Swords vs. karate | 0 | 0 | 5 | ? |
145 |
146 | **推出相应的评分**
147 |
148 | 
149 |
150 | **找出类似的影片**
151 |
152 | 
153 |
154 | ### 均值归一化Mean Normalization
155 |
156 | 
157 |
158 | 上图中，假设新来个用户Eva，他没有对任何的电影进行评分，那我们以什么依据来给他推荐电影呢？
159 |
160 | - 对上面的Y矩阵进行均值归一化，将每个用户对某一部电影的评分减去所有用户对该电影评分的平均值，得到如下的矩阵：
161 |
162 | 
163 |
164 | - 利用新的矩阵Y来训练算法。如果我们要用新训练出的算法来预测评分，则需要将平均值重新加回去，预测$(\theta^{(j)}x^{(i)}+\mu_i$，模型会人为其给每部电影的评分都是该电影的平均分。
165 |
--------------------------------------------------------------------------------