吴恩达机器学习系列课程笔记

视频资源获取：https://www.bilibili.com/video/BV164411b7dx?p=1

有监督学习：给算法包含正确答案的数据集，算法的任务就是根据数据集给出更多的正确答案。

回归问题（Regression）：预测一个连续的输出值，预测出连续值属性的类型。在回归问题中，我们试图在连续输出中预测结果，这意味着我们试图将输入变量映射到某个连续函数。
分类问题（Classification）：预测离散值输出0或1。在分类问题中，我们试图在离散输出中预测结果。换句话说，我们试图将输入变量映射到离散的类别中。

在有监督学习中，面对需要处理无限多特性的问题时，可以使用支持向量机算法

无监督学习：数据中没有任何标签或者所有的数据都具有相同的标签。无监督学习允许我们在几乎不知道或根本不知道结果应该是什么的情况下处理问题。我们可以从不一定知道变量影响的数据中得出结构。我们可以根据数据中变量之间的关系对数据进行聚类，从而得出这种结构。在无监督学习中，没有基于预测结果的反馈。

聚类算法（clustering algorithm）：将所有的数据经过算法分析过后，得到许多不同的簇，例如谷歌新闻。收集十万个不同的基因，并找到一种方法来自动将这些基因分组，这些基因在某种程度上是相似的，或者由不同的变量相关的，比如寿命、位置、角色等等。
鸡尾酒宴会算法（cocktail party algorithm）：处理鸡尾酒宴会问题。“鸡尾酒会算法”允许你在混乱的环境中找到结构。（即，在鸡尾酒会上从一系列声音中识别出个人的声音和音乐）。

[W,s,v] = svd((repmat(sum(x.*x,1),size(x,1),1).*x)*x');

模型建立过程：为了更正式地描述监督学习问题，我们的目标是，给定一个训练集，学习函数h:X→Y，因此h（x）对于Y的相应值是一个“好的”预测值。由于历史原因，这个函数h被称为一个假设。因此，从图像上看，过程如下：

当我们试图预测的目标变量是连续的时，比如在我们的住房示例中，我们称学习问题为回归问题。当y只能取一小部分离散值时（比如，如果给定居住面积，我们想预测一个住宅是房子还是公寓），我们称之为分类问题。

代价函数：该函数也称为平方误差函数、或是均方函数。为了便于计算梯度下降，将平均值减半，因为平方函数的导数项将抵消该项。

J ( θ 0 , θ 1 ) = 1 2 m ∑ i = 1 m ( y ^ i − y i ) 2 = 1 2 m ∑ i = 1 m ( h θ ( x i ) − y i ) 2 J(θ_0 ,θ_1)= \frac{1}{2m}\sum_{i=1}^{m}(\hat{y}_i-y_i)^2 =\frac{1}{2m}\sum_{i=1}^{m}(h_\theta(x_i)-y_i)^2 J(θ0,θ1)=2m1i=1∑m(y^i−yi)2=2m1i=1∑m(hθ(xi)−yi)2

在对一个数据集做一个一元回归线性分析时，所设计到的可能会有两个可控制变量，图为这两个变量发生变化时，代价函数的图形。左图是一个3-D曲面图，中图是数据集，右图是一个等高线图。

梯度下降：取成本函数的导数（函数的切线）。切线的斜率是这一点的导数，它会给我们一个前进的方向。我们沿着最陡下降的方向逐步降低成本函数。每个步骤的大小由参数α决定，该参数称为学习速率（learning rate）。

θ j : = θ j − α ∂ ∂ θ j J ( θ 0 , θ 1 ) ( f o r j = 0 a n d j = 1 ) f i n a l s t e p : θ j : = θ j − α ∗ 0 \theta_j:=\theta_j-\alpha\frac{\partial }{\partial \theta_j}J(\theta_0,\theta_1)\ \ \ \ \ \ \ \ \ \ \ \ (for\ j=0\ and\ j=1)\\final \ step:\theta_j:=\theta_j-\alpha*0 θj:=θj−α∂θj∂J(θ0,θ1) (for j=0 and j=1)final step:θj:=θj−α∗0

在使用梯度下降算法时需要注意的一点是对于梯度的计算必须是同时更新，不能渐次更新，同时更新的情况是普遍接受的梯度下降法，而渐次更新则是另一种方法，需要记住。

C o r r e c t : S i m u l t a n e o u s u p d a t e : t e m p 0 : = θ 0 − α ∂ ∂ θ 0 J ( θ 0 , θ 1 ) t e m p 1 : = θ 1 − α ∂ ∂ θ 1 J ( θ 0 , θ 1 ) θ 0 : = t e m p 0 θ 1 : = t e m p 1 \mathbf{Correct:Simultaneous\ update:}\\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 Correct:Simultaneous update:temp0:=θ0−α∂θ0∂J(θ0,θ1)temp1:=θ1−α∂θ1∂J(θ0,θ1)θ0:=temp0θ1:=temp1

I n c o r r e c t : t e m p 0 : = θ 0 − α ∂ ∂ θ 0 J ( θ 0 , θ 1 ) θ 0 : = t e m p 0 t e m p 1 : = θ 1 − α ∂ ∂ θ 1 J ( θ 0 , θ 1 ) θ 1 : = t e m p 1 \mathbf{Incorrect:}\\temp0:=\theta_0-\alpha\frac{\partial }{\partial \theta_0}J(\theta_0,\theta_1)\\\theta_0:=temp\ 0\\temp1:=\theta_1-\alpha\frac{\partial }{\partial \theta_1}J(\theta_0,\theta_1)\\\theta_1:=temp1 Incorrect:temp0:=θ0−α∂θ0∂J(θ0,θ1)θ0:=temp 0temp1:=θ1−α∂θ1∂J(θ0,θ1)θ1:=temp1

当特别应用于线性回归的情况时，可以导出一种新形式的梯度下降方程。我们可以替换实际成本函数和实际假设函数，并将方程修改为：

r e p e a t u n t i l c o n v e r g e n c e : { θ 0 : = θ 0 − α 1 m ∑ i = 1 m ( h θ ( x i ) − y i ) θ 1 : = θ 1 − α 1 m ∑ i = 1 m ( ( h θ ( x i ) − y i ) x i ) } repeat\ until\ convergence:\{\\ \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)x_i) \\\} repeat until convergence:{θ0:=θ0−αm1i=1∑m(hθ(xi)−yi)θ1:=θ1−αm1i=1∑m((hθ(xi)−yi)xi)}

其中m是训练集的大小，θ0和θ1是同时变化的常数，xi和yi是给定训练集的值。所有这些的要点是，如果我们从猜测我们的假设开始，然后反复应用这些梯度下降方程，我们的假设将变得越来越准确。这就是原始代价函数J上的梯度下降法。这种方法在每一步上看整个训练集中的每一个例子，叫做批量梯度下降法（batch gradient descent）。请注意，虽然梯度下降通常容易受到局部极小值的影响，但我们在这里提出的线性回归优化问题只有一个全局最优值，没有其他局部最优值；因此，梯度下降总是收敛到全局最小值（假设学习速率α不太大）。实际上，J是一个凸二次函数。这里是一个梯度下降的例子，因为它是为了最小化一个二次函数而运行的。

多元线性回归、多特征量：适应这些多重特征的假设函数的多变量形式如下： h θ ( x ) = θ 0 + θ 1 x 1 + θ 2 x 2 + θ 3 x 3 + ⋯ + θ n x n h_\theta(x)=\theta_0+\theta_1x_1+\theta_2x_2+\theta_3x_3+\cdots+\theta_nx_n hθ(x)=θ0+θ1x1+θ2x2+θ3x3+⋯+θnxn，使用矩阵乘法的定义，我们的多变量假设函数可以简洁地表示为：

h θ ( x ) = [ θ 0 a m p ; θ 1 a m p ; ⋯ a m p ; θ n ] [ x 0 x 1 ⋮ x n ] = θ T x h_\theta(x)=\begin{bmatrix} \theta_0&\theta_1&\cdots&\theta_n \end{bmatrix} \begin{bmatrix} x_0\\x_1\\\vdots\\x_n \end{bmatrix}=\theta^Tx hθ(x)=[θ0amp;θ1amp;⋯amp;θn]⎣⎢⎢⎢⎡x0x1⋮xn⎦⎥⎥⎥⎤=θTx

这是一个训练示例中假设函数的矢量化，公式中的 x 0 x_0 x0恒为1。

多元梯度下降：

r e p e a t u n t i l c o n v e r g e n c e { θ j : = θ j − α 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) ⋅ x j ( i ) f o r j : = 0 ⋯ n } repeat \ until\ convergence\{\\\theta_j:=\theta_j-\alpha\frac{1}{m}\sum^m_{i=1}(h_\theta(x^{(i)})-y^{(i)})\cdot x^{(i)}_j\qquad for\ j:=0\cdots n\\\} repeat until convergence{θj:=θj−αm1i=1∑m(hθ(x(i))−y(i))⋅xj(i)for j:=0⋯n}

或者是写成：

r e p e a t u n t i l c o n v e r g e n c e { θ 0 : = θ 0 − α 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) ⋅ x 0 ( i ) θ 1 : = θ 1 − α 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) ⋅ x 1 ( i ) θ 2 : = θ 2 − α 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) ⋅ x 2 ( i ) ⋯ } repeat \ until\ convergence\{\\\theta_0:=\theta_0-\alpha\frac{1}{m}\sum^m_{i=1}(h_\theta(x^{(i)})-y^{(i)})\cdot x^{(i)}_0\\ \theta_1:=\theta_1-\alpha\frac{1}{m}\sum^m_{i=1}(h_\theta(x^{(i)})-y^{(i)})\cdot x^{(i)}_1\\ \theta_2:=\theta_2-\alpha\frac{1}{m}\sum^m_{i=1}(h_\theta(x^{(i)})-y^{(i)})\cdot x^{(i)}_2\\ \cdots \} repeat until convergence{θ0:=θ0−αm1i=1∑m(hθ(x(i))−y(i))⋅x0(i)θ1:=θ1−αm1i=1∑m(hθ(x(i))−y(i))⋅x1(i)θ2:=θ2−αm1i=1∑m(hθ(x(i))−y(i))⋅x2(i)⋯}

特征缩放：我们可以通过让每个输入值在大致相同的范围内来加速梯度下降。这是因为θ在小范围内迅速下降，在大范围内缓慢下降，因此当变量非常不均匀时，θ将低效地振荡到最佳值。防止这种情况的方法是修改输入变量的范围，使它们大致相同。让每个特征的范围大致都保持在-1到1之间。有两种技术可以帮助实现这一点：特征缩放（feature scaling）和均值归一化（mean normalization）。特征缩放涉及将输入值除以输入变量的范围（即最大值减去最小值），从而得到一个新的范围，即1。平均标准化涉及从输入变量的值中减去输入变量的平均值，从而使输入变量的新平均值仅为零。

x i : = x i − μ i s i x_i:=\frac{x_i-\mu_i}{s_i} xi:=sixi−μi

其中 μ i \mu_i μi是特征i所有值的平均值， s i s_i si是所有值的范围或者是值的标准差。

学习率：已经经过证明，如果学习率 α \alpha α足够小，那么 J ( θ ) J(\theta) J(θ)将在每次迭代中减小。如果 α \alpha α太小，则收敛缓慢；如果 α \alpha α太大，可能不会在每次迭代中减少，因此可能不会收敛。

调试梯度下降：绘制一个包含迭代次数的图。该图中的 x x x轴是迭代次数， y y y轴是 J ( θ ) J(\theta) J(θ)的值，绘制这样的图可以明显的看出 J ( θ ) J(\theta) J(θ)的趋势。如果 J ( θ ) J(\theta) J(θ)增加，那么你可能需要减少 α \alpha α。
自动收敛测试：如果 J ( θ ) J(\theta) J(θ)在一次迭代中减少小于E，则声明收敛，其中E是一些小值，例如 1 0 − 3 10^{−3} 10−3。然而，在实践中，很难选择这个阈值。

多项式回归（Polynomial regression）：我们可以通过使其成为二次、三次或平方根函数（或任何其他形式）来改变假设函数的行为或曲线。

正规方程（normal equation）：我们将通过显式地取 J ( θ ) J(\theta) J(θ)相对于 θ \theta θ的导数，并将其设置为零，来最小化 J ( θ ) J(\theta) J(θ)。这使我们无需迭代就能找到最佳 θ θ θ。正规方程公式如下所示。并且对于正轨方程而言比不需要进行特征缩放。

θ = ( X T X ) − 1 X T y \theta=(X^TX)^{-1}X^Ty θ=(XTX)−1XTy

对于梯度下降和正规方程的比较：（在m个训练样本，n个特征的情况下）

梯度下降	正规方程
需要选取学习率	不需要选取学习率
需要进行多次迭代	不需要进行迭代
即使在n很大时，同样可以正常运行，复杂度是 o ( k n 2 ) o(kn^2) o(kn2)	需要计算 ( X T X ) − 1 (X^TX)^{-1} (XTX)−1，复杂度是 o ( n 3 ) o(n^3) o(n3)，当n很大时，计算量太大

pinv函数将为您提供 θ \theta θ的值，即使 X T X X^TX XTX不是可逆的。如果 X T X X^TX XTX是不可逆的，常见的原因可能是：

冗余特征，其中两个特征密切相关（即线性相关）
特征数太多（例如m≤ n）。在这种情况下，删除一些特征或使用“正则化”方法。

分类：为了尝试分类，一种方法是使用线性回归，将所有大于0.5的预测映射为1，将所有小于0.5的预测映射为0。然而，这种方法并不能很好地工作，因为分类实际上不是一个线性函数。分类问题和回归问题一样，只是我们现在想要预测的值只有少量离散值。现在，我们将关注二元分类问题，其中y只能有两个值0和1（我们在这里所说的大部分内容也将推广到多类情况）。我们可以忽略y是离散值这一事实来处理分类问题，并使用我们的旧线性回归算法来尝试预测给定x的y。然而，很容易构造出这种方法性能非常差的示例。比如说，当面对将y限制在0到1之间时，旧线性回归算法计算出某一个 h θ ( x ) h_\theta(x) hθ(x)的值大于1或小于0时，此时就失去了原本的意义。为了解决这个问题，引入Sigmoid函数或者叫Logistic函数

h θ ( x ) = g ( θ T x ) z = θ T x g ( z ) = 1 1 + e − z h_\theta(x)=g(\theta^Tx)\\z=\theta^Tx\\g(z)=\frac{1}{1+e^{-z}} hθ(x)=g(θTx)z=θTxg(z)=1+e−z1

根据上述公式计算出来的 h θ ( x ) h_\theta(x) hθ(x)将给出我们输出为1的概率，例如， h θ ( x ) = 0.7 h_\theta(x)=0.7 hθ(x)=0.7，表示最终输出为1的概率为70%，我们预测为0的概率只是预测为1的概率的补充，例如，如果预测为1的概率为70%，那么预测为0的概率为30%。

决策界限：决策界限是分隔y=0和y=1区域的线，是根据假设函数 ( θ ) (\theta) (θ)来创建的。同样Sigmoid函数的输入并不一定要求是线性的，可以是一个描述圆的函数或者任何符合我们数据的形状。为了得到离散的0或1分类，我们可以将假设函数的输出转换为：

KaTeX parse error: Expected 'EOF', got '&' at position 47: …=1\\h_\theta(x)&̲lt;0.5\rightarr…

根据Sigmoid函数的性质，当输入大于0时输出大于0.5。

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲& g(z) \geq…

所以我们对 g ( z ) g(z) g(z)的输入时 θ T X \theta^TX θTX，那就意味着：

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲& h_\theta(…

代价函数：我们不能使用与线性回归相同的成本函数，因为逻辑函数会导致输出波动，导致许多局部最优。换句话说，它不是凸函数。相反，我们的逻辑回归成本函数如下所示：

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲& J(\theta)…

如果我们的正确答案“y”为0，那么如果我们的假设函数也输出0，那么成本函数将为0。如果我们的假设接近1，那么成本函数将接近无穷大。如果我们的正确答案“y”是1，那么如果我们的假设函数输出1，那么成本函数将是0。如果我们的假设接近0，那么成本函数将接近无穷大。注意，以这种方式编写代价函数可以保证J（θ）对于逻辑回归是凸的。

简化代价函数： C o s t ( h θ ( x ) , y ) = − y ∗ l o g ( h θ ( x ) ) − ( 1 − y ) ∗ l o g ( 1 − h θ ( x ) ) Cost(h_\theta(x),y)=-y*log(h_\theta(x))-(1-y)*log(1-h_\theta(x)) Cost(hθ(x),y)=−y∗log(hθ(x))−(1−y)∗log(1−hθ(x))

Logistic回归代价函数：

J ( θ ) = 1 m ∑ i = 1 m C o s t ( h θ ( x ( i ) ) , y ( i ) ) = − 1 m ∑ i = 1 m [ y ( i ) l o g ( h θ ( x ( i ) ) ) + ( 1 − y ( i ) ) l o g ( 1 − h θ ( x ( i ) ) ) ] J(\theta) = \dfrac{1}{m} \sum_{i=1}^m \mathrm{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)}))] J(θ)=m1i=1∑mCost(hθ(x(i)),y(i))=−m1i=1∑m[y(i)log(hθ(x(i)))+(1−y(i))log(1−hθ(x(i)))]

Logistic梯度下降：

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲& \mathbf{G…

矢量化的实现方式为： θ : = θ − α m X T ( g ( X θ ) − y ⃗ ) \theta :=\theta-\frac{\alpha}{m}X^T(g(X\theta)-\vec{y}) θ:=θ−mαXT(g(Xθ)−y )

高级优化方法：共轭梯度法、BFGS、L-BFGS

多元分类–一对多(1vs all)(1vs rest)：现在，当我们有两个以上的类别时，我们将对数据进行分类。我们将扩展定义，而不是y={0,1}，这样y={0,1…n}。由于y={0,1…n}，我们将问题分为n+1（+1是因为索引从0开始）个二元分类问题；在每一个例子中，我们预测“y”是我们的一个类别的概率。我们基本上是选择一个类，然后将所有其他类合并到一个单独的第二类。我们反复这样做，对每个案例应用二元逻辑回归，然后使用返回最高值的假设作为我们的预测。总结一下：对多分类问题中每一个类别都训练一个回归器，然后在输入数据之后选取回归器返回值最大的那一类作为预测结果。

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲& y \in \lb…

过拟合：欠拟合或高偏差是指假设函数h的形式与数据的趋势不匹配。这通常是由于函数过于简单或使用的功能太少造成的。在另一个极端，过度拟合或高方差是由一个假设函数引起的，该假设函数拟合可用数据，但不能很好地概括预测新数据。这通常是由一个复杂的函数造成的，该函数创建了许多与数据无关的不必要的曲线和角度。这个术语既适用于线性回归，也适用于逻辑回归。解决过度装配问题有两个主要选择：

减少特征值的数量：手动选择要保留的特征或者是选择模型选择算法
正则化：保留所有特征，但减少参数的大小。当我们有很多稍微有用的特性时，正则化效果很好。

代价函数：如果我们的假设函数有过度拟合，我们可以通过增加它们的成本来减少函数中某些项的权重。假设我们想让下面的函数更二次： θ 0 + θ 1 x + θ 2 x 2 + θ 3 x 3 + θ 4 x 4 \theta_0+\theta_1x+\theta_2x^2+\theta_3x^3+\theta_4x^4 θ0+θ1x+θ2x2+θ3x3+θ4x4，想要消除 θ 3 \theta_3 θ3和 θ 4 \theta_4 θ4的影响，在不实际消除这些特征或改变假设形式的情况下，我们可以修改成本函数：

m i n θ 1 2 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) 2 + 1000 ⋅ θ 3 2 + 1000 ⋅ θ 4 2 min_\theta \frac{1}{2m} \sum_{i=1}^m(h_\theta (x^{(i)})-y^{(i)}) ^2+1000\cdot \theta_3^2+1000 \cdot \theta_4^2 minθ2m1i=1∑m(hθ(x(i))−y(i))2+1000⋅θ32+1000⋅θ42

我们在末尾增加了两个额外条款，以增加 θ 3 \theta_3 θ3和 θ 4 \theta_4 θ4的成本，现在为了使代价函数接近于0，我们必须减小 θ 3 \theta_3 θ3和 θ 4 \theta_4 θ4的值使其接近于0。这种方法反过来大大减小假设函数中 θ 3 \theta_3 θ3和 θ 4 \theta_4 θ4的值。因此在新的假设函数曲线中看起来更像一个二次函数，但是由于增加了额外的小项 θ 3 x 3 \theta_3x^3 θ3x3和 θ 4 x 4 \theta_4x^4 θ4x4也使其更能符合数据的特点。我们还可以在一次求和中正则化所有θ参数，如下所示：

m i n θ 1 2 m [ ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) 2 + λ ∑ i = 1 n θ j 2 ] min_\theta \frac{1}{2m} \left[ \sum_{i=1}^m(h_\theta (x^{(i)})-y^{(i)}) ^2+\lambda\sum_{i=1}^n\theta_j^2 \right] minθ2m1[i=1∑m(hθ(x(i))−y(i))2+λi=1∑nθj2]

线性回归的正则化：

梯度下降法：我们将修改梯度下降函数，以分离出 θ 0 \theta_0 θ0因为我们不想惩罚 θ 0 \theta_0 θ0。

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲ & \text{Re…

术语 λ m θ j \frac{\lambda}{m}\theta_j mλθj执行我们的正则化。通过一些操作，我们的更新规则也可以表示为：

θ j : = θ j ( 1 − α λ m ) − α 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) \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)} θj:=θj(1−αmλ)−αm1i=1∑m(hθ(x(i))−y(i))xj(i)

上述方程中的第一项， 1 − α λ m 1-\alpha\frac{\lambda}{m} 1−αmλ将始终小于1。直观地说，你可以把它看作是减少了 θ j \theta_j θj的值,每次更新时都会有一定数量的信息。请注意，第二个项现在与之前完全相同。
正规方程：现在让我们使用非迭代法方程的替代方法来处理正则化。要添加正则化，方程与原始方程相同，只是我们在括号内添加了另一项：

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲& \theta = …

L是一个矩阵，0在左上角，1在对角线下，0在其他地方。其尺寸应为（n+1）×（n+1）。直观地说，这是单位矩阵（尽管我们不包括 x 0 x_0 x0），乘以一个实数 λ \lambda λ。回想一下，如果m<n，那么 X T X X^TX XTX是不可逆的。然而，当我们加上 λ − L \lambda-L λ−L这一项，然后 X T X + λ ⋅ L X^TX+\lambda\cdot L XTX+λ⋅L变成了可逆的。

Logistic回归的正则化：在前文中出现过Logistic的代价函数为：

我们可以在末尾添加一个项来正则化这个方程：

J ( θ ) = − 1 m ∑ i = 1 m [ y ( i ) l o g ( h θ ( x ( i ) ) ) + ( 1 − y ( i ) ) l o g ( 1 − h θ ( x ( i ) ) ) ] + λ 2 m ∑ j = 1 n θ j 2 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)}))]+\frac{\lambda}{2m}\sum_{j=1}^n\theta_j^2 J(θ)=−m1i=1∑m[y(i)log(hθ(x(i)))+(1−y(i))log(1−hθ(x(i)))]+2mλj=1∑nθj2

关注代价函数中第二个和式的起始是从 j = 1 j=1 j=1开始的，对于一个 θ \theta θ向量而言其下标是从0到n共有n+1个向量在其中，但是在正则化的过程中，将 θ 0 \theta_0 θ0这个参数排除在外，不参与正则化的过程，因此在计算方程时，应不断更新以下两个方程：（和前面的线性回归相同）

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲ & \text{Re…

模型展示：让我们来看看如何使用神经网络来表示假设函数。在一个非常简单的层面上，神经元基本上是计算单元，将输入（树突）作为电输入（称为“尖峰”）传递到输出（轴突）。在我们的模型中，我们的树突类似于输入特征 x 1 ⋯ x n x_1\cdots x_n x1⋯xn，输出是我们假设函数的结果。在这个模型中，我们的 x 0 x_0 x0输入节点有时被称为“偏差单元”它总是等于1。在神经网络中，我们使用与分类中相同的逻辑函数 1 1 + e − θ T x \frac{1}{1 + e^{-\theta^Tx}} 1+e−θTx1，也有时称为Sigmoid激活函数。在这种情况下，我们的“θ”参数有时被称为“权重”。从视觉上看，一个简单化的表示看起来像：

[ x 0 x 1 x 2 ] → [ ] → h θ ( x ) \begin{bmatrix}x_0 \newline x_1 \newline x_2 \newline \end{bmatrix}\rightarrow\begin{bmatrix}\ \ \ \newline \end{bmatrix}\rightarrow h_\theta(x) [x0x1x2]→[ ]→hθ(x)

我们的输入节点（第1层），也称为“输入层”，进入另一个节点（第2层），最后输出假设函数，称为“输出层”。我们可以在输入层和输出层之间有中间的节点层，称为“隐藏层”在本例中，我们将这些中间或“隐藏”层节点标记为 a 0 2 ⋯ a n 2 a^2_0\cdots a ^2_n a02⋯an2并称之为“激活单元”。此时如果将隐藏层加入，则为：

[ x 0 x 1 x 2 x 3 ] → [ a 1 ( 2 ) a 2 ( 2 ) a 3 ( 2 ) ] → h θ ( x ) \begin{bmatrix}x_0 \newline x_1 \newline x_2 \newline x_3\end{bmatrix}\rightarrow\begin{bmatrix}a_1^{(2)} \newline a_2^{(2)} \newline a_3^{(2)} \newline \end{bmatrix}\rightarrow h_\theta(x) [x0x1x2x3]→[a1(2)a2(2)a3(2)]→hθ(x)

而公式总每一个激活节点的值的获取方式，则为：

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲ a_1^{(2)} = g(…

这意味着我们通过使用3×4的参数矩阵来计算激活节点。我们将每一行参数应用于我们的输入，以获得一个激活节点的值。我们的假设输出是应用于我们的激活节点的值之和的逻辑函数，其已乘以另一个参数矩阵 Θ ( 2 ) \Theta^{(2)} Θ(2)，这其中包含第二层节点的权重。每一层都有自己的权重矩阵 Θ ( j ) \Theta^{(j)} Θ(j)，这些权重矩阵的尺寸确定如下：如果该神经网络在第j层有s_j个节点，在第j+1层有s_{j+1}个节点，那么这个权重矩阵 Θ ( j ) \Theta^{(j)} Θ(j)的维度就是 s j + 1 × ( s j + 1 ) s_{j+1}\times(s_j+1) sj+1×(sj+1)。+1来自 Θ ( j ) \Theta^{(j)} Θ(j)中添加的“偏差节点”， x 0 x_0 x0和 Θ 0 ( j ) \Theta_0^{(j)} Θ0(j)。换句话说，输出节点将不包括偏置节点，而输入节点将包括偏置节点。

接下来，我们将对上述函数进行矢量化实现。我们将定义一个新变量 z k ( j ) z_k^{(j)} zk(j)它包含了g函数中的参数。在我们前面的示例中，如果我们用变量z替换所有参数，我们将得到：

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲a_1^{(2)} = g(z…

对于位于第二层的k个节点而言，变量z将被写成这样的形式 z k ( 2 ) = Θ k , 0 ( 1 ) x 0 + Θ k , 1 ( 1 ) x 1 + Θ k , 2 ( 1 ) x 2 + Θ k , n ( 1 ) x n z_k^{(2)}=\Theta_{k,0}^{(1)}x_0 + \Theta_{k,1}^{(1)}x_1 + \Theta_{k,2}^{(1)}x_2 + \Theta_{k,n}^{(1)}x_n zk(2)=Θk,0(1)x0+Θk,1(1)x1+Θk,2(1)x2+Θk,n(1)xn

x和 z j z^j zj的向量表示为：

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲x = \begin{bmat…

这时我们令 x = a ( 1 ) x=a^{(1)} x=a(1)，我们就可以得到这样一个普适的公式： z ( j ) = Θ ( j − 1 ) a ( j − 1 ) z^{(j)}=\Theta^{(j-1)}a^{(j-1)} z(j)=Θ(j−1)a(j−1)，这样我们就可以得到第j层的激活结点的向量表示为 a ( j ) = g ( z ( j ) ) a^{(j)}=g(z^{(j)}) a(j)=g(z(j))。在计算得到 a ( j + 1 ) a^{(j+1)} a(j+1)之后，将偏置单元添加到激活结点当中，即为 a 0 ( j ) = 1 a_0^{(j)}=1 a0(j)=1。为了计算我们的最终假设函数值，我们首先计算另一个z向量： z ( j + 1 ) = Θ ( j ) a ( j ) z^{(j+1)}=\Theta^{(j)}a^{(j)} z(j+1)=Θ(j)a(j)。我们将 Θ ( j − 1 ) \Theta^{(j-1)} Θ(j−1)之后的下一个 Θ \Theta Θ矩阵和我们刚刚得到的所有激活节点的值相乘，得到最终的z向量。最后的这个 Θ \Theta Θ矩阵 Θ ( j ) \Theta^{(j)} Θ(j)只有一行因此乘以只有一列的 a ( j ) a ^{(j)} a(j)，所以我们的结果是一个单一的数字。然后，我们通过以下方式获得最终结果： h Θ ( x ) = a ( j + 1 ) = g ( z ( j + 1 ) ) h_\Theta(x)=a^{(j+1)}=g(z^{(j+1)}) hΘ(x)=a(j+1)=g(z(j+1))。请注意，在最后一步中，在第j层和第j+1层之间，我们所做的事情与逻辑回归中所做的完全相同。在神经网络中添加所有这些中间层可以让我们更优雅地产生有趣和更复杂的非线性假设。

例子与直觉理解：应用神经网络的一个简单例子是预测 x 1 x_1 x1和 x 2 x_2 x2，这是逻辑“and”运算符，仅当 x 1 x_1 x1和 x 2 x_2 x2都是1时输出结果为1。我们的函数图如下所示：

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲\begin{bmatrix}…

需要注意的是 x 0 x_0 x0是偏置单元其值始终为1，现在设定 Θ \Theta Θ矩阵为 Θ ( 1 ) = [ − 30 a m p ; 20 a m p ; 20 ] \Theta^{(1)} =\begin{bmatrix}-30 & 20 & 20\end{bmatrix} Θ(1)=[−30amp;20amp;20]，这样设置 Θ \Theta Θ矩阵会让最后的输出假设为真当且仅当 x 1 x_1 x1和 x 2 x_2 x2都是1。结算过程如下：

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲& h_\Theta(…

因此，我们通过使用一个小的神经网络，而不是使用实际的与门，来构造计算机中的一个基本运算。神经网络也可以用来模拟所有其他逻辑门。下面是逻辑运算符“OR”的示例，表示 x 1 x_1 x1是真的或者 x 2 x_2 x2是真的，又或者两者都是真的。

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲& \Theta^{(…

在这些的基础上我们可以试着构建更高级的逻辑门，比如说是异或门。我们现在已知与门、或非门、或门的 Θ \Theta Θ矩阵值为：

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲AND:\Theta^{(1)…

根据这三种逻辑门构建的神经网络图的结构应该如下所示：

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲\begin{bmatrix}…

从输入层到第一个隐藏层实现与门和或非门的功能，因此构建 Θ ( 1 ) \Theta^{(1)} Θ(1)矩阵： Θ ( 1 ) = [ − 30 a m p ; 20 a m p ; 20 10 a m p ; − 20 a m p ; − 20 ] \Theta^{(1)} =\begin{bmatrix}-30 & 20 & 20 \newline 10 & -20 & -20\end{bmatrix} Θ(1)=[−30amp;20amp;2010amp;−20amp;−20]；第一个隐藏层到第二个隐藏层之间实现或门的功能，因此构建 Θ ( 2 ) \Theta^{(2)} Θ(2)矩阵： Θ ( 2 ) = [ − 10 a m p ; 20 a m p ; 20 ] \Theta^{(2)} =\begin{bmatrix}-10 & 20 & 20\end{bmatrix} Θ(2)=[−10amp;20amp;20]，然后根据上文的实现方式来得到各个节点的值：

KaTeX parse error: No such environment: align* at position 8: \begin{̲a̲l̲i̲g̲n̲*̲}̲& a^{(2)} =…

这样就实现了异或门的功能，与前面的与门、或非门、或门不同的是该异或门中包含了两个隐藏层。

多元分类：为了将数据分类为多个类别，我们让假设函数返回一个值向量。假设我们想将数据分为四类。我们将使用下面的示例来了解如何进行这种分类。该算法将图像作为输入，并对其进行相应分类：我们可以将结果类的集合定义为y：每个 y ( i ) y ^{(i)} y(i)表示与汽车、行人、卡车或摩托车相对应的不同图像。内层里的每一层都为我们提供了一些新的信息，这些信息会影响我们最终的假设函数的结果。我们对一组输入结果的假设可能如下所示：

h Θ ( x ) = [ 0 0 1 0 ] h_\Theta(x) =\begin{bmatrix}0 \newline 0 \newline 1 \newline 0 \newline\end{bmatrix} hΘ(x)=[0010]

在这种情况下，我们得到的类是第三个类的值为1，意思是算法最终判定该输入图像属于卡车分类。
神经网络的代价函数：让我们首先定义几个我们需要使用的变量：

L = 网络中的总层数
s l s_l sl = 层l中的单元数
K = 输出单元/类别的数量
由于在神经网络中我们可能有多个输出节点，所以使用 h Θ ( x ) k h_\Theta(x)_k hΘ(x)k来表示假设函数输出向量中第k维的值。

所以对于神经网络而言，它的代价函数可以写为：

KaTeX parse error: No such environment: gather* at position 8: \begin{̲g̲a̲t̲h̲e̲r̲*̲}̲ J(\Theta) = - …

我们添加了一些嵌套的求和来解释我们的多个输出节点。在方程的第一部分，在方括号之前，我们有一个额外的嵌套求和，它循环遍历输出节点的数量。在正则化部分，在方括号之后，我们必须考虑多个 Θ \Theta Θ矩阵。当前 Θ \Theta Θ矩阵中的列数等于当前层中的节点数（包括偏移单位）。当前 Θ \Theta Θ矩阵中的行数等于下一层中的节点数（不包括偏移单位）。和之前的逻辑回归一样，我们对每一项进行平方运算。

反向传播：是用于最小化成本函数的神经网络术语，就像我们在logistic和线性回归中使用梯度下降法一样。我们的目标是计算： m i n Θ J ( Θ ) min_\Theta J(\Theta) minΘJ(Θ)。也就是说，我们希望使用 Θ \Theta Θ中的一组最佳参数来最小化代价函数J。根据我们用来计算 J ( Θ ) J(\Theta) J(Θ)偏导数的方程：

∂ ∂ Θ i , j ( l ) J ( Θ ) \frac{\partial}{\partial\Theta_{i,j}^{(l)}}J(\Theta) ∂Θi,j(l)∂J(Θ)

然后进行反向传播算法的计算：

根据给定的训练集 { ( x ( 1 ) , y ( 1 ) ) ⋯ ( x ( m ) , y ( m ) ) } \{(x^{(1)},y^{(1)})\cdots(x^{(m)},y^{(m)})\} {(x(1),y(1))⋯(x(m),y(m))}，定义一个与神经网络结构有关的零矩阵 Δ \Delta Δ，三个参数为 ( l , i , j ) (l,i,j) (l,i,j)， l l l是神经网络层数， i i i和 j j j是行坐标和列坐标。对于每个训练集当中的元素我们都做如下运算：

令 a ( 1 ) : = x ( t ) , t = 1 ⋯ m a^{(1)}:=x^{(t)},t=1\cdots m a(1):=x(t),t=1⋯m
在该神经网络中运用前向传播算法去计算除第一层外，每一层的激活值 a ( l ) a^{(l)} a(l)
根据该训练集中做好的标注 y ( t ) y^{(t)} y(t)，去计算 δ ( L ) = a ( L ) − y ( t ) \delta^{(L)}=a^{(L)}-y^{(t)} δ(L)=a(L)−y(t)，这里L是神经网络的总层数，$ a^{(L)}$是是最后一层激活单元的输出向量。因此，最后一层的“误差值”只是最后一层的实际结果与y的正确输出之间的差异。为了得到最后一层之前各层的增量值，我们可以使用一个从右到左的公式
根据 δ ( l ) = ( ( Θ ( l ) ) T δ ( l + 1 ) ) . ∗ g ′ ( z ( l ) ) = ( ( Θ ( l ) ) T δ ( l + 1 ) ) . ∗ a ( l ) . ∗ ( 1 − a ( l ) ) \delta^{(l)}=((\Theta^{(l)})^T\delta^{(l+1)}).*g^{\prime}(z^{(l)})=((\Theta^{(l)})^T\delta^{(l+1)}).*a^{(l)}.*(1-a^{(l)}) δ(l)=((Θ(l))Tδ(l+1)).∗g′(z(l))=((Θ(l))Tδ(l+1)).∗a(l).∗(1−a(l))计算 δ ( L − 1 ) , δ ( L − 2 ) , … , δ ( 2 ) \delta^{(L-1)},\delta^{(L-2)},\ldots,\delta^{(2)} δ(L−1),δ(L−2),…,δ(2)，后面点乘的那一项是g(z)函数的导数
$ \Delta^{(l)}{i,j} := \Delta^{(l)}{i,j} + a_j^{(l)} \delta_i^{{(l+1)}$或者是向量化的计算方式$\Delta}{(l)} := \Delta^{(l)} + \delta^{(l+1)}(a{(l)})^T$

据此我们就可以更新 Δ \Delta Δ矩阵：

在j不等于0时， D i , j ( l ) : = 1 m ( Δ i , j ( l ) + λ Θ i , j ( l ) ) D^{(l)}_{i,j} := \dfrac{1}{m}\left(\Delta^{(l)}_{i,j} + \lambda\Theta^{(l)}_{i,j}\right) Di,j(l):=m1(Δi,j(l)+λΘi,j(l))
在j等于0时， D i , j ( l ) : = 1 m Δ i , j ( l ) D^{(l)}_{i,j} := \dfrac{1}{m}\Delta^{(l)}_{i,j} Di,j(l):=m1Δi,j(l)

增量矩阵D被用作一个“累加器”，在我们前进的过程中累加我们的值，并最终计算我们的偏导数。然后我们就可以得到 ∂ ∂ Θ i j ( l ) J ( Θ ) = D i j ( l ) \frac \partial {\partial \Theta_{ij}^{(l)}} J(\Theta)=D_{ij}^{(l)} ∂Θij(l)∂J(Θ)=Dij(l)

实际上 δ \delta δ计算的是cost函数对于 z j ( l ) z_j^{(l)} zj(l)的偏导数 δ j ( l ) = ∂ ∂ z j ( l ) c o s t ( t ) \delta_j^{(l)}=\frac{\partial}{\partial z_j^{(l)}}cost(t) δj(l)=∂zj(l)∂cost(t)

梯度检测：梯度检查将确保我们的反向传播按预期工作。我们可以用以下公式近似成本函数的导数：

∂ ∂ Θ J ( Θ ) ≈ J ( Θ + ϵ ) − J ( Θ − ϵ ) 2 ϵ \dfrac{\partial}{\partial\Theta}J(\Theta) \approx \dfrac{J(\Theta + \epsilon) - J(\Theta - \epsilon)}{2\epsilon} ∂Θ∂J(Θ)≈2ϵJ(Θ+ϵ)−J(Θ−ϵ)
在有多个 Θ \Theta Θ的情况下，我们可以将公式改写为：

∂ ∂ Θ j J ( Θ ) ≈ J ( Θ 1 , … , Θ j + ϵ , … , Θ n ) − J ( Θ 1 , … , Θ j − ϵ , … , Θ n ) 2 ϵ \dfrac{\partial}{\partial\Theta_j}J(\Theta) \approx \dfrac{J(\Theta_1, \dots, \Theta_j + \epsilon, \dots, \Theta_n) - J(\Theta_1, \dots, \Theta_j - \epsilon, \dots, \Theta_n)}{2\epsilon} ∂Θj∂J(Θ)≈2ϵJ(Θ1,…,Θj+ϵ,…,Θn)−J(Θ1,…,Θj−ϵ,…,Θn)

ϵ \epsilon ϵ的取值约为10^-4，如果再小的话会使我们的程序陷入数值问题。

epsilon = 1e-4;
for i = 1:n,thetaPlus = theta;thetaPlus(i) += epsilon;thetaMinus = theta;thetaMinus(i) -= epsilon;gradApprox(i) = (J(thetaPlus) - J(thetaMinus))/(2*epsilon)
end;

我们之前看到了如何计算deltaVector。一旦我们计算了梯度近似向量，我们就可以检查gradApprox是否约等于 deltaVector。一旦验证了反向传播算法的正确性，就不需要再次计算梯度近似值。因为计算GradApprox的代码可能非常慢。

随机初始化：在一开始的初始化工作中，将所有 Θ \Theta Θ权重初始化为零不适用于神经网络。当我们反向传播时，所有节点都会重复更新到相同的值。相反，我们可以使用以下方法随机初始化 Θ \Theta Θ矩阵的权重：

因此，我们初始化每个 Θ i j ( l ) \Theta^{(l)}_{ij} Θij(l)到 [ − ϵ , ϵ ] [-\epsilon,\epsilon] [−ϵ,ϵ]之间的随机值。使用上述公式可以保证我们得到所需的界限。同样的过程也适用于所有的 Θ \Theta Θ。下面是一些可以用于实验的工作代码。

If the dimensions of Theta1 is 10x11, Theta2 is 10x11 and Theta3 is 1x11.Theta1 = rand(10,11) * (2 * INIT_EPSILON) - INIT_EPSILON;
Theta2 = rand(10,11) * (2 * INIT_EPSILON) - INIT_EPSILON;
Theta3 = rand(1,11) * (2 * INIT_EPSILON) - INIT_EPSILON;

整合一下：首先，选择一个网络架构；选择神经网络的布局，包括每层中有多少隐藏单元，以及你想要的总层数。

输入单位数量=特征尺寸 x ( i ) x^{(i)} x(i)
输出单元数量=类别数量
每层隐藏单位的数量=通常越多越好（必须与计算成本相平衡，因为它随着隐藏单位的增加而增加），默认值：1个隐藏层。如果有多个隐藏层，建议在每个隐藏层中有相同数量的单元。

然后开始训练我们的神经网络，当我们执行正向和反向传播时，我们会循环每个训练示例：：

随机初始化权重
实现前向传播对每个 x ( i ) x^{(i)} x(i)都获得 h Θ ( x ( i ) ) h_\Theta(x^{(i)}) hΘ(x(i))
计算代价函数
实现反向传播来计算偏导数
使用梯度检查来确认你的反向传播工作。然后禁用梯度检查。
使用梯度下降法或内置的优化函数，使权重在 Θ \Theta Θ内的成本函数最小化。

理想情况下我们想要让 h Θ ( x ( i ) ) ≈ y ( i ) h_\Theta(x^{(i)})\approx y^{(i)} hΘ(x(i))≈y(i)，这将会使得我们的成本函数最小化，但是有一点需要注意的是 J ( Θ ) J(\Theta) J(Θ)不是凸的，因此我们可能会得到局部最小值。

评估假设：一旦我们通过以下方式解决了预测中的错误：

获取更多培训示例
尝试更小的功能集
尝试其他功能
尝试多项式特征
增加或减少λ

我们可以继续评估我们的新假设。假设对训练示例的误差可能很小，但仍然不准确（因为过度拟合）。因此，为了评估一个假设，给定一个训练示例数据集，我们可以将数据分为两组：训练集和测试集。通常，训练集由70%的数据组成，测试集是剩下的30%。

使用这两套设备的新程序如下：

学习 Θ \Theta Θ并最小化 J t r a i n ( Θ ) J_{train}(\Theta) Jtrain(Θ)使用训练集
计算测试集误差 J t e s t ( Θ ) J_{test}(\Theta) Jtest(Θ)

对于测试集计算后的误差情况我们分为两种情况进行讨论：

对于线性回归而言： J t e s t ( Θ ) = 1 2 m t e s t ∑ i = 1 m t e s t ( h Θ ( x t e s t ( i ) ) − y t e s t ( i ) ) 2 J_{test}(\Theta) = \dfrac{1}{2m_{test}} \sum_{i=1}^{m_{test}}(h_\Theta(x^{(i)}_{test}) - y^{(i)}_{test})^2 Jtest(Θ)=2mtest1∑i=1mtest(hΘ(xtest(i))−ytest(i))2
对于分类错误（也称为0/1错误分类错误）：

e r r ( h Θ ( x ) , y ) = 1 a m p ; i f h Θ ( x ) ≥ 0.5 a n d y = 0 o r h Θ ( x ) l t ; 0.5 a n d y = 1 0 a m p ; o t h e r w i s e err(h_\Theta(x),y) = \begin{matrix} 1 & if h_\Theta(x) \geq 0.5\ and\ y = 0\ or\ h_\Theta(x) < 0.5\ and\ y = 1\newline 0 & otherwise \end{matrix} err(hΘ(x),y)=1amp;ifhΘ(x)≥0.5 and y=0 or hΘ(x)lt;0.5 and y=10amp;otherwise

这会给我们一个基于错误分类的二进制0或1错误结果。测试集的平均测试误差为： Test Error = 1 m t e s t ∑ i = 1 m t e s t e r r ( h Θ ( x t e s t ( i ) ) , y t e s t ( i ) ) \text{Test Error} = \dfrac{1}{m_{test}} \sum^{m_{test}}_{i=1} err(h_\Theta(x^{(i)}_{test}), y^{(i)}_{test}) Test Error=mtest1∑i=1mtesterr(hΘ(xtest(i)),ytest(i))
这为我们提供了错误分类的测试数据的比例。

吴恩达机器学习系列课程笔记相关推荐

吴恩达机器学习系列课程笔记——第十一章：机器学习系统的设计(Machine Learning System Design)
11.1 首先要做什么 https://www.bilibili.com/video/BV164411b7dx?p=65 在接下来的视频中,我将谈到机器学习系统的设计.这些视频将谈及在设计复杂的机器学 ...
吴恩达机器学习系列课程笔记——第十六章：推荐系统(Recommender Systems)
16.1 问题规划 https://www.bilibili.com/video/BV164411b7dx?p=96 在接下来的视频中,我想讲一下推荐系统.我想讲推荐系统有两个原因: 第一.仅仅因为它 ...
吴恩达机器学习系列课程笔记——第五章：Octave教程(Octave Tutorial)
提示:这章选学,可以去学python,第六节可以看看. 5.1 基本操作 https://www.bilibili.com/video/BV164411b7dx?p=26 本章学习以种编程语言:Oct ...
吴恩达机器学习系列课程--个人笔记
网址:https://www.bilibili.com/video/av50747658/ (b站找的有中文字幕的视频) 第一周一.引言 1.1 欢迎 1.2 机器学习是什么 1.3 监督学习 1. ...
吴恩达机器学习系列课程作业ex3 matlab实现
目录 Matlab实现: lrCostFunction.m oneVsAll.m predictOneVsAll.m predict.m Matlab实现: lrCostFunction.m func ...
吴恩达深度学习课程笔记（初步认识神经网络）
吴恩达深度学习课程笔记1 课程主要内容 1.神经网络与深度学习介绍 2.Improving Deep Neural Networks:超参数调整,正则化,优化方法 3.结构化机器学习工程:比如如何分割 ...
吴恩达深度学习课程笔记（四）：卷积神经网络2 实例探究
吴恩达深度学习课程笔记(四):卷积神经网络2 实例探究吴恩达深度学习课程笔记(四):卷积神经网络2 实例探究 2.1 为什么要进行实例探究 2.2 经典网络 LeNet-5 AlexNet VGG- ...
吴恩达机器学习MATLAB代码笔记（1）梯度下降
吴恩达机器学习MATLAB代码笔记(1)梯度下降单变量线性回归 1.标记数据点(Plotting the Date) fprintf('Plotting Data') data = load('D: ...
吴恩达机器学习系列篇p31~p42
文章目录逻辑回归矢量分类 s型函数决策界限代价函数优化过拟合问题逻辑回归吴恩达机器学习系列篇p31~p42 矢量 octave c++ 分类 · 0 1 分类 ### 直线回归对于 ...

吴恩达机器学习系列课程笔记

吴恩达机器学习系列课程笔记相关推荐

最新文章

热门文章