Machine learning （3）

Bertha 。 2022-05-16 23:13 203阅读 0赞

## 逻辑回归 ##

### `分类问题` ###

*  在分类问题中，你要预测的变量y  y 是离散的值，我们将学习一种叫做逻辑回归的算法，这是目前最流行使用最广泛的一种学习算法。
 *  在分类问题中，我们尝试预测的是结果是否属于某个类（例如正确或错误）。分类问题的例子有：判断一封电子邮件是否是垃圾邮件；判断一次金融是否是欺诈，之前我们也谈到了肿瘤分类问题的例子，区别一个肿瘤是恶性还是良性。
 *  我们从二元的分类问题开始讨论。
 *  我们将因变量可能属于的两个类分别称为负向类和正向类，则因变量y∈0,1 y ∈ 0 , 1，其中0表示负向类，1表示正向类。  
    ![87352269.jpg][]  
    ![43145645.jpg][]
 *  如果我们要用线性回归算法来解决一个分类问题，对于分类，y取值为0或1，但如果你使用的是线性回归，那么假设函数的输出可能远大于1，或者远小于0，即使所有训练样本的标签y都等于0或1，尽管我们知道标签应该取值0或者1，但是如果算法得到的值远大于1或者远小于0的话，就会感觉很奇怪。所以我们在接下来的要研究的算法就叫做逻辑回归算法，这个算法的性质是，它的输出值永远在0到1之间.
 *  顺便说一下，逻辑回归算法是分类算法，我们将它作为分类算法使用。有时候可能因为这个算法的名字中出现了“回归”使你感到困惑，但逻辑回归算法实际上是一种分类算法，它适用于标签y取值离散的情况，如：1001  1 0 0 1 。

### `假说表示` ###

*  回顾在一开始提到的乳腺分类问题，我们可以用线性回归的方法求出适合数据的一条直线：  
    ![28624043.jpg][]
 *  根据线性回归模型我们只能预测连续的值，然而对于分类问题，我们需要输出0或1，我们可以预测：
    
     *  当hΘ(x)>=0.5时，预测y=1  h Θ ( x ) >= 0.5 时 ， 预 测 y = 1 .
     *  当hΘ(x)<0.5时，预测y=0  h Θ ( x ) < 0.5 时 ， 预 测 y = 0 .
 *  对于上图所示的数据，这样的一个线性模型似乎能完成分类任务，加入我们又观测到一个非常大尺寸的恶性肿瘤，将其作为实例加入我们的训练集中来，这将使得我们获得一条 新的直线。  
    ![62290888.jpg][]
 *  这时，再用0.5作为阈值来预测肿瘤是良性还是恶性便不合适了。可以看出，线性回归模型，因为其预测的值可以超越（0,1）的范围，并不合适解决这样的问题。
 *  我们引入一个新的模型，逻辑货柜，该模型的输出变量范围始终在0和1之间。逻辑回归模型的假设是：hΘ(x)=g(ΘTX)  h Θ ( x ) = g ( Θ T X ) ,其中：X 代表特征向量，g代表伙计函数是一个常用的逻辑函数为s型函数，公式为：g(z)=11\+e−z  g ( z ) = 1 1 + e − z 
 *  该函数的图像为：  
    ![96142405.jpg][]
 *  和起来，我们得到逻辑回归模型的假设：
 *  对模型的理解：g(z)=11\+e−z  g ( z ) = 1 1 + e − z .
 *  hΘ(x)  h Θ ( x ) 的作用是，对于给定的输入变量，根据选择的参数计算输出变量=1  = 1 的可能性即hΘ(x)=P(y=1|x;Θ)  h Θ ( x ) = P ( y = 1 | x ; Θ ) 
 *  例如，如果对于给定的x  x ，通过已经确定的参数计算得出hΘ(x)=0.7 h Θ( x ) = 0.7，则表示有70  70 的几率为正向类，相应的y  y 为负向类的几率为1-0.7 = 0.3。

### `判定边界` ###

*  现在讲一下决策边界的概念。这个概念能更好的帮助我们理解逻辑回归的假设函数在计算什么。  
    ![91342536.jpg][]
 *  在逻辑回归中，我们预测：
    
     *  当hΘ(x)>=0.5时,预测y=1 h Θ( x ) >= 0.5时,预测y = 1。
     *  当hΘ(x)<0.5时，预测y=0  当 h Θ ( x ) < 0.5 时 ， 预 测 y = 0 。
    
     *  根据上去绘制出的S  S 型函数图像，我们知道当  
        
        
         *  z=0时，g(z)=0.5 z = 0时，g ( z ) = 0.5
         *  z>0时，g(z)>0.5  z > 0 时 ， g ( z ) > 0.5 
         *  z<0时，g(z)<0.5  z < 0 时 ， g ( z ) < 0.5 
         *  又z=ΘT，即  z = Θ T ， 即   
            
            
             *  ΘT>=0时，预测y=1  Θ T >= 0 时 ， 预 测 y = 1 
             *  ΘT<0时，预测y=0  Θ T < 0 时 ， 预 测 y = 0 
         *  现在假设我们有一个模型：  
            ![37024121.jpg][]
         *  并且参数Θ是向量\[−311\]  Θ 是 向 量 \[ − 3 1 1 \] .则当x−1\+x2>=3时  x − 1 + x 2 >= 3 时 ，模型预测y=1  y = 1 ，我们可以绘制直线x1\+x2=3  x 1 + x 2 = 3 ，这条线便是我们模型的分界线，将预测为1的区域和预测为0的区域分割开。  
            ![19147270.jpg][]
         *  假使我们的数据呈现这样的分布情况，怎么样的模型才能适合呢？
         *  ![57710953.jpg][]
            
             *  因为需要用曲线才能分割y=0  y = 0 的区域，和y=1  y = 1 的区域，我们需要二次方特征：hΘ(x)=g(Θ0\+Θ1x1\+Θ2x2\+Θ3x21\+Θ4x22)  h Θ ( x ) = g ( Θ 0 + Θ 1 x 1 + Θ 2 x 2 + Θ 3 x 1 2 + Θ 4 x 2 2 ) ，则我们得到的判定边界恰好是在原点且半径为1的圆形。
             *  我们可以用非常复杂的模型来适应非常复杂形状的判定边界。
            
            ### `代价函数` ###
            
             *  我们要介绍如何拟合逻辑回归模型的参数Θ  Θ .具体来说，我要定义用来拟合参数的优化目标或者代价函数，这便是监督学习问题中逻辑回归模型的拟合问题。  
                ![81071562.jpg][]
             *  对于线性回归模型，我们定义的代价函数是所有模型误差的平方和。理论上来说，我们也可以对逻辑回归模型沿用这个定义。但问题在于，当我们将hΘ(x)=11\+e−ΘTx  h Θ ( x ) = 1 1 + e − Θ T x 带入到这样定义了的代价函数中时，我们得到的代价函数将是一个非凸函数。  
                ![47916735.jpg][]
             *  这意味着我们的代价函数有许多局部最小值，这将影响梯度下降算法寻找全局最小值。
             *  线性回归的代价函数为：J(Θ)=1m∑mi=112(hΘ(x(i))−y(i))2  J ( Θ ) = 1 m ∑ i = 1 m 1 2 ( h Θ ( x ( i ) ) − y ( i ) ) 2 .
             *  我们重新定义逻辑回归的代价函数为:J(Θ)=1m∑mi=1Cost(hΘ(x(i)),y(i))  J ( Θ ) = 1 m ∑ i = 1 m C o s t ( h Θ ( x ( i ) ) , y ( i ) ) ,其中。  
                
                
                Cost(hΘ(x),y)=\{ −log(hΘ(x))−log(1−hΘ(x))ify=1ify=0  C o s t ( h Θ ( x ) , y ) = \{ − l o g ( h Θ ( x ) ) i f y = 1 − l o g ( 1 − h Θ ( x ) ) i f y = 0 
             *  hΘ(x)与Cost（hΘ(x),y）之间的关系如下图所示:  h Θ ( x ) 与 C o s t （ h Θ ( x ) , y ） 之 间 的 关 系 如 下 图 所 示 :   
                ![68421522.jpg][]
             *  这样构建的Cost(hΘ(x),y)函数的特点是，当实际的y=1且hΘ(x)也为1时误差为0，当y=1,但hΘ(x)不为1时误差随着hΘ(x)变小而变大：当实际的y=0且hΘ(x)也为0时代价为0，当y=0，但y=0但hΘ(x)不为0时误差随着hΘ(x)的变大而变大。  这 样 构 建 的 C o s t ( h Θ ( x ) , y ) 函 数 的 特 点 是 ， 当 实 际 的 y = 1 且 h Θ ( x ) 也 为 1 时 误 差 为 0 ， 当 y = 1 , 但 h Θ ( x ) 不 为 1 时 误 差 随 着 h Θ ( x ) 变 小 而 变 大 ： 当 实 际 的 y = 0 且 h Θ ( x ) 也 为 0 时 代 价 为 0 ， 当 y = 0 ， 但 y = 0 但 h Θ ( x ) 不 为 0 时 误 差 随 着 h Θ ( x ) 的 变 大 而 变 大 。 
             *  将构建的Cost(h\_\\Theta(x),y)简化如下：
             *  带入代价函数得到：  
                
                
                J(Θ)=1m∑i=1m\[−y(i)log(hΘ(x(i)))−(1−y(i))log(1−hΘ(x(i)))\]  J ( Θ ) = 1 m ∑ i = 1 m \[ − y ( i ) l o g ( h Θ ( x ( i ) ) ) − ( 1 − y ( i ) ) l o g ( 1 − h Θ ( x ( i ) ) ) \] 
             *  即：  
                
                
                J(Θ)=−1m∑i=1m\[y(i)log(hΘ(x(i)))\+(1−y(i))log(1−hΘ(x(i)))\]  J ( Θ ) = − 1 m ∑ i = 1 m \[ y ( i ) l o g ( h Θ ( x ( i ) ) ) + ( 1 − y ( i ) ) l o g ( 1 − h Θ ( x ( i ) ) ) \] 
             *  在得到这样一个代价函数后，我们便可以用梯度下降算法来求得能使代价函数最小的参数了。算法为：  
                ![43550069.jpg][]
            
            ### `简化的成本函数和梯度下降` ###
            
             *  我们将会找出一种稍微简单一点的方法来写代价函数，来替换我们现在用的方法。同时我们还要弄清楚如何运用下降法，来拟合出逻辑回归的参数。
             *  这是逻辑回归的代价函数： J(Θ)=1m∑mi=1Cost(hΘ(x(i)),y(i))  J ( Θ ) = 1 m ∑ i = 1 m C o s t ( h Θ ( x ( i ) ) , y ( i ) ) ,其中。  
                
                
                Cost(hΘ(x),y)=\{ −log(hΘ(x))−log(1−hΘ(x))ify=1ify=0  C o s t ( h Θ ( x ) , y ) = \{ − l o g ( h Θ ( x ) ) i f y = 1 − l o g ( 1 − h Θ ( x ) ) i f y = 0 
             *  这个式子可以合成：  
                
                
                Cost(hΘ(x),y)=−y×log(hΘ(x))−(1−y)×log(1−hΘ(x))  C o s t ( h Θ ( x ) , y ) = − y × l o g ( h Θ ( x ) ) − ( 1 − y ) × l o g ( 1 − h Θ ( x ) ) 
             *  即，逻辑回归的代价函数：  
                
                
                Cost(hΘ(x),y)=−y×log(hΘ(x))−(1−y)×log(1−hΘ(x))=−1m∑i=1m\[y(i)log(hΘ(x(i)))\+(1−y(i))log(1−hΘ(x（i）))\]  C o s t ( h Θ ( x ) , y ) = − y × l o g ( h Θ ( x ) ) − ( 1 − y ) × l o g ( 1 − h Θ ( x ) ) = − 1 m ∑ i = 1 m \[ y ( i ) l o g ( h Θ ( x ( i ) ) ) + ( 1 − y ( i ) ) l o g ( 1 − h Θ ( x （ i ） ) ) \] 
             *  根据这个代价函数，为了拟合出参数，该怎么做呢》我们要试图找尽量让J(Θ)  J ( Θ ) 取得最小值的参数Θ  Θ .  
                
                
                minΘJ(Θ)  m i n Θ J ( Θ ) 
             *  所以我们想要尽量减小这一项，这将我们将得到某个参数Θ  Θ .
             *  如果我们给出一个新的样本，加入某个特征x  x ，我们可以用拟合训练样本的参数Θ Θ，来输出对假设的预测。
             *  另外，我们假设的输出，实际上就是这个概率值：p(y=1|x;Θ)  p ( y = 1 | x ; Θ ) ,就是关于x  x 以\\Theta为参数，y=1 y = 1的概率，你可以认为我们的假设就是估计y=1  y = 1 的概率，所以，接下来就是弄清楚如何最大限度的最小化代价函数J(Θ)  J ( Θ ) ,作为一个关于Θ  Θ 的函数，这样我们才能为训练集拟合参数Θ  Θ 。
             *  最小化代价函数的办法，是使用梯度下降法，这是我们的代价函数：  
                
                
                J(Θ)=−y×log(hΘ(x))−(1−y)×log(1−hΘ(x))=−1m∑i=1m\[y(i)log(hΘ(x(i)))\+(1−y(i))log(1−hΘ(x（i）))\]  J ( Θ ) = − y × l o g ( h Θ ( x ) ) − ( 1 − y ) × l o g ( 1 − h Θ ( x ) ) = − 1 m ∑ i = 1 m \[ y ( i ) l o g ( h Θ ( x ( i ) ) ) + ( 1 − y ( i ) ) l o g ( 1 − h Θ ( x （ i ） ) ) \] 
             *  如果我们要最小化这个关于Θ  Θ 的函数值，这就是我们通常用的梯度下降法的模板。  
                ![62042150.jpg][]
             *  我们要反复更新每个参数，用这个式子来更新，就是用它自己减去学习率α  α 乘以后面的 微分项，求导后得到的：  
                ![21939902.jpg][]
             *  如果你计算一下的话，你会得到这个等式：  
                
                
                Θj:=Θj−α1m∑i=1m(hΘ(x(i))−y(i))x(i)j  Θ j := Θ j − α 1 m ∑ i = 1 m ( h Θ ( x ( i ) ) − y ( i ) ) x j ( i ) 
             *  我把它写在这里，这将后面这个式子，在i=1  i = 1 到m  m 上求和，其实就是预测误差乘以xj(i) x j( i ),所以你把这个偏导数项∂∂ΘjJ(Θ)  ∂ ∂ Θ j J ( Θ ) 放回原来式子这里，我们就可以将梯度下降算法写作如下形式：  
                
                
                Θj:=Θj−α1m∑i=1m(hΘ(x(i))−y(i))x(i)j  Θ j := Θ j − α 1 m ∑ i = 1 m ( h Θ ( x ( i ) ) − y ( i ) ) x j ( i ) 
             *  所以，如果你有n  n 个特征，也就是说：
                
                Θ=⎡⎣⎢⎢⎢⎢⎢⎢Θ0Θ1Θ2...Θ0⎤⎦⎥⎥⎥⎥⎥⎥ Θ =\[Θ 0Θ 1Θ 2. . .Θ 0\]
             *  参数向量Θ  Θ 包含Θ0,Θ1,Θ2一直到Θn  Θ 0 , Θ 1 , Θ 2 一 直 到 Θ n ,那么你就需要用这个式子：  
                
                
                Θj:=Θj−α1m∑i=1m(hΘ(x(i))−y(i))x(i)j  Θ j := Θ j − α 1 m ∑ i = 1 m ( h Θ ( x ( i ) ) − y ( i ) ) x j ( i ) 
                
                来同时更新所有Θ的值  Θ 的 值 
             *  现在，如果你把这个更新规则和我们之前用在线性胡桂上的进行比较的话，你会惊讶的发现，这个式子正是我们用来做线性回归梯度下降的。
             *  那么，线性回归和逻辑回归是同一个算法吗？要回答这个问题，我们要观察逻辑回归看看发生了哪些变化，实际上，假设的定义发生了变化。
             *  对于线性回归假设函数：  
                
                
                hΘ(x)=ΘTX=Θ0x0\+Θ1x1\+Θ2x2\+Θ3x3\+Θ4x4\+....\+Θnxn  h Θ ( x ) = Θ T X = Θ 0 x 0 + Θ 1 x 1 + Θ 2 x 2 + Θ 3 x 3 + Θ 4 x 4 + . . . . + Θ n x n 
             *  而现在逻辑函数假设函数：hΘ(x)=11\+e−ΘTx  h Θ ( x ) = 1 1 + e − Θ T x 
             *  因此，即使更新参数的规则看起来基本相同，但由于假设的定义发生了变化，所以逻辑函数的梯度下降，跟线性回归的梯度下降实际上是两个完全不同的东西。
             *  在先前的视频中，当我们在谈论线性回归的梯度下降法时，我们谈到了如何监控梯度下降法以确保其收敛，我通常也把同样的方法用在逻辑回归中，来检测梯度下降，以确保它正常收敛。
             *  当时用梯度下降法来实现逻辑回归时，我们有这些不同的参数Θ  Θ ，就是Θ0,Θ1,Θ2  Θ 0 , Θ 1 , Θ 2 一直到Θn  Θ n ,我们需要用这个表达式来更新这些参数。我们还可以使用for循环来更新这些参数值，用fori=1ton  f o r i = 1 t o n 或者fori=1ton\+1  f o r i = 1 t o n + 1 。当然，不用for循环也是可以的，理想情况下，我们更提倡使用向量化的实现，可以把所有这些n个参数同时更新。
             *  最后还有一点，我们之前在谈线性回归时，讲到的特征缩放，我们看到了特征缩放是如何提高梯度下降的收敛速度的，这个特征缩放的方法，也适用于逻辑回归中，梯度下降收敛更快。
             *  就是这样，现在你知道如何实现逻辑回归，这是一种非常强大，甚至可能世界上使用最广泛的一种分类算法。  
                ![66901376.jpg][]
             *  假设我们已经完成了可以实现这两件事的代码，那么梯度下降所做的就是反复执行这些更新。
             *  另一种考虑下降梯度的思路是，我们需要写出代码来计算J(Θ)  J ( Θ ) 和这些偏导数，然后把这些插入到梯度下降中，然后他就可以为我们最小化这个函数。对于梯度下降来说，我认为从技术上讲，你实际并不需要编写代码计算代价函数J(Θ)  J ( Θ ) 。你只需编写代码来计算导数项，但是，如果你希望代码还要监控这些J(Θ)  J ( Θ ) 的收敛性。那么我们就需要自己编写代码来计算代价函数J(Θ)  J ( Θ ) 和偏导项∂∂ΘjJ(Θ)  ∂ ∂ Θ j J ( Θ ) 。所以，在写完能够计算这两者的代码之后，我们就可以使用梯度下降。
             *  然而梯度下降并不是我们可以使用的唯一算法，还有其他一些算法，更高级、更复杂。如果我们能用这些方法来计算代价函数J(Θ)  J ( Θ ) 和偏导数项∂∂ΘjJ(Θ)  ∂ ∂ Θ j J ( Θ ) 两个项的话，那么这些算法就是我们优化代价函数的不同方法，共轭梯度法BFGS（变尺度法）和L-BFGS（限制变尺度法）就是其中一些更高级的优化的算法，他们需要有一种方法来计算J(Θ)  J ( Θ ) ,以及需要一种方法计算导数项，然后使用比梯度下降更复杂的算法来最小化代价函数。这三种算法的具体细节超出了本门课程的范畴，实际上你最后通常会花费很多天，或几周时间研究这些算法，你可以专门学一门课来提高数值计算能力，不过让我来告诉你他们的一些特性。
             *  这三种算法的优点：
             *  一个是使用这其中任何一个算法，你通常不需要手动选择学习率α  α ,所以对于这些算法的一种思路是，给出计算导数项和代价函数的方法，你可以认为算法有一个智能的内部循环，而且，事实上，他们确实有一个智能的内部循环称为线性搜索算法，它可以自动尝试不同的学习速率α  α ,因此它甚至可以为每次迭代选择不同的学习速率α  α ，那么你就不需要自己选择，这些算法实际上在做更复杂的事情，而不仅仅是选择一个好的学习率，所以他们往往最终收敛得远远快于梯度下降，不过关于他们到底做什么的详细讨论，已经超过本课程的范围。
             *  实际上，我过去使用这些算法已经很长一段时间了，也许超过十年了，使用的相当频繁，而直到几年前我才真正搞清楚共轭梯度法和L-BFGS的细节。
             *  我们实际上完全有可能使用这些算法，并应用于许多不同的学习问题，而不需要真正理解这些算法内环间在做什么，如果说这些算法有缺点的话，那么我想说主要缺点是它们比梯度下降法复杂多了，特别是你最好不要使用L-BGFS、BFGS这些算法，除非你使计算方面的专家，实际上，我不会建议你们编写自己的代码来计算数据的平方根，或者计算逆矩阵，因为对于这些算法，我还是会建议你直接使用一个软件库，比如说，要求一个平方根，我们所能做的就是调用一些别人已经写好用来计算数字平方根的函数，幸运 的是现在我们可以使用Matlab或Python的库来做计算。
            
            ### `多类别分类：一对多` ###
            
             *  第一个例子，假如说你现在需要一个学习算法能自动将邮件归类到不同的文件夹里，或者说可以自动的加上标签，那么，你也需要一些不同的文件夹，或者不同的标签来完成这件事，来区分开来自工作的邮件、来自朋友的邮件、来自家人的邮件或者是有关兴趣爱好的邮件，那么我们就有了这样的一个分类问题，其类别有四个，分别用y=1、y=2、y=3、y=4  y = 1 、 y = 2 、 y = 3 、 y = 4 来代表。
             *  第二个例子是有关药物诊断的，如果一个病人因为鼻塞来到你的诊所，他可能并没有病，用y=1  y = 1 这个类别来代表；或者患了感冒，用y=2  y = 2 来代表；或者的了流感用y=3  y = 3 来代表。
             *  第三个例子，如果你正在做有关天气的机器学习分类问题，那么你可能想要区分哪些天是晴天、多云、雨天、或者下雪天，对上述所有的例子，y可以取一个很小的数值，一个相对“谨慎”的数值，比如1到3、1到4或者其他数值，以上说的都是多分类问题，顺便一提的是，对于下标是01234  0 1 2 3 4 都不重要，我更喜欢将分类从1开始标而不是0其实怎样标注都不会影响最后的结果。
             *  然而对于之前的一个，二元分类问题，我们的数据看起来可能是这样的。  
                ![5926415.jpg][]
             *  对于一个多类分类问题，我们的 数据集或许看起来像这样：  
                ![61272358.jpg][]
             *  我用3种不同的符号来代表3个类别，问题就是给处3个类型的数据集，我们如何得到一个学习算法来进行分类的呢？
             *  我们现在已经知道如何进行二元分类。可以使用逻辑回归，对于直线或许你也知道，可以将数据集一分为二为正类和负类。用一对多的分类思想，我们可以将其用在多类分类问题上。
             *  下面将介绍如何进行一对多的分类工作，有时这个方法也被称为“一对余”方法。  
                ![68193231.jpg][]
             *  现在我们有一个训练集，好比上图表示的有3个类别，我们用三角形表示y=1,方框表示y=2，叉叉表示y = 3，我们下面要做的就是使用一个训练集，将其分成3个二元分类问题。
             *  我们先从用三角形代表的类别1开始，实际上我们可以创建一个，新的”伪”训练集，类型2和类型3定为负类，类型1设定为正类，我们创建一个新的训练集，如下图所示的那样，我们要拟合出一个合适的分类器。  
                ![20764316.jpg][]
             *  这里的三角形是正样本，而圆形代表负样本。可以这样想，设置三角形的值为1，圆形的值为0，下面我们来训练一个标准的逻辑回归分类器，这样我们就得到一个正边界。
             *  为了能是现这样的转变，我们将多个类中的一个类标记为正向类(y=1)，然后将其他所有类都标记为负向类，这个模型记作h(i)Θ(x)  h Θ ( i ) ( x ) .接着，类似的我们选择另一个类标记为正向类(y=2)，再将其它都标记为负向类，将这个模型记作h(2)Θ(x)  h Θ ( 2 ) ( x ) 依次类推。
             *  最后我们得到一系列的模型简记为：h(i)Θ(x)=p(y=i|x;Θ)其中：i=(1,2,3,...k)  h Θ ( i ) ( x ) = p ( y = i | x ; Θ ) 其 中 ： i = ( 1 , 2 , 3 , . . . k )   
                ![20697638.jpg][]
             *  最后，在我们需要做预测时，我们将所有的分类机都运行一遍，然后对每一个输入变量，都选择最高可能性的输出变量。
             *  总之，我们已经把要做的做完了。现在要做到 就是训练这个逻辑回归分类器：h(i)Θ(x)  h Θ ( i ) ( x ) .其中i  i 对应每一个可能的y=i y = i,最后，为了做出预测，我们给出输入一个新的h(i)Θ(x)  h Θ ( i ) ( x ) 最大的i  i ,即maxih(i)(x) m ax ih( i )( x )
             *  你现在知道了基本的挑选分类器的方法，选择出哪一个分类器是可信度最高效果最好的。那么就可以认为得到一个正确的分类，无论i  i 值是多少，我们都有最高的概率值，我们预测y y就是那个值，这就是多类别分类问题，以及一对多的方法，通过这个小方法，你现在也可以将逻辑回归分类器用在多类分类的问题上。
            
            ## 正则化 ##
            
            ### `过拟合的问题` ###
            
             *  到现在为止，我们已经学习了集中不同的学习算法啊，包括线性回归和逻辑回归，他们能够有效的解决许多问题，但是当将它们应用到某些特定的机器学习应用时，会遇到过拟合的问题，可能会导致他们效果很差。
             *  我将伪逆解释什么是过度拟合问题，并且在此之后接下来的几个视频中，我们将谈论一种称为正则化的技术，他可以改善或者减少过度拟合问题。
             *  如果我们有非常多的特征，我们通过学习得到的假设可能能够非常好的适应训练集（代价函数几乎为0），但是可能不能推广到新的数据。
             *  下图是一个回归问题的例子：  
                ![11961675.jpg][]
             *  第一个模型是线性模型，欠拟合，不能很好的适应我们的训练集，第三个模型是一个四次方的模型，过于强调拟合原始数据，而丢失了算法的 本质，预测新数据。我们可以看出，若给出一个新的值使之预测，他将表现的很差，是过拟合，虽然能非常好的适应我们的训练集，但在新输入变量进行预测时可能会效果不好，而中间的模型似乎最合适。
             *  分类问题中 也存在这样的问题：  
                ![59267273.jpg][]
             *  就以多项式理解，x  x 的次数越高，拟合的越好，但相应的预测的能力就可能变差。
             *  问题是，如果我们发现了过拟合的问题，应该如何处理？
             *  丢弃一些不能帮助我们正确预测的特征，可以是手工选择保留哪些特征，或者使用一些模型选择的算法来帮忙
             *  正则化，保留所有的特征，但是减少参数的大小。
            
            ### `代价函数` ###
            
             *  上面的回归问题中如果我们的模型是：  
                
                
                hΘ(x)=Θ0\+Θ1x1\+Θ2x22\+Θ3x33\+Θ4x44 h Θ( x ) =Θ 0\+Θ 1x 1\+Θ 2x 2 2\+Θ 3x 3 3\+Θ 4x 4 4
             *  我们可以从之前的实例中看出，正式哪些告辞项导致了过拟合的产生，所以如果我们能让这些告辞项的系数接近0的话，我们就能很好的拟合了。
             *  所以我们要做的就是在一定程度上减小这些参数Θ  Θ 的值，这就是正则化的基本方法。我们决定要减少Θ3  Θ 3 和Θ4  Θ 4 的大小，我们要做的就是修改代价函数，在其中Θ3  Θ 3 和Θ4  Θ 4 设置一点惩罚，这样做的话，我们在尝试最小化代价时也需将这个惩罚纳入考虑中，并最终导致选择较小 的一些Θ3  Θ 3 和Θ4  Θ 4 .
             *  修改后的代价函数如下：minΘ12m\[∑mi=1(hΘ(x(i))−y(i))2\+1000Θ23\+10000Θ24\]  m i n Θ 1 2 m \[ ∑ i = 1 m ( h Θ ( x ( i ) ) − y ( i ) ) 2 + 1000 Θ 3 2 + 10000 Θ 4 2 \] 
             *  通过这样的代价函数选择出的Θ3  Θ 3 和Θ4  Θ 4 对预测结果的影响就比之前要小许多。假如我们有非常多的特征，我们并不知道其中哪些特征我们要惩罚，我们将对所有的特征进行惩罚，并且让代价函数最优化的软件 来选择这些城噶的程度。这样的结果是得到了一个较为简单的能防止过拟合的问题的假设：J(Θ)=12m\[∑mi=1(hΘ(x(i))−y(i))2\+λ∑j=1nΘ2j\]  J ( Θ ) = 1 2 m \[ ∑ i = 1 m ( h Θ ( x ( i ) ) − y ( i ) ) 2 + λ ∑ j = 1 n Θ j 2 \] 
             *  其中λ  λ 又称为正则化参数。注：根据管理，我们不对Θ0  Θ 0 进行惩罚。经过正则化处理的模型与原模型的可能对比如下图所示：  
                ![91374833.jpg][]
             *  如果选择的正则化参数λ  λ 过大，则会把所有的参数都最小化了，导致模型变成hΘ(x)=Θ0，也就是上图中红色直线所示的情况，造成欠拟合。  h Θ ( x ) = Θ 0 ， 也 就 是 上 图 中 红 色 直 线 所 示 的 情 况 ， 造 成 欠 拟 合 。 
             *  那为什么增加的一项λ=∑nj=1Θ2j  λ = ∑ j = 1 n Θ j 2 可以使Θ  Θ 的值减小呢？
             *  因为如果我们令λ  λ 的值很大的话，为了使CostFunction  C o s t F u n c t i o n 尽可能的小，所有的Θ  Θ 的值（不包括\\Theta\_0）都会在一定程度上减小。
             *  但若λ  λ 的值太大了，那么Θ  Θ （不包括\\Theta\_0）都会趋近于0，这样我们所得到的只能是一条平行x轴的直线。
             *  所以对于正则化，我们要取一个 合理的λ  λ 的值，这样才能更好的应用正则化。
             *  回顾一下代价函数，为了使用正则化，让我们把这些概念应用到线性回归和逻辑回归中去，那我们就可以让他们避免过度拟合了。
            
            ### `正则化线性回归` ###
            
             *  对于线性回归的求解，我们之前推导了两种学习算法：一种基于梯度下降，一种基于正规方程。
             *  正则化线性回归的代价函数为：  
                
                
                J(Θ)=12m∑i=1m\[((hΘ(x(i))−y(i))2\+λ∑j=1nΘ2j)\]  J ( Θ ) = 1 2 m ∑ i = 1 m \[ ( ( h Θ ( x ( i ) ) − y ( i ) ) 2 + λ ∑ j = 1 n Θ j 2 ) \] 
             *  如果我们要使用梯度下降法令这个代价函数最小化，因为我们来进行正则化，所以梯度下降算法将分两种情形：  
                ![29847341.jpg][]
             *  对于上面的算法中j=1,2….n时的更新式子进行调整可得。  
                
                
                Θj:=Θj(1−αλm)−α1m∑i=11(hΘ(x(i))−y(i))x(i)j  Θ j := Θ j ( 1 − α λ m ) − α 1 m ∑ i = 1 1 ( h Θ ( x ( i ) ) − y ( i ) ) x j ( i ) 
             *  可以看出，正则化线性回归的梯度下降算法的变化在于，每次都在原有的算法更新规则的基础上令Θ  Θ 值减少了一个额外的值。
             *  我们同样也可以利用正规方程来求解正则化线性回归模型，方法如下所示  
                
                
                Θ=⎛⎝⎜⎜⎜⎜⎜⎜XTX\+λ⎡⎣⎢⎢⎢⎢⎢⎢011...1⎤⎦⎥⎥⎥⎥⎥⎥⎞⎠⎟⎟⎟⎟⎟⎟−1XTy  Θ = ( X T X + λ \[ 0 1 1 . . . 1 \] ) − 1 X T y 
             *  图中的矩阵尺寸为(n\+1)∗(n\+1)  ( n + 1 ) ∗ ( n + 1 ) 
            
            ### `正则化的逻辑回归模型` ###
            
             *  针对逻辑回归问题，我们在之前的课程已经学习过两种优化算法，我们首先学习了使用梯度下降法来优化代价函数J(Θ)  J ( Θ ) ,接下来学习了跟高级的优化算法，这些高级优化算法需要你自己设计代价函数J(Θ)  J ( Θ )   
                ![44217474.jpg][]
             *  自己计算导数同样对于逻辑回归，我们也给代价函数增加一个正则化的表达式，得到代价函数.  
                
                
                J(Θ)=1m∑i=1m\[−y(i)log(hΘ(x(i)))−(1−y(i))log(1−hΘ(x(i)))\]\+λ2m∑j=1nΘ2j  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 
             *  要最小化该代价函数，通过求导，得出梯度下降算法为：  
                ![16718583.jpg][]

[87352269.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-3/87352269.jpg
[43145645.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-3/43145645.jpg
[28624043.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-3/28624043.jpg
[62290888.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-3/62290888.jpg
[96142405.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-3/96142405.jpg
[91342536.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-5/91342536.jpg
[37024121.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-5/37024121.jpg
[19147270.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-5/19147270.jpg
[57710953.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-5/57710953.jpg
[81071562.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-6/81071562.jpg
[47916735.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-6/47916735.jpg
[68421522.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-6/68421522.jpg
[43550069.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-6/43550069.jpg
[62042150.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-6/62042150.jpg
[21939902.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-6/21939902.jpg
[66901376.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-7/66901376.jpg
[5926415.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-7/5926415.jpg
[61272358.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-7/61272358.jpg
[68193231.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-7/68193231.jpg
[20764316.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-7/20764316.jpg
[20697638.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-7/20697638.jpg
[11961675.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-7/11961675.jpg
[59267273.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-7/59267273.jpg
[91374833.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-7/91374833.jpg
[29847341.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-7/29847341.jpg
[44217474.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-7/44217474.jpg
[16718583.jpg]: http://oz3ijy2k5.bkt.clouddn.com/18-8-7/16718583.jpg