吴恩达机器学习

吴恩达机器学习

章节01 绪论：初识机器学习

什么是机器学习？

不同人不同时间对机器学习的定义：

Arthur Samuel（1959）：在没有明确设置的情况下使计算机具有学习能力的研究领域。

Tom Mitchell（1998）：计算机程序从经验E中学习解决某一任务T进行某一性能度量P，通过P测定在T上的表现因经验E而提高。

目前有各种不同类型的学习算法，最主要的两类是监督学习和无监督学习。

监督学习：就是我们会教计算机做某件事情。

无监督学习：我们让计算机自己学习。

监督学习

定义：我们给算法一个数据集，其中包含了正确答案。算法的目的就是给出更多的正确答案。

监督学习最大的特点就是其数据集带有标签。换句话来说，监督学习就是在带有标签的训练数据中学习模型，然后对某个给定的新数据利用模型预测它的标签。具体点来说，该数据集中的标签就像是作业的标准答案，而我们预测的标签则是我们给出的答案。如果我们的答案和标准答案不同，老师和父母就会来纠正，我们会进行学习，对题目的理解就会加深，正确率就会越来越高。

常见算法：分类算法(KNN、朴素贝叶斯、SVM、决策树、随机森林、BP神经网络算法等)和回归算法(逻辑回归、线性回归等)。

应用场景：分类和回归的场景，如垃圾邮件分类、心脏病预测等。

回归问题：回归是指我们的目标是预测一个连续值输出。

分类问题：其目的是预测离散值输出。

无监督学习

定义：对于给定的数据集，无监督学习算法可能判定该数据集包含两个或两个以上不同的簇，这就是聚类算法。

无监督学习是机器学习中的一种范例，它的主要特点是在训练数据中没有明确的标签或目标输出。在无监督学习中，算法试图从数据中自动发现模式、结构和关系，而不需要预先指定目标或监督信息。无监督学习通常用于数据探索、降维、聚类和生成。

以下是无监督学习的主要应用和方法：

1. 降维（Dimensionality Reduction）：无监督学习可用于减少数据的维度，从而更容易处理和可视化数据。主要方法包括主成分分析（PCA）和独立成分分析（ICA）。
2. 聚类（Clustering）：聚类是将数据点分组到相似的簇或类别中的任务。K均值聚类和层次聚类是常见的聚类算法。这有助于揭示数据中的内在结构。
3. 异常检测（Anomaly Detection）：无监督学习可用于识别数据中的异常值或异常模式。这在金融、网络安全和质量控制等领域有广泛应用。
4. 生成模型（Generative Models）：生成模型试图从数据中学习数据的分布，然后生成类似的新数据点。例如，生成对抗网络（GANs）是一种流行的生成模型。
5. 关联规则学习（Association Rule Learning）：这是用于发现数据集中项目之间关联关系的技术，例如在市场篮子分析中找到购物篮中常一起购买的商品。
6. 主题建模（Topic Modeling）：用于从文本数据中识别主题的无监督学习方法，例如潜在狄利克雷分配（Latent Dirichlet Allocation，LDA）。
7. 数据压缩和特征选择：无监督学习可以用于减少数据的维度，去除冗余信息，或选择最重要的特征，以提高模型的效率和泛化性能。

无监督学习的主要挑战是在没有明确目标的情况下进行学习，因此结果的解释可能更具挑战性。它通常用于发现数据中的隐含结构和模式，以便进一步的数据分析或用于监督学习的特征工程。无监督学习是机器学习中的重要分支，广泛应用于数据挖掘、自然语言处理、计算机视觉等领域。

章节02 单变量线性回归

模型描述

单变量线性回归即 简单线性回归 ，是一种 回归分析 方法。回归分析 在统计学上用来分析两个或者多个变量之间的相关关系及其程度。比如预测股票，预测产品销量等等。单变量 即使用单一变量预测，线性 即自变量与因变量之间的关系为线性的。回归 即根据之前的数据预测一个准确的输出值。

注意：

m = 训练集数目

x = ”输入“变量/特征

y = ”输出“变量/”目标“变量

（x，y）来表示一个训练样本

$$(x^{(i)},y^{(i)})来表示第i个训练样本，上标i只是训练集的一个索引，指的是表格中的第i行/列$$

$$h_{\theta }(x)={\theta }_0+{\theta }_{1}x这种模型被称为线性回归$$

代价函数

代价函数有助于将最可能的线性函数与我们的数据相拟合。在线性回归中，我们有一个这样的数据集，m表示训

代价函数也被称为平方误差函数（Squared error function），有时也被称为平方均方误差（Mean squared error）。为什么我们要求出误差的平方和，是因为误差平方代价函数，对于大多数问题，特别是线性回归问题都是一个合理的选择，其他代价函数也能很好的发挥作用，但是平方误差函数可能是解决线性回归问题最常用的手段了。在后面将更加详细的介绍J的工作原理以及尝试更加直观的解释它在计算什么，以及我们使用它的目的。

总结，我们可以使用代价函数来衡量我们得到的假设函数的准确度。
$$h_{\theta }(x)={\theta }_0+{\theta }_{1}x$$
在这个模型当中，对于不同的两个参数，输入不同的值，我们会得到不同的假设函数。

在线性回归中，我们有一个训练集，我们要做的就是得出
$${\theta }_0和{\theta }_1$$
这两个参数的值，来让假设函数表示的直线尽量地与这些数据点更好的拟合。

The best definition：在线性回归中，我们要解决的是一个最小化问题。对所有训练样本进行一个求和，对 i=1和 i=M的样本，将对假设进行预测得到的结果减去其实际价格（即将第i号对应的预测结果减去第i号房子的实际价格），所得的差的平方相加得到总和。

代价函数（一）

$$\begin{gathered} 假设函数：h_{\theta }(x)={\theta }_0+{\theta }_{1}x \\ 参数：{\theta }_0和{\theta }_1 \\ 代价函数：J({\theta }_0,{\theta }_1)=\frac{1}{2m}\sum _{i=1}^m{(h_{\theta }(x^{(i)})-y^{(i)})}^2 \\ 优化目标：尽量减小J({\theta }_0,{\theta }_1) \end{gathered}$$

对于假设函数而言，如果将其θ0=0，那么就可类比为正比例函数，将假设函数带入不同的系数θ1以此来画出代价函数图像，假设样本点的位置在(1,1),(2,2),(3,3)，那么此时假设函数其系数θ1=1时，所得到的代价函数值最小，类比于凹函数，θ1<1时，代价函数单调递减；θ1>1时，代价函数单调递增；在θ1=1时取最小值。这只是将θ1和代价函数作为图像的示例；当θ1,θ2两个参数同时有值的时候，那么将三维坐标系的x,y类比为θ1,θ2,将z轴看做是代价函数，会得到一个曲面，在曲面底部取得最小值。

代价函数（二）

$$横轴{\theta }_0和{\theta }_1,及竖轴J({\theta }_0,{\theta }_1),会形成一个碗装曲面,这就是代价函数的形状$$

代价函数 J 的意义 : 如何对应不同的假设函数以及接近代价函数 J 最小值的点对应着更好的假设函数。

我们真正想要的是一个高效的算法，一个软件的高效组成部分，来自动寻找代价函数 J 最小值对应的θ0和θ1。

梯度下降

可以将代价函数 J 最小化的梯度下降法。

梯度下降是很常用的算法，它不仅被用在线性回归上，还被广泛应用于机器学习的众多领域。
$$\begin{gathered} 我们有一个函数J({\theta }_0,{\theta }_1)，这也许是一个线性回归的代价函数，也许是一个需要最小化的其他函数， \\ 这里我们需要用一个算法来求最小化函数J({\theta }_0,{\theta }_1) \end{gathered}$$
梯度下降的思路（列举两个参数为例）：
$$\begin{gathered} 开始给定{\theta }_0和{\theta }_1的初始值。（通常选择{\theta }_0设为0，{\theta }_1设为0） \\ 我们在梯度下降算法中要做的是不停地一点点地改变{\theta }_0和{\theta }_1，来使J({\theta }_0,{\theta }_1)变小，直到找到J的最小值或者局部最小值 \end{gathered}$$

梯度下降算法的定义：
$${\theta }_j:={\theta }_j-\alpha \frac{\partial }{\partial {\theta }_j}J({\theta }_0,{\theta }_1)$$
我们将会反复做这一步直到收敛，我们要更新参数θ_j，为θ_j减去α乘以这一部分。

:=表示赋值

α是一个被称为学习速率的数字，α用来控制梯度下降时，所迈出多大的步子。若α值很大，则梯度下降就很迅速；若α很小，则梯度下降就慢。

正确实现梯度下降的方法（即同步更新）：
$$\begin{gathered} temp0:={\theta }_0-\alpha \frac{\partial }{\partial {\theta }_0}J({\theta }_0,{\theta }_1) \\ temp1:={\theta }_1-\alpha \frac{\partial }{\partial {\theta }_1}J({\theta }_0,{\theta }_1) \\ {\theta }_0:=temp0 \\ {\theta }_1:=temp1 \end{gathered}$$

梯度下降知识点总结

$$\begin{gathered} {\theta }_j:={\theta }_j-\alpha \frac{\partial }{\partial {\theta }_j}J({\theta }_0,{\theta }_1) \\ 其中：\frac{\partial }{\partial {\theta }_j}J({\theta }_0,{\theta }_1)为在({\theta }_0,{\theta }_1)处的偏导 \end{gathered}$$

$$\begin{gathered} 代价函数为凹函数。 \\ 此处类比{\theta }_1在最低点右侧 \\ {\theta }_1:={\theta }_1-\alpha \frac{\partial }{\partial {\theta }_1}J({\theta }_1) \\ {\theta }_1:={\theta }_1-\alpha (正数) \\ 这样做的好处就是左移{\theta }_1，将{\theta }_1不断逼近函数的最低点 \\ 同理，{\theta }_1在最低点左侧 \\ {\theta }_1:={\theta }_1-\alpha (负数) \\ 则{\theta }_1不断增大，逼近函数最低点。 \\ {\theta }_1:={\theta }_1-\alpha \frac{\partial }{\partial {\theta }_1}J({\theta }_1) \\ 如果\alpha 太小，梯度下降会很慢；如果\alpha 太大，梯度下降可能越过最低点，甚至可能无法收敛或者发散 \end{gathered}$$

$$\begin{gathered} {\theta }_1:={\theta }_1-\alpha \frac{\partial }{\partial {\theta }_1}J({\theta }_1) \\ 假设{\theta }_1初始化在局部最低点，局部最优点的导数等于0，则{\theta }_1:={\theta }_1-\alpha \ast 0，那么{\theta }_1将不再改变 \\ 随着{\theta }_1的不断更新，其对应点的导数在不断减小，那么其{\theta }_1与\alpha 的乘积也在不断减小，所以{\theta }_1所向最低点的幅度也在减小 \end{gathered}$$

在梯度下降法中，当我们接近局部最低点时，梯度下降法会自动采取更小的幅度，这是因为当我们接近局部最低点时，根据定义在局部最低时导数等于0，所以当我们接近局部最低时，导数值会自动变的越来越小，所以梯度下降将自动采取较小的幅度。这就是梯度下降的运行方式，故实际上没有必要再另外减小α。

线性回归的梯度下降

线性回归的算法：梯度下降和代价函数相结合

作用：可以用直线模型来拟合数据

$$\begin{gathered} \frac{\partial }{\partial {\theta }_j}J({\theta }_0,{\theta }_1)=\frac{\partial }{\partial {\theta }_j}\frac{1}{2m}\sum _{i=1}^m{(h_{\theta }(x^{(i)})-y^{(i)})}^2 \\ =\frac{\partial }{\partial {\theta }_j}\frac{1}{2m}\sum _{i=1}^m{({\theta }_0+{\theta }_1{x}^{(i)}-y^{(i)})}^2 \\ j=0:\frac{\partial }{\partial {\theta }_0}J({\theta }_0,{\theta }_1)=\frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)}) \\ j=1:\frac{\partial }{\partial {\theta }_1}J({\theta }_0,{\theta }_1)=\frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})\ast x^{(i)} \end{gathered}$$
回归的梯度下降法：
$$\begin{gathered} {\theta }_0:={\theta }_0-\alpha \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)}) \\ {\theta }_1:={\theta }_1-\alpha \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})\ast x^{(i)} \end{gathered}$$

章节03 线性代数回顾

矩阵和向量

矩阵是指由数字组成的矩形阵列并写在方括号内：
KaTeX parse error: Undefined control sequence: \matrix at position 8: \left[\̲m̲a̲t̲r̲i̲x̲{ 123 & 321\\…
因此实际上矩阵可以说是二维数组的另一种说法。

矩阵的维数应该写为：矩阵的行数乘以列数
$$A_{ij}=矩阵的第i行，第j列对应的那个数$$
向量：一个向量是一种特殊的矩阵，向量是只有一列的矩阵
$$y是一个n维列向量，则y_i=表示向量y的第i个元素$$
一般情况下，大写英文字母表示矩阵，而小写英文字母表示向量。

加法和标量乘法

矩阵求和：需要保证矩阵大小一致。
KaTeX parse error: Undefined control sequence: \matrix at position 8: \left[\̲m̲a̲t̲r̲i̲x̲{ 1 & 0\\ 2…
标量乘法，除法类似。
KaTeX parse error: Undefined control sequence: \matrix at position 11: 3* \left[\̲m̲a̲t̲r̲i̲x̲{ 4 & 1\\ 2…
操作组合：略

矩阵向量乘法

略

矩阵乘法

略

矩阵乘法特征

矩阵乘法不可以交换：A×B≠B×A

A×B×C可以用乘法的结合律

让D=B×C，计算A×D

让E=A×B，计算E×C
$$I指单位矩阵，I_{n\times n}指n维单位矩阵单位矩阵的乘法符合乘法交换律$$

逆和转置

$$\begin{gathered} 逆 \\ 只有m\times m的矩阵才有其逆矩阵，m\times m的矩阵也可以被称为方阵 \\ A{A}^{-1}=A^{-1}A=I \end{gathered}$$

$$\begin{gathered} 转置 \\ B=A^T则B_{ij}=A_{ji}，对应位置的元素相等 \end{gathered}$$

章节04 配置

略

章节05 多变量线性回归

多功能

多元线性回归：多特征量情况下的假设形式，多元即多个特征量或者变量来预测Y值

表示法：
$$\begin{gathered} n=表示特征量的数目 \\ {x}^{(i)}=表示第i个训练样本的输入特征值 \\ {x}_j^{(i)}=表示第i个训练样本中的第j个特征量的值 \\ {h}_{\theta }(x)={\theta }_0+{\theta }_1{x}_1+{\theta }_2{x}_2+...+{\theta }_n{x}_n \\ 为了便于符号化，定义x_0=1 \\ x\in \left[\begin{array}{c}{x}_0\\ x_1\\ ...\\ x_n\end{array}\right]\in R^{n+1}\theta \in \left[\begin{array}{c}{\theta }_0\\ {\theta }_1\\ ...\\ {\theta }_n\end{array}\right]\in R^{n+1} \end{gathered}$$

多元梯度下降法

$$\begin{gathered} 多选线性回归的假设形式：h_{\theta }(x)={\theta }_0{x}_0+{\theta }_1{x}_1+{\theta }_2{x}_2+...+{\theta }_n{x}_n \\ ={\theta }^{T}x \\ 模型的参数包括：{\theta }_0，{\theta }_1，...，{\theta }_n（把这些参数看成一个n+1维的\theta 向量） \\ 代价函数:J({\theta }_0,{\theta }_1,...,{\theta }_n)=J(\theta )=\frac{1}{2m}\sum _{i=1}^m{(h_{\theta }(x^{(i)})-y^{(i)})}^2 \\ J({\theta }_0,{\theta }_1,...,{\theta }_n)可以看作是J(\theta )这里的\theta 就是一个向量 \\ 梯度下降：重复【{\theta }_j:={\theta }_j-\alpha \frac{\partial }{\partial {\theta }_j}J({\theta }_0,{\theta }_1,...,{\theta }_n)】（同时更新每个j=\mathrm{0..}，n） \\ 超过一个特征值时的新的算法（特征值个数n\ge 1）: \\ 重复【{\theta }_j:={\theta }_j-\alpha \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}】（同时更新{\theta }_j的j=\mathrm{0..}，n） \\ {\theta }_0:={\theta }_0-\alpha \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})x_0^{(i)} \\ {\theta }_1:={\theta }_1-\alpha \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})x_1^{(i)} \\ {\theta }_2:={\theta }_2-\alpha \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})x_2^{(i)} \\ ... \end{gathered}$$

多元梯度下降法演练Ⅰ-特征缩放

想法：确保不同特征值的取值都处在一个相近的范围。

特征缩放：使每个特征都接近于-1 ≤ Xi ≤ 1范围。特征缩放其实不需要特别精确，只是为了让梯度下降能够运行得更快而已。

均值归一化：
$$\begin{gathered} 特征缩放：使每个特征都接近于‘-1\le x_i\le 1‘范围。 \\ 均值归一化：如果有一个特征x_i就用x_i-{\mu }_i来替换，让特征值具有为0的平均值（不需要把这一步应用到x_0，因为x_0=1） \\ {x}_i=\frac{x_i-{\mu }_i}{s_i},其中{\mu }_i是训练集中特征x_i的平均值，s_i是该特征值的范围（最大值减最小值） \end{gathered}$$

多元梯度下降法Ⅱ-学习率

$${\theta }_j:={\theta }_j-\alpha \frac{\partial }{\partial {\theta }_j}J(\theta )$$

梯度下降算法就是找到一个θ值并且希望它能够最小化代价函数J(θ)

在梯度下降算法运行时，绘出代价函数J(θ)的值，在绘图时，x轴表示的是迭代次数，随着梯度下降算法的运行会得到一条曲线，随着迭代次数的增加代价函数J(θ)的值将会越来越小，最终会变成一条接近与x轴平行的直线。如果梯度下降算法正常工作的话，每一步迭代之后J(θ)都应该下降，这条所画的曲线的用处是能够清晰地判断梯度下降算法是否已经收敛。对于每一个特定的问题，梯度下降算法所需的迭代次数可能相差会很大，所以可能对于某一个问题梯度下降算法可能迭代30次即可收敛，然而换一个问题也许梯度下降算法就需要3000步迭代，对于另一个机器学习问题则可能需要三百万步迭代。我们很难判断梯度下降算法需要多少步迭代才能收敛。通常画出代价函数随迭代次数增加的变化曲线，通过看这种曲线来判断，梯度下降算法是否已经收敛。

-对于足够小的α，J(θ)在每一次迭代中都会减少。

-但如果α太小，梯度下降可能会收敛缓慢。

总结：

如果学习率α太小的话，会遇到收敛速度慢的问题。

如果学习率α太大的话，代价函数J(θ)可能不会在每次迭代都下降，甚至可能不收敛。（某些情况下，也可能会出现收敛缓慢）

所以为了调试所有的情况通常绘制J(θ)随迭代步数变化的曲线。尝试不同的α值，比如0.001，0.01，…，去找到一个最合适的学习率α。

特征和多项式回归

特征选择
下面讨论了不单止可以使用两个特征是房子临街宽度frontage和房子纵深长度depth，还可以把两个特征房子临街宽度frontage和房子纵深长度depth两者相乘。得到一个特征房子面积大小，上面两个方式都可以应用到线性回归模型，也即可以自由徐选择使用什么特征，并通过设计不同的特征，能够用更复杂的函数拟合数据。而不是只用一条直线去拟合数据。特别是可以使用多项式函数(二次函数/三次函数)去拟合数据。
$$\begin{gathered} 设置有两个特征，分别是房子临街宽度frontage和房子纵深长度depth，然后建立如下的线性回归模型。 \\ 第一个特征x_1：房子临街宽度frontage。 \\ 第二个特征x_2：房子纵深长度depth。 \\ 但当在运用线性回归时，不一定非要直接用给出的特征x_1和特征x_2，即可以创造新的特征来使用。 \\ 如预测房子价格，那么首先创造一个房子面积大小的新特征x，即房子临街宽度frontage和房子纵深长度depth的乘积。 \\ 得出公式：房子面积大小(特征x)=房子临街宽度frontage(特征x_1)\ast 房子纵深长度depth的乘积(特征x_2) \\ 使用两个特征的线性回归模型：h_{\theta }(x)={\theta }_0+{\theta }_1\ast frontage+{\theta }_2\ast depth \\ 第一个特征x_1：房子临街宽度frontage。第二个特征x_2：房子纵深长度depth。 \\ 使用一个特征的线性回归模型：h_{\theta }(x)={\theta }_0+{\theta }_1\ast x \\ 特征x：房子面积大小(特征x)是房子临街宽度frontage(特征x_1)和房子纵深长度depth(特征x_2)的乘积。 \\ 此处我们不一定使用两个特征的线性回归模型，也可以转换为使用一个特征的线性回归模型，可能会得到更好的模型。 \end{gathered}$$
多项式回归

多项式回归能够使用线性回归的方法来拟合非常复杂的函数，甚至是非线性函数。主要探讨如何将一个多项式(比如二次函数/三次函数)拟合到数据上。举例一个住房价格的数据集，然后还提供有多个不同的公式模型可分别用于拟合数据集。
$$第一个公式模型：二次函数模型{\theta }_0+{\theta }_1\ast x+{\theta }_2\ast x^2$$
因为直线似乎并不能很好地拟合这些数据，因此可以使用这样的二次函数模型去拟合。考虑到价格可能是一个二次函数，那么便可以画出二次函数曲线般去拟合这些数据。但是二次函数模型也存在不合理的地方，比如说二次函数模型最终会降下来，那么就意味着随着房子面积的不断增加达到一个临界点之后，房子面积还继续增加，但是此时的房子价格却不会继续上升，而是开始下降。那么这样的二次函数模型明显是有问题的。

所以既然二次函数会存在这样的问题，那就可以选择一个不同的多项式模型，即选择使用一个三次函数模型。三次函数模型即使超过了某个临界点，也不会下降，只会继续上升。也即意味着随着房子面积的不断增加，房子价格也继续会上升。
$$\begin{gathered} 利用三次函数模型{\theta }_0+{\theta }_1\ast x+{\theta }_2\ast x^2+{\theta }_3\ast x^3与数据集进行拟合 \\ 使用多元线性回归的方法，用h_{\theta }(x)={\theta }_0+{\theta }_1\ast x_1+{\theta }_2\ast x_2+{\theta }_3\ast x_3假设函数来拟合数据。 \\ 下面讨论使用三次函数模型{\theta }_0+{\theta }_1\ast x+{\theta }_2\ast x^2+{\theta }_3\ast x^3来拟合数据。 \\ 例:要进行预测房子价格 \\ {\theta }_0+{\theta }_1\ast (size)+{\theta }_2\ast (size{)}^2+{\theta }_3\ast (size{)}^3 \\ 表示用{\theta }_0+{\theta }_1\ast 房子面积+{\theta }_2\ast 房子面积的平方+{\theta }_3\ast 房子面积的立方。 \\ {h}_{\theta }(x)={\theta }_0+{\theta }_1\ast x_1+{\theta }_2\ast x_2+{\theta }_3\ast x_3中的x_1、x_2、x_3均为输入特征。 \\ 把h_{\theta }(x)={\theta }_0+{\theta }_1\ast x_1+{\theta }_2\ast x_2+{\theta }_3\ast x_3和{\theta }_0+{\theta }_1\ast (size)+{\theta }_2\ast (size{)}^2+{\theta }_3\ast (size{)}^3两者关联起来 \\ 把特征x_1设置为房子面积size，把特征x_2设置为房子面积size的平方，把特征x_3设置为房子面积size的立方 \\ 即设x_1=(size)、x_2=(size{)}^2、x_3=(size{)}^3 \\ 再用线性回归方法h_{\theta }(x)={\theta }_0+{\theta }_1\ast x_1+{\theta }_2\ast x_2+{\theta }_3\ast x_3， \\ 就可以拟合这个三次函数模型{\theta }_0+{\theta }_1\ast (size)+{\theta }_2\ast (size{)}^2+{\theta }_3\ast (size{)}^3到数据集上 \\ 如像上述那样设置特征x_1=(size)、x_2=(size{)}^2、x_3=(size{)}^3 \\ 特征x_1=(size)：房子面积范围大小在1到1000之间 \\ 特征x_2=(size{)}^2：房子面积的平方的范围大小就在1到一百万(1000的平方)之间 \\ 特征x_3=(size{)}^3：房子面积的平方的范围大小就在1到10的9次方之间 \\ 可以看出上述3个特征的范围相差很大，因此此时使用梯度下降法的话，那么运用特征缩放就显得更加尤为重要了 \end{gathered}$$

$$\begin{gathered} 之前所述的二次函数模型{\theta }_0+{\theta }_1\ast x+{\theta }_2\ast x^2拟合数据并不是很理想，因为二次函数模型拟合数据到最终曲线会下降，曲线会 \\ 下降即意味着房子面积增加的情况下房子价格反而下降的情况，这是使用二次函数模型不理想的地方。因此采用三次函数模型 \\ {\theta }_0+{\theta }_1\ast x+{\theta }_2\ast x^2+{\theta }_3\ast x^3来拟合数据。当然除了使用三次函数模型之外，还可以通过其他模型来进行拟合。 \\ 如：h_{\theta }(x)={\theta }_0+{\theta }_1\ast (size)+{\theta }_2\ast \sqrt{size}。\sqrt{size}表示求房子面积size的平方根。 \\ 表示预测的房子价格={\theta }_0+{\theta }_1\ast 房子面积+{\theta }_2\ast 房子面积的平方根。 \\ 那么该函数的曲线趋势上升到一定程度之后便慢慢变得平缓，曲线最终也不会下降的，最多也只会缓慢上升。 \end{gathered}$$

正规方程（区别于迭代方法的直接解法）

为了求出最优解θ，假如θ是个实数，我们可以求导，令导数等于0得到θ。

但是这里θ是一个N维向量，可以运用微积分的知识，分别对θ1，θ2，θ3，…，求偏导数令其为0得到最优解。

正规方程提供了一种求θ的解析方法，不需要再像之前梯度下降算法那样运行迭代算法，而是可以直接一次性求解θ的最优值，即只需要一步就可以得到最优值。
$$\begin{gathered} 假设有一个非常简单的代价函数：J(\theta )=\alpha {\theta }^2+b\theta +c（这里的\theta 是一个实数） \\ 可以利用对\theta 求导，然后令J(\theta )的导数等于0即可得到令J(\theta )最小的\theta 值。 \end{gathered}$$
在目前所探讨的问题中，θ不是一个实数，而是一个n+1维的参数向量
$$\begin{gathered} \theta \in R^{n+1}J({\theta }_0,{\theta }_1,...,{\theta }_m)=\frac{1}{2m}\sum _{i=1}^m{(h_{\theta }(x^{(i)})-y^{(i)})}^2 \\ \frac{\partial }{\partial {\theta }_j}J(\theta )=...=0(对每一个j都求偏导，并令其偏导为0，求对应的{\theta }_j的值) \end{gathered}$$
举一个m=4的例子，构建一个矩阵X
KaTeX parse error: Undefined control sequence: \matrix at position 10: X=\left[\̲m̲a̲t̲r̲i̲x̲{ 1 & 2104&5&…

KaTeX parse error: Undefined control sequence: \matrix at position 75: … x^{(i)}=\left[\̲m̲a̲t̲r̲i̲x̲{ x_0^{(i)}\\…

何时使用梯度下降法，何时使用正规方程法

如有m个训练样本，n个特征变量

梯度下降法	正规方程法
缺点：需要选择学习速率α，运行多次尝试不同的α，找到最好的那个α	优点：不需要选择学习速率α
缺点：需要更多次的迭代	优点：也不需要迭代，所以不需要画出J(θ)的曲线
优点：在特征变量很多的情况下也能运行地相当好	缺点：为了求解参数θ，需要求(X^T)X^(-1)这个n×n地矩阵，若有n个特征变的话，其复杂度为O(n^3)，故若n很大，其时间消耗会太大

所以取决于特征变量的多少来决定用什么方法，但是其界限很难确定。

总结：只要特征变量的数目并不大，正规方程是一个很好的计算参数θ的替代方法，具体地说只要特征变量数量小于一万，吴老师会用正规方程法。

正规方程在矩阵不可逆情况下的解决方法

$$\begin{gathered} \theta =(X^{T}X{)}^{-1}{X}^{T}y \\ 如果X^{T}X是不可逆矩阵(奇异或退化矩阵)，怎么进行处理？ \\ 在Octave里可以直接pinv(X^{\prime }\ast X)\ast X^{\prime }\ast y得到正解。 \\ Octave里有两个函数可以求解矩阵的逆，一个被称为pinv，另一个是inv，两者之间的差异是技术性的 \\ 一个是所谓的伪逆，另一个被称为逆。即使矩阵不可逆也可以直接用Octave里面的两个函数求解\theta \end{gathered}$$

$$\begin{gathered} X^{T}X不可逆的两个常见原因： \\ 1.由于某些原因，学习问题包含了多余的特征。 \\ 如在预测住房价格时，如果x_1是以平方英尺为单位的房子面积，x_2是以平方米为单位的房子面积。1m=3.28feet \\ {x}_1=(3.28{)}^2{x}_2两个特征可以用一个线性方程联系起来，这样的话X^{T}X是不可逆矩阵。 \\ 2.在运行的学习算法，有很多特征。具体地说在训练样本m小于或等于特征变量n的时候。 \\ 解决办法是看能否删除某些特征，或者使用一种叫做正规化的方法。 \end{gathered}$$

$$\begin{gathered} 总结：如果X^{T}X是不可逆矩阵，首先看特征里是否有多余的特征像x_1和x_2若是线性相关的或互为线性函数。若的确有一些多余 \\ 的特征，可以删除其中一个，无需将两个特征同时保留，所以删除二者其一。如果特征里没有多余的，检查是否有过多的特征， \\ 如果特征数量实在太多，在不影响结果的情况下删除一些特征，或者考虑使用正规化方法 \end{gathered}$$

导师的编程小技巧

略

章节06 Octave/Matlab教程(Python编程)

基本操作

移动数据

计算数据

数据绘制

控制语句: for，while…

矢量

本章课程总结

编程作业: 线性回归

01 简单的练习

总结下题目：输出一个5*5的单位矩阵

在此我们用np.eye(N,M=None, k=0, dtype=<type ‘float’>)

函数的原型：numpy.eye(N,M=None,k=0,dtype=<class 'float'>,order='C')

返回的是一个二维2的数组(N,M)，对角线的地方为1，其余的地方为0.

参数介绍：

（1）N：int型，表示的是输出的行数即方阵的维度

（2）M：int型，可选项，输出的列数，如果没有就默认为M=N

（3）k：int型，可选项，默认对角线为1，其余全为0；如果k为正数，则对角线往上第k个全为1，其余全为0；如果k为负数，则对角线往下第k个全为1，其余全为0

（4）dtype：数据的类型，可选项，返回的数据的数据类型

（5）order：{‘C’，‘F’}，可选项，也就是输出的数组的形式是按照C语言的行优先’C’，还是按照Fortran形式的列优先‘F’存储在内存中

import numpy as np
A = np.eye(5)
print(A)
"""
[[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]]
"""

02 单变量线性回归

根据这座城市的人口数量及该城市小吃店的利润，来预测开小吃店的利润。

2.1 绘制数据

• 读入数据：在此我们引入pandas库，该库可以帮助我们从诸如 csv 类型的文件导入数据，并且可以用它快速的对数据进行转换和过滤的操作。

  import pandas as pd
  path = "machine-learning-ex1\machine-learning-ex1\ex1\ex1data1.txt"
  data = pd.read_csv(path,header=None,names=['Population','Profit'])#header决定要不要原始的表头，name给出自定义的表头。
  print(data.head())#从头查询数据,默认的是查看5行
  """
     population   profit
  0      6.1101  17.5920
  1      5.5277   9.1302
  2      8.5186  13.6620
  3      7.0032  11.8540
  4      5.8598   6.8233
  """
  

• 数据可视化：在此我们引入matplotlib.pyplot库，使用plot函数画图。

  import matplotlib.pyplot as plt
  data.plot(kind='scatter', x='Population', y='Profit', figsize=(12,8))#生成图形，kind指定所画图的类型，figsize 指定图片大小。
  plt.show()#显示图形
  

2.2 梯度下降

这部分需要使用梯度下降将线性回归参数 θ 拟合到数据集上。

2.21 公式

• 代价函数
  $$J(\theta )=\frac{1}{2m}\sum _{i=1}^m{(h_{\theta }(x^{(i)})-y^{(i)})}^2$$

• 假设函数
  $$h_{\theta }(x)={\theta }^{T}x={\theta }_0+{\theta }_1{x}_1$$

• 参数更新
  $$重复【{\theta }_j:={\theta }_j-\alpha \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}】（同时更新{\theta }_j的j=\mathrm{0..}，n）$$

• 随着梯度下降不断地更新参数，参数也就越接近使代价函数最小的最优值

2.22 实现

• 我们要为我们之前读取的数据添加一列x，用来更新θ_0。

  data.insert(0, 'Ones', 1) #相当于在第0列，添加一个表头名为Ones，并且该列均为1
  print(data.head())
  """
     Ones  Population   Profit
  0     1      6.1101  17.5920
  1     1      5.5277   9.1302
  2     1      8.5186  13.6620
  3     1      7.0032  11.8540
  4     1      5.8598   6.8233
  """
  

• 分割X和y。使用pandas的iloc来进行选择训练集X和目标y

  iloc函数作用：iloc[]函数，属于pandas库，全称为index location，即对数据进行位置索引，从而在数据表中提取出相应的数据。

  # 分割X和y
  lists = data.shape[1]#输出列数
  X = data.iloc[:,:-1]#X是第一列到最后一列，但不包括最后一列，因为 python的范围/切片不包括终点
  y = data.iloc[:,lists-1:lists]#最后一列
  #y = data.iloc[:,-1]#也是最后一列
  print(X.head())
  """
     Ones  Population
  0     1      6.1101
  1     1      5.5277
  2     1      8.5186
  3     1      7.0032
  4     1      5.8598
  """
  print(y.head())
  """
      Profit
  0  17.5920
  1   9.1302
  2  13.6620
  3  11.8540
  4   6.8233
  """
  

• 我们还要将θ初始化为0，并将θ、X、y全部转化为矩阵

  np.matrix函数：使用np.matrix函数，我们直接传入一个二维数组，我们就能够成功创建一个矩阵。

  X = np.matrix(X.values)
  y = np.matrix(y.values)
  theta = np.matrix(np.array([0,0]))
  print(X.shape)#(97, 2)
  print(y.shape)#(97, 1)
  print(theta.shape)#(1, 2)
  

2.23 计算J(θ)

• 计算代价函数来检测代价函数的收敛性。根据上面的公式我们写出代价函数。

  def computeCost(X, y, theta):
      inner = np.power((X * theta.T)-y,2)#数组元素求n次方
      return np.sum(inner) / (2 * len(X))
  print(computeCost(X, y, theta)) #32.072733877455676
  

2.24 梯度下降

代价函数J(θ)的参数是由向量θ表示，假设你已经实现了梯度下降，如果计算正确，J(θ)的值不应该增加，而应该减小然后在算法结束时收敛到一个稳定值。

def gradientDescent(X, y, theta, alpha, iters):
    temp = np.matrix(np.zeros(theta.shape))#创建0矩阵[[0. 0.]]
    parameters = int(theta.ravel().shape[1]) #ravel()将多维数组转换为一维数组,.shape[1]是看列数为多少-2
    cost = np.zeros(iters)#初始化代价函数数组

    for i in range(iters):
        error = (X * theta.T) - y

        for j in range(parameters):
            term = np.multiply(error, X[:, j])
            temp[0, j] = theta[0, j] - ((alpha / len(X)) * np.sum(term))#更新参数

        theta = temp
        cost[i] = computeCost(X, y, theta)

    return theta, cost

alpha = 0.01#设置学习率
iters = 1500#设置迭代次数
g, cost = gradientDescent(X, y, theta, alpha, iters)
print(g)#[[-3.63029144  1.16636235]]
predict1 = [1,3.5]*g.T
print(predict1)#[[0.45197679]]
predict2 = [1,7]*g.T
print(predict2)#[[4.53424501]]

2.3 调试

• python可视化：原始数据以及拟合的直线

  # 在指定的间隔内返回均匀间隔的数字：从data.Population的最小值到最大的范围内，等间距的返回100个样本
  x = np.linspace(data.Population.min(), data.Population.max(), 100)
  f = g[0, 0] + (g[0, 1] * x)#参数为最优值的直线
  fig, ax = plt.subplots(figsize=(12,8))#创建一个12*8的图即多维窗口
  ax.plot(x, f, 'r', label='Prediction') #定义x, y, 颜色，图例上显示的东西
  ax.scatter(data.Population, data.Profit, label='Traning Data')
  ax.legend(loc=2)#指定图例的位置
  ax.set_xlabel('Population')
  ax.set_ylabel('Profit')
  ax.set_title('Predicted Profit vs. Population Size')
  plt.show()
  

03 多变量线性回归

根据ex1data2.txt里的数据建立模型，预测房屋的价格，其中第一列是房屋大小，第二列是卧室数量，第三列是房屋售价

• 第一步依旧是读入数据：

path = 'machine-learning-ex1\machine-learning-ex1\ex1\ex1data2.txt'
data2 = pd.read_csv(path,header = None,names=['Size', 'Bedrooms', 'Price'])
print(data2.head())
'''
 Size  Bedrooms   Price
0  2104         3  399900
1  1600         3  329900
2  2400         3  369000
3  1416         2  232000
4  3000         4  539900
'''

3.1 特征归一化

特征缩放的目的只是为了运行更快。使特征值比较接近，使图像变得比较圆。以至于梯度下降的速度更快，收敛所需要的迭代次数更少，收敛更快。

• mean()函数功能：求取均值，std()函数是用来求标准差的(std = sqrt(mean(abs(x - x.mean())**2)))。

  data2 = (data2 - data2.mean()) / data2.std()
  print(data2.head())
  '''
        Size  Bedrooms     Price
  0  0.130010 -0.223675  0.475747
  1 -0.504190 -0.223675 -0.084074
  2  0.502476 -0.223675  0.228626
  3 -0.735723 -1.537767 -0.867025
  4  1.257476  1.090417  1.595389
  '''
  

3.2 梯度下降

data2.insert(0, 'Ones', 1)

cols = data2.shape[1]
X2 = data2.iloc[:,0:cols-1]
y2 = data2.iloc[:,cols-1:cols]

X2 = np.matrix(X2.values)
y2 = np.matrix(y2.values)
theta2 = np.matrix(np.array([0,0,0]))

g2, cost2 = gradientDescent(X2, y2, theta2, alpha, iters)
print(g2)
'''
[[-1.10898288e-16  8.84042349e-01 -5.24551809e-02]]
'''

3.3 正规方程

训练集特征矩阵为 X（包含了x_0=1）训练集结果为向量 y，则利用正规方程解出向量：其中np.linalg.inv()：矩阵求逆。
$$\theta =(X^{T}X{)}^{-1}{X}^{T}y$$

def normalEqn(X, y):
    theta = ((np.linalg.inv(X.T.dot(X))).dot(X.T)).dot(y)
    # theta = np.linalg.inv(X.T@X)@X.T@y
    return theta
theta2=normalEqn(X2, y2)
print(theta2)
'''
[[-7.11223170e-17]
 [ 8.84765988e-01]
 [-5.31788197e-02]]
 '''

04 代码总结

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
path = "machine-learning-ex1\machine-learning-ex1\ex1\ex1data1.txt"
data = pd.read_csv(path,header=None,names=['Population','Profit'])#header决定要不要原始的表头，name给出自定义的表头。

#data.plot(kind='scatter', x='Population', y='Profit', figsize=(12,8))#生成图形，kind‘指定所画图的类型，figsize 指定图片大小。
# plt.show()#显示图形
#==============================================================================
data.insert(0, 'Ones', 1) #相当于在第0列，添加一个表头名为Ones，并且该列均为1

# 分割X和y
lists = data.shape[1]#输出列数
X = data.iloc[:,:-1]#X是第一列到最后一列，但不包括最后一列，因为 python的范围/切片不包括终点
y = data.iloc[:,lists-1:lists]#最后一列
#y = data.iloc[:,-1]#也是最后一列

X = np.matrix(X.values)
y = np.matrix(y.values)
theta = np.matrix(np.array([0,0]))

def computeCost(X, y, theta):
    inner = np.power((X * theta.T)-y,2)#数组元素求n次方
    return np.sum(inner) / (2 * len(X))
# print(computeCost(X, y, theta)) #32.072733877455676
#梯度下降算法如下：
def gradientDescent(X, y, theta, alpha, iters):
    temp = np.matrix(np.zeros(theta.shape))#创建0矩阵[[0. 0.]]
    parameters = int(theta.ravel().shape[1]) #ravel()将多维数组转换为一维数组,.shape[1]是看列数为多少
    cost = np.zeros(iters)

    for i in range(iters):
        error = (X * theta.T) - y

        for j in range(parameters):
            term = np.multiply(error, X[:, j])
            temp[0, j] = theta[0, j] - ((alpha / len(X)) * np.sum(term))

        theta = temp
        cost[i] = computeCost(X, y, theta)

    return theta, cost

alpha = 0.01
iters = 1500
g, cost = gradientDescent(X, y, theta, alpha, iters)
#print(g)#[[-3.63029144  1.16636235]]
predict1 = [1,3.5]*g.T
#print(predict1)#[[0.45197679]]
predict2 = [1,7]*g.T
#print(predict2)#[[4.53424501]]

# 在指定的间隔内返回均匀间隔的数字：从data.Population的最小值到最大的范围内，等间距的返回100个样本
x = np.linspace(data.Population.min(), data.Population.max(), 100)
f = g[0, 0] + (g[0, 1] * x)#参数为最优值的直线
fig, ax = plt.subplots(figsize=(12,8))#创建一个12*8的图即多维窗口
ax.plot(x, f, 'r', label='Prediction') #定义x, y, 颜色，图例上显示的东西
ax.scatter(data.Population, data.Profit, label='Traning Data')
ax.legend(loc=2)#指定图例的位置
ax.set_xlabel('Population')
ax.set_ylabel('Profit')
ax.set_title('Predicted Profit vs. Population Size')
#plt.show()
#===========================================================================
path = 'machine-learning-ex1\machine-learning-ex1\ex1\ex1data2.txt'
data2 = pd.read_csv(path,header = None,names=['Size', 'Bedrooms', 'Price'])
data2 = (data2 - data2.mean()) / data2.std()

data2.insert(0, 'Ones', 1)
cols = data2.shape[1]
X2 = data2.iloc[:,0:cols-1]
y2 = data2.iloc[:,cols-1:cols]

X2 = np.matrix(X2.values)
y2 = np.matrix(y2.values)
theta2 = np.matrix(np.array([0,0,0]))

g2, cost2 = gradientDescent(X2, y2, theta2, alpha, iters)
print(g2)

def normalEqn(X, y):
    theta = ((np.linalg.inv(X.T.dot(X))).dot(X.T)).dot(y)
    # theta = np.linalg.inv(X.T@X)@X.T@y
    return theta
theta2=normalEqn(X2, y2)
print(theta2)

章节07 Logistic回归(sigmoid)

分类

要预测变量y是一个离散值情况下的分类问题，logistic回归算法是最广泛使用的学习算法之一

举例垃圾邮件分类问题，分类网上交易（某一个交易是否存在欺诈），对肿瘤进行分类（良性肿瘤还是恶性肿瘤）
$$\begin{gathered} 二元分类问题，y\in \left\{\begin{array}{c}0，1\end{array}\right\} \\ 0:负类（良性肿瘤） \\ 1:正类（恶性肿瘤）可以任意，没有明确规定 \end{gathered}$$

将分类器输出阈值设为0.5，即纵坐标值为0.5：
$$\begin{gathered} 如果假设输出一个h_{\theta }(x)\ge 0.5，可以预测为y=1 \\ 如果假设输出一个h_{\theta }(x)\le 0.5，可以预测为y=0 \end{gathered}$$

通常对数据集进行线性回归有时候效果会好，但不一定是一个好的方法，比如此处不建议将线性回归用于分类问题。

PS：对分类问题使用线性回归，会发生什么？
$$\begin{gathered} 对于分类：y=0或1 \\ 使用线性回归输出值h_{\theta }(x)可能＞1或＜0 \\ 用logistic回归的算法，其特点在于算法的输出或者预测值：0\le h_{\theta }(x)\le 1这个范围内。 \\ 这里我们把logistic回归算法视为一种分类算法，用在标签y为离散值0或1的情况下。 \end{gathered}$$

假设陈述

当有一个分类问题的时候，我们要使用哪个方程，来表示我们的假设。
$$\begin{gathered} logistic回归模型希望0\le h_{\theta }(x)\le 1 \\ 使用线性回归h_{\theta }(x)={\theta }^{T}x这是假设形式 \\ sigmoid函数或logistic函数（sigmoid和logistic基本上是同义词）：g(z)=\frac{1}{1+e^{-z}} \\ 那么h_{\theta }(x)=\frac{1}{1+e^{-{\theta }^{T}x}} \end{gathered}$$

$$\begin{gathered} 假设h_{\theta }(x)的输出=输出某个数字，把这个数字当做对一个输入x，y=1的概率估计 \\ 肿瘤分类例子：有一特征向量x=\left[\begin{array}{c}{x}_0\\ x_1\end{array}\right]=\left[\begin{array}{c}1\\ tumorSize\end{array}\right] \\ {h}_{\theta }(x)=0.7 \\ 对于一个特征为x的患者，y=1的概率是0.7 \\ 换句话说：要告诉病人这个肿瘤0.7的可能性是恶性肿瘤 \\ {h}_{\theta }(x)=P(y=1|x;\theta ),在给定x的条件下y=1的概率，即病人的特征为x的情况下（x代表肿瘤的大小，概率的参数是\theta ）依赖假设来估计y=1的概率。 \end{gathered}$$

这是一个分类问题，我们知道y必须是0或1，这是y可以取得的仅有的两个值。
$$\begin{gathered} P(y=0|x;\theta )+P(y=1|x;\theta )=1 \\ P(y=0|x;\theta )=1-P(y=1|x;\theta ) \end{gathered}$$

决策界限

$$\begin{gathered} 如果要决定预测y=1还是y=0，取决于估值概率是大于等于0.5还是小于0.5 \\ 其实就等于说我们将预测y=1只需要{\theta }^{T}x\ge 0，另一方面我们将预测y=0只需要{\theta }^{T}x＜0 \end{gathered}$$

决策边界是假设函数的一个属性，即使我们去掉数据集，这条决策边界以及我们预测y=0和y=1的区域，他们都是假设函数的属性，决定于其参数，它不是数据集的属性。参数确定则决策边界确定，此时就不需要再通过绘制训练集来确定决策边界。

在logistic回归中可以在特征中添加额外的高阶多项式项，来确定决策边界。通过在特征中增加一些复杂的多项式，可以得到更复杂的决策边界，而不是只用直线分开正负样本。PS：决策边界不是训练集的属性，而是假设本身及其参数的属性，只要给定了参数向量θ，其决策边界就确定了。不是用训练集来定义的决策边界，是用训练集来拟合参数θ。

代价函数

如何拟合logistic回归模型的参数θ，定义用来拟合参数的优化目标或者叫代价函数。

对于这个给定的训练集，如何选择θ？

代价函数
$$\begin{gathered} 线性回归：J(\theta )=\frac{1}{m}\sum _{i=1}^m\frac{1}{2}{(h_{\theta }(x^{(i)})-y^{(i)})}^2 \\ Cost(h_{\theta }(x^{(i)}),y^{(i)})=\frac{1}{2}{(h_{\theta }(x^{(i)})-y^{(i)})}^2 \end{gathered}$$

在此处因为logistic(sigmoid)函数为非连续函数，导致无法使用梯度下降算法，强行使用会导致θ取得局部最优解而不一定是全局最优解。

下面为logistic函数的损失函数：

$$\begin{gathered} 如果y=1而且h_{\theta }(x)=1，也就是说如果假设函数预测值是1，而且y刚好等于预测的，那么此时这个代价值Cost=0，这也是所希望的，正确预测了输出值y。 \\ 但同样的，当h_{\theta }(x)\to 0 \\ Cost\to \infty \\ 如果假设函数输出0，h_{\theta }(x)=0（P(y=1|x;\theta )=0），相当于假设函数指y=1的概率为0； \\ 如果结果为1，y=1，就用非常大的代价值惩罚这个学习算法（即如果y=1而h_{\theta }(x)=0，预测失败） \end{gathered}$$

简化代价函数与梯度下降

找出一种稍微简单一点的方法来写出代价函数来替换现有的方法，同时运用梯度下降法来拟合logistic回归的参数。

logistic回归的代价函数：
$$\begin{gathered} J(\theta )=\frac{1}{m}\sum _{i=1}^{m}Cost(h_{\theta }(x^{(i)}),y^{(i)}) \\ Cost(h_{\theta }(x),y)=\{\begin{array}{l}-log(h_{\theta }(x)),y=1\\ -log(1-h_{\theta }(x)),y=0\end{array} \\ 注意：y=0或y=1（一直） \\ 可以将上述Cost函数进行合并：Cost(h_{\theta }(x),y)=-ylog(h_{\theta }(x))-(1-y)log(1-h_{\theta }(x)) \\ logistic回归的代价函数：J(\theta )=\frac{1}{m}\sum _{i=1}^{m}Cost(h_{\theta }(x^{(i)}),y^{(i)}) \\ =-\frac{1}{m}[\sum _{i=1}^m{y}^{(i)}log{h}_{\theta }(x^{(i)})+(1-y^{(i)})log(1-h_{\theta }(x^{(i)}))] \end{gathered}$$
根据这个代价函数为了拟合出参数，要做的是找出让J(θ)取得最小值的参数θ
$$\begin{gathered} 为了拟合参数\theta ：minJ(\theta ) \\ 在给定x的情况下做出预测：输出h_{\theta }(x)=\frac{1}{1+e^{-{\theta }^{T}x}} \end{gathered}$$
最小化代价函数的方法是使用梯度下降法：
$$\begin{gathered} 梯度下降法：J(\theta )=-\frac{1}{m}[\sum _{i=1}^m{y}^{(i)}log{h}_{\theta }(x^{(i)})+(1-y^{(i)})log(1-h_{\theta }(x^{(i)}))] \\ 要最小化这个关于\theta 的函数J(\theta ): \\ 重复:{\theta }_j:={\theta }_j-\alpha \frac{\partial }{\partial {\theta }_j}J(\theta )={\theta }_j-\alpha \sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})\ast x_j^{(i)} \\ （同时更新所有{\theta }_j） \end{gathered}$$

算法看起来与线性回归相同！但实际上是不同的。
$$\begin{gathered} 在线性回归中：h_{\theta }(x)={\theta }^{T}x \\ 在logistic回归中：h_{\theta }(x)=\frac{1}{1+e^{-{\theta }^{T}x}} \end{gathered}$$
特征缩放的方法也适用于logistic回归中，如果特征范围差距很大的话，那么应用特征缩放的方法可以让梯度下降收敛更快。

高级优化

高级优化方法与梯度下降相比能大大提高logistic回归的运行的速度。

损失函数J(θ)，我们想要使它最小化，需要做的是编写代码，当输入参数θ时
$$\begin{gathered} 会计算出J(\theta ) \\ \frac{\partial }{\partial {\theta }_j}J(\theta )（forj=0,\mathrm{1...},n） \\ 梯度下降：重复：{\theta }_j:={\theta }_j-\alpha \frac{\partial }{\partial {\theta }_j}J(\theta ) \\ 对于梯度下降来说，从技术上讲，并不需要编写代码来计算代价函数J(\theta )，只需要编写代码来计算导数项， \\ 但是如果希望代码还要能够监控这些J(\theta )的收敛性，需要自己编写代码来计算代价函数和偏导数项。 \\ 在编码出J(\theta ) \\ 和\frac{\partial }{\partial {\theta }_j}J(\theta )（forj=0,\mathrm{1...},n）的代码后，就可以使用梯度下降或其他算法(共轭梯度法、BFGS、L-BFGS) \\ (共轭梯度法、BFGS、L-BFGS)算法优点：不需要选择手动学习率\alpha ；往往比梯度下降收敛得快。 \\ 缺点：这三个算法比梯度下降法复杂多了 \end{gathered}$$

使用以上三种算法的例子：
$$\begin{gathered} \theta =\left[\begin{array}{c}{\theta }_1\\ {\theta }_2\end{array}\right]想要求得最小的J(\theta ) \\ J(\theta )=({\theta }_1-5{)}^2+({\theta }_2-5{)}^2那么{\theta }_1=5，{\theta }_2=5 \\ \frac{\partial }{\partial {\theta }_1}J(\theta )=2({\theta }_1-5) \\ \frac{\partial }{\partial {\theta }_2}J(\theta )=2({\theta }_2-5) \\ 调用相关库直接进行运算即可。 \end{gathered}$$
对于这些高级优化算法，所使用的是一个复杂的优化库，它让算法使用起来更模糊一点，因此会稍微有点难调试，不过由于这些算法的运行速度通常远远超过梯度下降，因此当有一个很大的机器学习问题时，可以选择这些高级算法而不是梯度下降。

多元分类：—对多

多类别分类问题：需要一个学习算法自动地将邮件归类到不同的文件夹里或者说可以自动地加上标签

例：将邮件分为工作、朋友、家人、爱好，这就是一个包含四个分类的问题

例：有关医学诊断的，分类为没有生病，着凉了，流感

例：利用机器学习来处理天气的分类问题，包括：晴天、多云、雨天、雪天

对以上所有的例子，y可以取一些离散值

$$\begin{gathered} 一VS所有 \\ 对于每一个分类i都训练一个logistic回归分类器h_{\theta }^{(i)}(x)来预测y=i的概率。 \\ 在一个新的输入x中，要做出预测，选择最大限度的i类：max{h}_{\theta }^{(i)}(x) \end{gathered}$$

章节08 正则化

正则化可以改善或减少过度拟合问题，以使学习算法更好地起作用。

过拟合问题

线性回归例子

logistic回归例子

欠拟合：算法没有很好地拟合训练集，另一种说法是算法具有高偏差

过度拟合：通过了所有的数据点，很好地拟合了训练集，但这是一条扭曲的曲线，不停地上下波动。过度拟合另一种说法是这个算法具有高方差。

过度拟合问题将会在变量过多的时候出现，这时训练出的假设能很好地拟合训练集，所以代价函数实际上可能非常接近于0，但是可能会得到过拟合的数据导致无法泛化到新样本。泛化：一个假设模型应用到新样本的能力。新样本数据指的是没有出现在训练集的房子。

解决过拟合的方法：

1.尽量减少选取变量的数量。可以人工检查变量清单并以此决定哪些变量更为重要，哪些特征变量应该保留，那些应该舍弃；模型选择算法，这种算法可以自动选择哪些特征变量保留，哪些舍弃。这种减少特征变量的方法可以有效减少过拟合的发生。其缺点在于舍弃一部分特征变量，就舍弃了关于问题的一些信息。

2.正则化。将保留所有的特征变量，但是减少量级或参数θ_j的大小。

代价函数

$$\begin{gathered} 不妨在函数中加入惩罚项使得{\theta }_3和{\theta }_4都非常小，意味着优化目标，要最小化其均方误差代价函数，对函数进行一些修改，给它加上1000\times {\theta }_3^2+1000\times {\theta }_4^2， \\ 1000只是随便一个比较大的数，假如要最小化这个函数，要使得修改后的函数尽可能小的方法只有一个那就是{\theta }_3和{\theta }_4要尽可能小。 \\ 当最小化这个新函数，需要{\theta }_3使尽量接近于0，还要使{\theta }_4也尽量接近于0，就像直接去掉两项一样。 \end{gathered}$$
正则化：
$$\begin{gathered} 如果参数值较小，参数值较小意味着一个更简单的假设模型，在上面的例子中对{\theta }_3和{\theta }_4加入了惩罚项，当它们都接近于0时，会得到一个更简单的假设模型，就相当于一个二次函数。 \\ 大体上来说如果将这些参数都加上惩罚项，这么做就相当于尽量去简化这个假设模型，结果表明，参数越小所得到的函数就会越平滑也越简单，因此也更不容易出现过拟合的问题。 \\ 正则化的优化目标即正则化代价函数：J(\theta )=\frac{1}{2m}\left[\begin{array}{c}{\sum }_{i=1}^m{(h_{\theta }(x^{(i)})-y^{(i)})}^2+\lambda {\sum }_{j=1}^n{\theta }_j^2\end{array}\right] \\ 等号右边的\lambda \sum _{j=1}^n{\theta }_j^2是正则化项，其中的\lambda 被称为正则化参数，\lambda 的作用是控制两个不同目标之间的取舍/平衡关系，即更好地去拟合训练集的目标和将参数控制的更小的目标。 \\ 从而保持假设模型的相对简单，避免出现过拟合的情况。 \end{gathered}$$
在正则线性回归中，我们选择θ来最小化
$$J(\theta )=\frac{1}{2m}\left[\begin{array}{c}{\sum }_{i=1}^m{(h_{\theta }(x^{(i)})-y^{(i)})}^2+\lambda {\sum }_{j=1}^n{\theta }_j^2\end{array}\right]$$

如果λ被设置为一个非常大的值(对于我们的问题来说可能太大了，比如λ=10^10)呢？

其结果就是对这些参数都会接近于0，这样的话相当于把假设函数的全部项都忽略掉了，就成为一个欠拟合的例子。

为了让正则化起到一个很好的效果，去选择一个更合适的正则化参数λ。

线性回归的则很难规则化

正则化线性回归的优化目标
$$\begin{gathered} J(\theta )=\frac{1}{2m}\left[\begin{array}{c}{\sum }_{i=1}^m{(h_{\theta }(x^{(i)})-y^{(i)})}^2+\lambda {\sum }_{j=1}^n{\theta }_j^2\end{array}\right] \\ \sum _{i=1}^m{(h_{\theta }(x^{(i)})-y^{(i)})}^2是线性回归的一般目标 \\ \lambda \sum _{j=1}^n{\theta }_j^2正则化项，\lambda 为正则化参数 \\ 想找一个\theta 来最小化代价函数，也就是最小化这个正则化代价函数J(\theta ) \end{gathered}$$

$$\begin{gathered} 重复【 \\ {\theta }_0:={\theta }_0-\alpha \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})x_0^{(i)} \\ {\theta }_j:={\theta }_j-\alpha \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}+\frac{\lambda }{m}{\theta }_j】 \\ （同时更新{\theta }_j的j=\mathrm{0..}，n） \\ {\theta }_j:={\theta }_j(1-\alpha \frac{\lambda }{m})-\alpha \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)} \end{gathered}$$
梯度下降是拟合线性回归模型时所讲的两种算法中的一个，另一种方法则是用正规方程来解决

正规方程
$$\begin{gathered} X=\left[\begin{array}{c}(x^{(1)}{)}^T\\ ...\\ (x^{(m)}{)}^T\end{array}\right]，每一行都代表一个单独的训练样本，m\ast (n+1)维的矩阵 \\ y=\left[\begin{array}{c}{y}^{(1)}\\ ...\\ y^{(m)}\end{array}\right]，m维的向量，它包含了训练集里的所有标签 \\ 为了最小化代价函数J(\theta )，一个办法是让\theta 等于这个式子\theta =(X^{T}X+\lambda \left[\begin{array}{ccccc}0& 0& ...& 0& 0\\ 0& 1& ...& 0& 0\\ ...& ...& ...& ...& ...\\ 0& 0& ...& 1& 0\\ 0& 0& ...& 0& 1\end{array}\right]{)}^{(-1)}{X}^{T}y \\ \left[\begin{array}{ccccc}0& 0& ...& 0& 0\\ 0& 1& ...& 0& 0\\ ...& ...& ...& ...& ...\\ 0& 0& ...& 1& 0\\ 0& 0& ...& 0& 1\end{array}\right]，一般情况下这是个(n+1)\times (n+1)维矩阵 \end{gathered}$$
如果样本数量比特征数量少那么X转置乘X的矩阵是不可逆的

编程作业：Logistic回归

暂略

Logistic回归的正则化

所加的那项的作用是惩罚参数θ_1，θ_2直到θ_n防止他们过大，这样做所产生的效果是即使拟合阶数很高且参数很多，只要添加了这个正则化项，保持参数较小，那么仍然可以得到一条相对平滑的决策边界，这条边界更能合理地划分正样本和负样本。因此使用正则化，即使有很多特征，正则化都可以避免过拟合地现象出现。

如何实现？对于最初的梯度下降算法

更高级的优化算法中使用正则化

提醒：对于这些高级算法，要做的就是需要自己定义一个costFunction函数，这个函数以参数向量theta作为输入。

章节09 神经网络学习

非线性假设

假如有一个监督学习分类问题，训练集如下图所示。若利用logistic回归来解决这个问题，可以构造一个包含很多非线性项的logistic回归函数，图中的g仍然是sigmoid函数，其中可以包含很多多元高次的多项式。当多项式项数足够多时，那就可能得到完全分开正样本和负样本的假设。当只有两个特征比如x_1和x_2，拥有足够多的项数这个方法确实能得到不错的结果。但是在大部分问题中，特征往往不仅仅是两个。如果要包含所有的二次项，即使只要包含二次多项式，最终也有很多项。在n=100的情况下，最终也有5000个特征（n为原始特征个数）。但是如果只对每个特征进行平方，这样可以将二次项的数量大幅减少，减少到只有100个二次项，但是由于忽略了太多相关项，在处理类似下图数据的时候，不可能得到理想的结果。

举个例子：关于计算机视觉中的一个问题，假设想使用机器学习算法来训练一个分类器来检测图像，来判断图像是否为一辆汽车。人看图像，是什么一目了然。计算机实际上看到的却是一个数据矩阵或者说表示像素强度值的网格，告诉我们图像中每个像素的亮度值。因此计算机视觉问题根据这个像素点亮度矩阵来告诉我们这些数值代表一个汽车门把手。

用机器学习算法构造一个汽车识别器时，我们要做的是提供一个带标签的样本集，其中一些样本是各类汽车，另一部分样本不是车。将这个样本集输入给学习算法以训练出一个分类器。然后输入一个图片，让分类器判定这个是什么东西。理想情况下分类器能识别出这是一辆汽车。

为了理解引入非线性假设的必要性，从学习算法的训练样本中找出一些汽车图片和一些非汽车图片，从图片中选择一组像素点位，在坐标系中标出这幅汽车的位置，车的位置取决于像素点1和像素点2的强度，用同样的方法处理其他图片。在坐标轴上用+表示汽车图片，-表示非汽车图片。会发现汽车样本和非汽车样本分布在坐标系中的不同区域。现在需要一个非线性假设来尽量分开这两类样本。

因此，只是包括平方项或者立方项特征，简单的logistic回归算法并不是一个在n很大时学习复杂的非线性假设的好办法，因为特征过多。

神经元与大脑

神经网络算法最初产生的目的是制造能模拟大脑的机器。

神经网络的起源：人们想尝试设计出模仿大脑的算法，其理念是若我们想要建立学习系统，则模仿我们所认识的人类的大脑。

模型展示Ⅰ

神经网络模仿了大脑中的神经元或者神经网络。

神经元是大脑中的细胞，其中有两点值得注意：一是神经元有如下图这样的细胞体；二是神经元有很多输入通道叫做树突，可以把它们想象成输入电线，它们接收来自其他神经元的信息，且神经元有一条输出通道叫做轴突，这条输出通道是用来给其他神经元传递信号或者传送信息的。简而言之，神经元是一个计算单元，它从输入通道接受一定数目的信息并做一些计算，然后结果通过它的轴突传送到其他节点或者大脑中的其他神经元

一组神经元的示意图：

神经元之间利用微弱的电流进行沟通，也称作动作电位，本质就是一些微弱的电流。如果一个神经元想要传递信息，它就会通过它的轴突发送一段微弱电流给其他神经元，轴突连接到输入通道或者说连接到另一个神经元的树突，接下来这个神经元接收这条信息做一些计算然后可能把自己的信息通过轴突传递给其他神经元。

在一个神经网络里或者说在我们在电脑上实现的人工神经网络里，我们将使用一个很简单的模型来模拟神经元的工作，将神经元模拟成一个逻辑单元。

黄色圆圈类比于神经元细胞体，通过x1，x2，x3这些树突或者说是输入通道传递给它一些信息，然后神经元做一些计算，并通过它的输出通道h(x)，就算轴突输出计算结果。这是一个简单的模型来模拟来模拟神经元。

当绘制一个神经网络时，通常只绘制的输入节点x1，x2，x3，有必要的时候会增加一个额外的节点x0，x0有时也被称作偏置单元或者偏置神经元，但因为x0总是等于1，所以会画出它，有时也不用画出，这取决于具体的例子，加上x0是否表示起来更方便。有时会说上图这是一个带有sigmoid或者logistic激活函数的人工神经元，在神经网络术语中，激活函数指代非线性函数g(z)的另一个术语。到目前为止，一直称θ为模型的参数，但在关于神经网络的文献里，θ也被称之为模型的权重。权重和模型的参数是一样的东西。上图代表单个的神经元。

神经网络其实就是一组神经元连接在一起的集合，下图为一个三个神经元组成的神经网络示例。

神经网络中的第一层也被称为输入层，最后一层即图中示例的第三层称为输出层，中间的第二层被称作隐藏层。神经网络中的隐藏层不是只有一个，但在本例子中，只有一个隐藏层。只有一个输入层，一个输出层，其他层都称为隐藏层。

$$\begin{gathered} {\theta }^{(1)}控制着从三个输入单元到三个隐藏单元的映射的参数矩阵，因此{\theta }^{(1)}就是一个3\times 4的矩阵。 \\ 如果一个网络在第j层有s_j个单元，在j+1层有s_{j+1}个单元，那么矩阵{\theta }^{(j)}即控制第j层到j+1层映射的矩阵，它的维度为s_{j+1}\times (s_j+1)，s_{j+1}行，(s_j+1)列 \end{gathered}$$
神经网络定义函数h(x)从输入x到输出y的映射，这些假设被参数化，将参数记为大写的θ，这样一来改变θ就能得到不同的假设，有不同的函数比如从x到y的映射。

模型展示Ⅱ

前向传播：矢量化实现，将神经网络的计算向量化。

从输入单元的激活项开始，然后进行前向传播给隐藏层，计算隐藏层的激活项，然后继续前向传播，并计算输出层的激活项。这个依次计算激活项，从输出层到隐藏层再到输出层的过程叫前向

传播。上述内容为这一过程的向量化实现方法。

将左边部分遮住，剩下部分看起来很像是逻辑回归，即用第三层节点（逻辑回归单元）来预测h(x)的值

两个隐藏层的神经网络示例：

例子与直觉理解Ⅰ

神经网络可以用来学习复杂的非线性假设模型

学习一个非线性的判断边界，来区分正负样本。

需要计算目标函数y=x1 XOR x2或者y=x1 XOR x2（XNOR是NOT(x1 XOR x2)的另一种写法）

x1 XOR x2表示当这两个值恰好其中一个等于1时，这个式子为真。对于上图例子，当x1和x2同时为真或同时为假的时候，y=1；若y=0，则他们有且仅有一个为真。

为了建立能够拟合XNOR运算的神经网络，可以从一个简单的能够拟合AND运算的网络进行。

假设有2个二进制输入，只能取0或1，目标函数取y=x1 AND x2，AND的意思是逻辑与。路径线上蓝色所标注的数字为权重。在神经网络图中标出权重或者说参数会方便后续工作。

h(x)的输出结果为当且仅当x1和x2均为1时，输出结果才为1。

下图的神经网络可以实现或运算函数的功能

例子与直觉理解Ⅱ

神经网络实现逻辑非运算函数的功能

如果要计算(NOT x1)AND(NOT x2)，那么当x1=x2=0的时候会有(NOT x1)AND(NOT x2)=1

把x1 AND x2和(NOT x1)AND(NOT x2)和x1 OR x2这三部分结合起来，来计算x1 XNOR x2

这种复杂的函数当网络拥有许多层，在第二层中有一些关于输入的相对简单的函数，第三层又在此基础上计算更加复杂的方程，再往后一层计算的函数越来越复杂

多元分类

要在神经网络中实现多类别分类，采用的方法本质上是一对多的拓展

假设有个计算机视觉的例子：需要识别四个类别的对象，通过图像来辨别出行人，汽车，摩托车，货车。

需要建立一个有四个输出单元的神经网络

章节10 神经网络参数的反向传播算法

代价函数

神经网络在分类问题中的应用

L=神经网络总层数；S_l=在l层有几个不包括偏置项的神经元

第一种是二分类，在这种情况下只会有一个输出单元，h(x)∈实数

为了简化记忆，把K设为1，这样也可以把K当作输出层的单元数目

第二种是多类别分类问题，有K个不同的类，即有K个输出单元，h(x)∈K维向量，同时输出单元S_l=k，通常情况这类问题K≥3

代价函数

逻辑回归代价函数：

神经网络：

反向传播算法

梯度计算

这里实现了把前向传播向量化，使得可以计算神经网络结构里的每一个神经元的激活值。

接下来，为了计算导数项，将采用一种反向传播的算法。

代表了第l层的第j个结点的误差

误差=这个单元激活值-训练样本里的真实值 （即：误差=假设的输出值和训练集y值之间的差）

假设有m个样本的训练集，要做的第一件事情就是固定这些带下标ij的Δ=0

没有δ(1)，因为不需要对输入层考虑误差项

理解反向传播

前向传播是从左往右进行运算

反向传播算法

代价函数：（只有一个输出单元的代价函数）

这个代价函数一般应用于只有一个输出单元的情况，如果有不止一个输出单元，只需用k作为输出单元的下标，然后对它们进行求和即可。

关注一下只有一个输出单元的情况，此时y(i)就是一个实数。

忽略正则化（即λ=0）

得出第i个样本的代价函数：

这个代价函数扮演了一个类似方差的角色，可以近似地把cost(i)当成是神经网络输出值与实际值的方差。

因此cost(i)表示了神经网络预测样本值的准确程度，也就是网络的输出值和实际观测值y(i)的接近程度。

反向传播的过程：反向传播算法就是在计算项，可以把它看作是在第l层中第j个单元中得到的激活项的“误差”。

δ项实际上是代价函数cost(i)关于z^(l)_j的偏导数，计算出的z项的加权和或者说代价函数关于z项的偏导数。

具体来说这个代价函数是关于标签y和神经网络中h(x)的输出值的函数。

使用注意：展开参数

高级优化：

执行了代价函数，输入参数是theta，函数返回代价值以及导数值。然后可以将返回值传递给高级优化算法fminunc（fminunc并不是唯一的算法，也可以使用别的优化算法，但他们的功能都是取出这些输入值@costFunction以及theta值的一些初始值），并且这些程序都假定theta和这些theta初始值都是参数向量，也许是n或者n+1维，同时假定这个代价函数的第二个返回值（梯度值）也是n或者n+1维。

但是在用神经网络时，我们的参数不是向量而是矩阵，因此对于一个完整的神经网络，参数矩阵为θ(1)，θ(2)，θ(3)，类似地梯度值为D(i)

此处的例子是运用octave进行将矩阵转换为向量的步骤。

梯度检测

梯度检测可以保证前向传播以及后向传播都会是百分之百的正确。避免了程序里出现的bug。

梯度的数值估计：

实现数值上的梯度检验步骤：

1.通过反向传播来计算DVec。

2.实现数值上的梯度检验，计算出gradApprox。

3.确保DVec与gradApprox都能得出相似的值，确保它们只有几位小数的差距。

4.在使用代码进行学习或者训练网络之前，重要的是要关掉梯度检验。

PS：在运行算法之前，比如多次迭代的梯度下降或是多次迭代来训练分类器的高级优化算法先禁用梯度检验代码。如果在每次梯度下降迭代或者在每次代价函数的内循环里都运行一次梯度检验，程序就会变得非常慢，因为梯度检验算法比反向传播算法要慢很多。反向传播算法就是计算δ(i)这些值的方法，它比梯度检验要快上很多。所以一旦验证了反向传播的实现是正确的，就应当在训练之前关闭梯度检验或者禁用梯度检验代码，否则程序将会变得非常慢。

随机初始化

当执行一个算法，例如梯度下降法，或者更高级优化算法时，需要为变量θ选取一些初始值，对于高级优化算法，它默认为变量θ提供一些初始值，对于梯度下降法，同样需要对θ进行初始化，初始化完毕以后就可以一步一步通过梯度下降来最小化代价函数J(θ)，那如何对θ设初始值呢？

有一种方法是：将θ的初始值全部设为0，在逻辑回归中可以，但实际上在训练网络时，将所有参数初始化为0起不到任何作用。

举例：

所以每次之后，这两个隐藏单元的每个参数输入都是相等的，也就是说红色/绿色/蓝色的权重依然相等，意味着，即使梯度下降进行了一次迭代，但这两个隐藏单元依然以相同的函数作为输入来计算，因此a^(1)_2仍然等于a^(2)_2。假设有不止两个隐藏单元，而是有很多隐藏单元，那么这里所有隐藏单元都在计算相同的特征，所有的隐藏单元都以相同的函数作为输入，这是一种高度冗余的现象。这意味着最后的逻辑回归单元只能得到一个特征，因为所有的单元都一样。这种情况阻止了神经网络去学习任何有趣的东西。

为了解决这个问题，在神经网络中对参数进行初始化时，要使用随机初始化的思想。

具体来说，上述问题有时被称作是对称权重问题，也就是所有的权重都是一样的，所以随机初始化可以有效解决对称问题。

对每一个θ值将其初始化为一个范围在-ε到ε之间的随机值。随机初始化为一个接近0的范围在-ε到ε之间的随机值，然后进行反向传播再进行梯度检验，最后使用梯度下降或者其他高级优化算法来最小化代价函数J(θ)，这个关于参数θ的函数整个过程从为参数选取一个随机初始化的值开始这是一种打破对称性的流程。随后，通过梯度下降或者其他高级优化算法计算出θ的最优值。

组合到一起

在训练一个神经网络时，要做的第一件事是选择一种网络架构。架构指神经元之间的连接模式。

首先定义了输入单元的数量，一旦确定了特征集x，输入单元的数量就等于特征x(i)的维度，输入单元数目将会由此确定。如果进行多类别分类，那么输出层的单元数目将会由分类问题中所要区分的类别个数确定。对于隐藏层单元的个数以及隐藏层的数目，默认选项是使用单个隐藏层（通常情况下，隐藏单元越多越好，但同时越多的隐藏单元会导致计算量增大），如果使用不止一个隐藏层，同样也有默认选项，那就是每个隐藏层通常都有相同的单元数。

训练神经网络需要实现的步骤：

1.构建一个神经网络，然后随机初始化权重，通常把权重初始化为很小的值，接近于0。

2.执行前向传播算法，也就是对该神经网络的任意一个输入x(i)，计算出对应h(x(i))值，也就是一个输出值y的向量。

3.通过代码计算出代价函数J(θ)。

4.执行反向传播算法来计算出这些偏导数项，也就是J(θ)关于参数θ的偏导数。PS：使用反向传播，要对所有训练样本使用一个for循环进行遍历，至少在第一次进行计算时这样做，之后可以用一些高级算法进行。

5.使用梯度检查来比较已经计算得到的偏导数项，把用反向传播算法得到的偏导数值与数值方法得到的估计值进行比较。因此通过进行梯度检查来确保两种方法得到基本接近的两个值。通过梯度检查能确保反向传播算法得到的结果是正确的。然后停用梯度检查，因为梯度检查的计算非常慢。

6.使用一个最优化算法，比如梯度下降算法或者更加高级的优化方法比如LBFGS算法、共轭梯度法或者其他内置到fminunc函数中的方法，将这些优化方法与反向传播算法相结合，反向传播计算出这些偏导数项的值。知道了如何去计算代价函数，知道了如何使用反向传播算法来计算偏导数，就能使用某个优化方法来最小化关于θ的代价函数J(θ)。

神经网络，代价函数J(θ)是一个非凸函数，因此理论上可能停留在局部最小的位置。实际上梯度下降算法和其他一些高级优化方法理论上都可能收敛于局部最小值，尽管算法不能保证全局最优，但一般来讲在实际操作中这并不是大问题。

无人驾驶

一个无人驾驶的学习视频，略

章节11 应用机器学习的建议

章节12 机器学习系统设计

章节13 支持向量机

章节14 无监督学习

章节15 降维

章节16 异常检测

章节17 推荐系统

章节18 大规模机器学习

章节19 应用举例：照片OCR（光学字符识别）

章节20 总结与感谢

博主声明：
本文知识点与代码皆出吴恩达机器学习线上资源课程
欢迎有兴趣的同学进行视频学习
后面11-20章节没有再进行学习，如后期学习，会进行笔记补充
里面图片上传失败，需要pdf版本的可以私聊我
如有侵权，私信联系我