linear regression and logistic regression

#①linear regression ###target function的推導 線性迴歸是一種作擬合的算法:git

經過工資和年齡預測額度,這樣就能夠作擬合來預測了。有兩個特徵,那麼就要求有兩個參數了,設置 \theta_1,\theta_2,對應工資和年齡兩個字段的值。擬合的公式通常都是 s = wx + b,因此還缺一個 b,因此還要設置一個 \theta_0,因此決策函數就是 h_{\theta}(x) = \theta_0+\theta_1x_1+\theta_2x_2。這個決策函數的形式並非推出來的,而是經驗之舉設置成這個形式的。能夠設置多一個 x_0,使得 x_0=1,而後上式就能夠變成 h_{\theta}(x) = \theta_0x_0+\theta_1x_1+\theta_2x_2,整合一下, h_{\theta}(x) = \sum_{i=0}^{i = 2}\theta_ix_i=\theta^Tx

###偏差 上面的\theta_0能夠看作是一個偏差,這個偏差知足高斯分佈,服從均值爲0,方差爲\theta^2的高斯分佈,也就是高斯分佈。由於求出來的擬合數值不是必定就準確的,確定會有一些的偏差。github

通常偏差不會太多,都是在0上下浮動的,因此0附近是最高的機率。 使用linear regression要知足三個條件: 1.獨立,每個樣本點之間都要相互獨立。 2.同分布,他們的銀行是同樣的,使用的算法是同樣的。 3.偏差都服從高斯分佈。

因爲偏差是服從高斯分佈的,天然有:$$P(\theta_0)=\frac{1}{\sqrt{2\pi}\sigma}exp(-\frac{\theta_0^2}{2\sigma^2})$$ 上述式子有:y = \theta^Tx+\theta_0算法

P(\theta_0)=\frac{1}{\sqrt{2\pi}\sigma}exp(-\frac{(y_i-\theta^Tx_i)^2}{2\sigma^2})

須要求參數\theta,天然就是最大似然函數:bash

L(\theta)=\prod_{i=1}^m\frac{1}{\sqrt{2\pi}\sigma}exp(-\frac{(y_i-\theta^Tx_i)^2}{2\sigma^2})

log化簡: logL(\theta) = log\prod_{i=1}^m\frac{1}{\sqrt{2\pi}\sigma}exp(-\frac{(y_i-\theta^Tx_i)^2}{2\sigma^2}) =mlog\frac{1}{\sqrt{2\pi}\sigma}+\sum_{i=1}^m(-\frac{(y_i-\theta^Tx_i)^2}{2\sigma^2}) =mlog\frac{1}{\sqrt{2\pi}\sigma}-\frac{1}{2\sigma^2}\sum_{i=1}^m(y_i-\theta^Tx_i)^2 最大化這個似然函數那就是最小化\frac{1}{2\sigma^2}\sum_{i=1}^m(y_i-\theta^Tx_i)^2。由於前面都是常數,能夠忽略。而這個式子稍微變一下就是最小二乘法了。 最小二乘法:f = \frac{1}{2}\sum_{i=1}^m(h_{\theta}(x_i)-y_i)^2,不用上面化簡出來的式子非要加上\frac{1}{2}是由於求導以後2是能夠和0.5抵消的。 ###目標函數的化簡 化簡一下: J(\theta)=\frac{1}{2}\sum_{i=1}^m(h_{\theta}(x_i)-y_i)^2 =\frac{1}{2}(x\theta-y)^T(x\theta-y) 求極小值,直接就是導數爲0便可,因此對\theta求導數便可。 \bigtriangledown_{\theta}J(\theta) = \bigtriangledown_{\theta}(\frac{1}{2}(\theta^Tx^T-y^T)(x\theta-y)) = \bigtriangledown_{\theta}\frac{1}{2}(\theta^Tx^Tx\theta-\theta^Tx^Ty-y^Tx\theta+y^Ty) =x^Tx\theta-x^Ty 直接令等於0:\theta = (x^Tx)^{-1}x^Ty。 這樣就是獲得了最終的目標函數,一步就能夠到達最終的optimal value。這就是linear regression。因此線性迴歸是有解析解的,直接一條公式就能夠求出來的。注意上面的公式J(\theta)=\frac{1}{2}\sum_{i=1}^m(h_{\theta}(x_i)-y_i)^2\theta^Tx是不包含bias偏置值,偏置項就是偏差,代入高斯函數推導出來的。 #②logistic regression ###target function 的推導 首先要提一個函數,sigmoid函數:f(x) = \frac{1}{1+e^{-z}} 這個函數以前被用來作神經網絡的激活函數,可是它有一個缺點。網絡

離原點處越遠梯度就越趨近於0,在神經網絡裏面就會出現一個梯度消失的問題,因此後來就用relu或者tanh函數代替了。這個函數的值域是在 (0, 1),因此sigmoid函數能夠把一個值映射成一個機率,經過這個函數就能夠作出一個機率,最後用過這個機率來區分類別。這裏的決策函數仍是和以前的同樣$$h(x) = \sum_{i=1}^m\theta_ix+\theta_0$$這樣有點麻煩,能夠把 \theta_0合併到 h(x),只須要在 x中加多一列1就行了,因此函數能夠簡化 h(x) = \theta^Tx。這仍是不是最終的決策函數,這只是一個值,只是一個得分,須要把這個得分轉換成一個機率。因此最終的決策函數就是 h(x) = \frac{1}{1+e^{-\theta^Tx}}。假設有兩個類別 y=1,y=0,那麼能夠假設屬於 y=1的類別就是 p(y=1|x;\theta) = h(x),屬於 y=0的類別就是 p(y=0|x;\theta) = 1-h(x) 這樣的兩個的式子對於求導和化簡都很差,因此合併一下:$$P(y|x:\theta) = (h(x)^y)(1-h(x)^{1-y})$$由於y只有1和0,若是當前的分類是y,那麼就是 h(x)的機率,不是就是另一個。 ###目標函數的化簡 最大似然函數,常規操做,給定了數據集找到符合這個數據集的分佈通常也就是最大似然函數適合了。因此$$L(\theta) = \prod_{i=1}^mP(y_i|x_i;\theta) = \prod_{i=1}^{m}(h(x_i)^{y_i}(1-h(x_i))^{1-y_i})$$ log化:

l(\theta) = \sum_{i=1}^m(y_llogh(x_i)+(1-y_i)log(1-h(x_i)))

因此梯度更新公式:

\theta_j = \theta_j - \alpha\frac{1}{m}\sum_{i=1}^m(h(x_i)-y_i)x_i^j

這個方法就梯度降低,問題來了,爲何要用梯度降低?爲何不能夠直接等於0呢?app

####logistics regression沒有解析解 若是等於0,就有:$$\sum_{n=1}^Nsigmoid(\theta^Tx) = x^Ty$$考察一下兩個特徵兩個樣本的狀況: dom

有三個不一樣的sigmoid函數,兩個式子解不了,由於sigmoid函數不是線性的,若是是線性的,那麼能夠吧 \theta提出來,這樣就有解了。其實若是sigmoid去掉,僅僅把 sigmoid(\theta^Tx) = \theta^Tx那麼就和linear regression同樣了。因此是沒有解析解的,主要的緣由就是由於sigmoid函數是一個非線性的函數。

###當標籤不一樣的時候另外一種函數形式 計算分數函數同樣的:score = W^Tx 以前瞭解的preceptron機器學習

直接把score分數經過一個sign函數便可。0/1錯誤。 linear regression:
線性迴歸就是去掉了sign函數,使其成爲一個線性函數,error function = square logistic regression:
常規操做,就是要找到error function先。按照剛剛的函數分佈能夠獲得:
極大似然函數:
sigmoid函數有一個比較牛逼的性質。$$1-\frac{1}{1+e^{-x}}=\frac{e^{-x}}{1+e^{-x}}=\frac{1}{\frac{1}{e^{-x}}+1} = \frac{1}{1+e^x}$$

1-h(x) = h(-x)$$因此美滋滋,替換一下就OK了:![](https://upload-images.jianshu.io/upload_images/10624272-4015a5c6d66be321.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
![](https://upload-images.jianshu.io/upload_images/10624272-beffb058eadcedb8.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)$P(x_i)$是先驗機率,開始就給定的了,是能夠忽略的。![](https://upload-images.jianshu.io/upload_images/10624272-c318025e7107e9c3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)最大值通常比較難求,加上負號變成一個最小化的問題,化簡一下:
![](https://upload-images.jianshu.io/upload_images/10624272-2a5aca978d122361.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
其實這個就是交叉熵函數,和上面推導出的:![](https://upload-images.jianshu.io/upload_images/10624272-a2574ef56abaf744.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)是一個東西,整合起來了而已,負號提早,因此形式有點不同。最小化error function:
![](https://upload-images.jianshu.io/upload_images/10624272-5fe2fbd0855d042e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
gradient decent,和剛剛的方法是同樣的。![](https://upload-images.jianshu.io/upload_images/10624272-a74f306909b426ec.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
![](https://upload-images.jianshu.io/upload_images/10624272-0b294055fe27ccfb.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
**上面的$\theta(yw^Tx)$能夠看作是-yx的線性加權,要求就是加權和以後爲0,而若是是線性可分的話,則只要$\theta$爲0就能夠了;根據sigmoid函數的特性,爲0就至關因而$-yw^Tx$要 << 0,即$-yw^Tx$ >> 0,這就尷尬了,須要保證所有的yx都同號,都是線性可分的,這樣實際上是很難作到的,因此咱們轉換一個思路,用梯度降低解決。歸根到底,仍是sigmoid函數的非線性。**
###Stochastic Gradient Descent
隨機梯度降低,以往的經驗是所有一塊兒作一次更新,若是計算量很是大,那麼計算複雜度很高,另外若是是作online learning的時候也不方便,由於這個時候數據不是一個betch的過來了,而是幾個幾個的了。![](https://upload-images.jianshu.io/upload_images/10624272-47f84ac4e262039f.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
**優勢:簡單,若是迭代次數夠多的話是能夠比得上average true gradient的效果的。
缺點:迭代的方向會不穩定,可能會左拐右拐的。average true gradient是查找的當前一階導最適合的方向走的,而SGD是直接隨機一個方向走。**
![](https://upload-images.jianshu.io/upload_images/10624272-bc33d418c5f51fb7.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
**他和PLA其實很像,而在理解上面其實也是相似,他們都選取一個點進行調整。而SGD ≈ soft PLA,PLA是錯了以後才糾正,而SGD會看下你錯了多少,錯了越多,意味着你的wx越大,因此糾正的越多,是動態可變的,因此也叫作soft PLA。**
#③線性模型error function的對比
三個比較簡單算法:PLA,linear regression,logistic regression。他們敢於分類的時候:![](https://upload-images.jianshu.io/upload_images/10624272-66b6eea91e573e23.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
![](https://upload-images.jianshu.io/upload_images/10624272-0acdc0785dbf838c.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
**square function對於分類來講其實不太合理的,分類正確了,應該越遠越好纔對,可是square function是越遠錯誤就越大,是不合理的,logistics就更合理了,錯誤的越錯就越大正確的就小,因此linear regression適合迴歸而不是分類。**
能夠看到ce和err0/1是有焦點的,咱們乘上一個數字使他相切:
![](https://upload-images.jianshu.io/upload_images/10624272-b981f3f4ebfe1da2.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
![](https://upload-images.jianshu.io/upload_images/10624272-35d05bfad0246f1e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
![](https://upload-images.jianshu.io/upload_images/10624272-3c161cca90896433.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
根據VC bound的理論:
![](https://upload-images.jianshu.io/upload_images/10624272-e6066908bde64d5c.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
全部logistic regression是能夠做爲分類的,並且他的分類效果要比linear regression好,首先直觀理解錯誤,他比linear regression更合理,其次,他的VC bound比linear regression要小,這就證實了Ein ≈ Eout的機率會更高,泛化能力更強。
#④Nonlinear Transformation
對於線性可分的狀況來講,幾乎是不用對x作什麼預處理就能夠直接使用模型進行分類,可是若是是對於非線性的模型,上面的方法就有點吃力了,他們都是線性分類,直接在model上改進有點困難,因此在數據上進行處理。
![](https://upload-images.jianshu.io/upload_images/10624272-e563d6cc9472c14d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)這種是絕逼找不到一條直線分開的,要完成這種任務就須要找一個非線性的模型分開,好比看起來這就像是一個圓:$h(x) = -x_1^2-x_2^2+0.6$
![](https://upload-images.jianshu.io/upload_images/10624272-af04832ec4f30db0.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
把上面的式子變成咱們認識的形式:$w_1 = -1,w_2=-2,w_0=0.6$
因而決策函數:$h(x) = sign(w_1z_1+w_2z_2+z_0)$
其實就是把x空間映射到了z空間,而後再z空間解決。x裏面是nonlinear的,映射到z可能就會是linear的了,低緯度解決不了的問題拉到高維度解決:![](https://upload-images.jianshu.io/upload_images/10624272-df15bb8913408d08.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
支持向量機也用到了這種思想,核函數就是映射到高維度空間裏面而後進行切片操做。
Nolinear Transformation的方法不止一個:![](https://upload-images.jianshu.io/upload_images/10624272-6534c194f305ef01.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
目前咱們所討論的都是過原點的,若是是不過原點的話,那麼他們的VC dimension就會增長。好比這種$f(x) = (1,x_1^2,x_2^2,x_1x_2,x_1,x_2)$
其實,作法很簡單,利用映射變換的思想,經過映射關係,把x域中的最高階二次的多項式轉換爲z域中的一次向量,也就是從quardratic hypothesis轉換成了perceptrons問題。用z值代替x多項式,其中向量z的個數與x域中x多項式的個數一致(包含常數項)。這樣就能夠在z域中利用線性分類模型進行分類訓練。訓練好的線性模型以後,再將z替換爲x的多項式就能夠了。具體過程以下:
![](https://upload-images.jianshu.io/upload_images/10624272-3b759069367e8339.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
**整個過程就是經過映射關係,換個空間去作線性分類,重點包括兩個:
特徵轉換
訓練線性模型**
### Price of Nonlinear Transform
首先,用十二指腸想都知道:$d_{vc}^{nonlinear} >=d_{vc}^{linear}$
若是是d維的x作二次的擴展,那麼有![](https://upload-images.jianshu.io/upload_images/10624272-a766a755d70f68bf.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)求上界,若是階數更高,假如階數爲Q,對於x是d維,那麼對於z空間就是![](https://upload-images.jianshu.io/upload_images/10624272-835c3e4b819dd22e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)**這種特徵變換會致使計算空間變大,計算複雜度變大。另外,能夠看到隨着Q增大,W也會增大,這樣就致使了VC dimension會增大,而W的秩其實就是VC維,因此,若是Q越大,就會致使泛化能力變差。**
![](https://upload-images.jianshu.io/upload_images/10624272-93a27476af05362a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
接下來討論一下x到z多項式的變換:
一維:$f_0(x) = (1)$
二維:$f_1(x) = (f_0(x),x_1,x_2,...x_d)$
三維:$f_2(x) = (f_1(x),x_1^2,x_1x_2,...x_d^2)$
Q維:$f_Q(x) = (f_{Q-1}(x),x_1^Q,x_1^{Q-1}x_2,...x_d^Q)$
因此這些hypothesis是包含關係的:![](https://upload-images.jianshu.io/upload_images/10624272-787c9850e38a918e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
對應上圖:$d_{vc}(H_1) <= d_{vc}(H_2) <= d_{vc}(H_d)$
![](https://upload-images.jianshu.io/upload_images/10624272-6695e0fe6ed26236.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
![](https://upload-images.jianshu.io/upload_images/10624272-569112078d40a4d7.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
**因此一目瞭然,代價就是$E_{out},E_{in}$之間的差距會愈來愈大,$E_{in}$最後就不能再表明$E_{out}$了。隨着變換多項式的階數增大,雖然逐漸減少,可是model complexity會逐漸增大,形成很大,因此階數不能過高。若是選擇的階數很大,確實能使接近於0,可是泛化能力一般不好,咱們把這種狀況叫作tempting sin。因此,通常最合適的作法是先從低階開始,如先選擇一階hypothesis,看看是否很小,若是足夠小的話就選擇一階,若是大的話,再逐漸增長階數,直到知足要求爲止。也就是說,儘可能選擇低階的hypothes,這樣才能獲得較強的泛化能力。模型複雜度越高出現的泛化能力問題,就是過擬合,在訓練數據上表現很好,Ein = 0,可是在測試數據上就不好,Ein << Eout。**
#⑤Overfitting and Regularization
overfiting,過擬合,就是上面所描訴的狀況了,$E_{in}$和$E_{out}$相差太遠了,局部已經不能再表明全局了,主要緣由就是模型複雜度太大了,VC bound太大,限制不了$E_{out}$。overfitting就是訓練過程當中翻車了,緣由:①太快了,模型複雜度太大。②近視,看的路過短,樣本少。③這路不行,彎彎曲曲的,noise太多,噪音太大。
對應的解決方法其實不少,但主要就是regularization了:![](https://upload-images.jianshu.io/upload_images/10624272-4270fa06fd5f240a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
雖然fitting出來的結果徹底符合了數據點,可是模型自己沒有這麼複雜,因此產生了過擬合。
既然模型太複雜了,那麼簡化一下模型:![](https://upload-images.jianshu.io/upload_images/10624272-885eeb0146001f54.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
**因此過擬合了,咱們能夠簡化複雜度,複雜度的表明係數其實就是VC dimension,也就是W的個數。**好比一個十階的hypothesis:
$$H_{10}(x) = w_0+w_1x+w_2x^2+w_3x^3+w_4 x^4+...w_{10}x^{10}

想簡化模型就只須要減小w的個數便可,好比簡化成2階:H_2(x) = w_0+w_1x+w_2x^2只須要把後面大於3的w都置爲0便可。然而,問題來了,爲何畫蛇添足先要設置成10階再退化回2階呢?首先這是爲了拓展視野,其次,萬一這些個數據不是2階課完成的呢?要知道咱們事先是不能夠知道數據的分佈的。 剛剛是規定了前面的不爲0,如今放寬一下條件,只要3個w不爲0就行了,因而有:\sum_{q=0}^{10}[w_q != 0]<=3這種形式下的hypothesis稱爲H_2^{'},有H_2<=H_2^{'}<=H_{10} 可是這種方法已經被證實是NP-hard問題了,因此尋求一種更簡便的辦法:$$\sum_{q=0}^{10}w^2<=C$$小於某一個constant便可。當C很是大的時候,那就和高階的基本沒有什麼區別了,用這種方法改造一下linear regression:函數

這樣就把W限定在了一個以根號C的一個球形裏面,兩個W纔是一個圓,多個w就是立體的球了。
能夠看到梯度的方向是差很少對準了W_{lin}(最好的W),只要在切線方向有份量,那麼就會沿着切線的方向滑動。可是能夠看到,這梯度的方向只是差很少對準了W_{lin}而不是準確的對齊,由於是直接的求導,你不能夠保證這個式子就是一個凸優化問題,它多是多個凸優化多個山谷的,可能只是看到了比較近的一個山谷,可是大體方向是正確的。因此若是梯度沒有和份量w平行,那麼會一直移動,w,normal能夠看作是w,w^T,梯度就是-△E_{in}負方向嘛,當平行時,按照圖中的推理:△E_{in}+\frac{2\lambda}{N}w = 0△E_{in}就是square error function求導,因此有$$\frac{2}{N}(z^Tzw-z^Ty)+\frac{2\lambda}{N}w=0$$,最後就推導出$$w = (z^Tz+\lambda I)^{-1}z^Ty$$ 這種線性迴歸被當作是origin linear regression的進階版,也叫ridge regression。 上面的公式也能夠直接用拉格朗日乘子法推出來:$$error = E_{in}+\lambda w^Tw$$ w^Tw<=C \frac{1}{C}w^Tw<=1 拉格朗日: L = \frac{1}{N}\sum(x_nw-y_n)^2+\lambda(\frac{1}{C}w^Tw-1)
能夠看到λ越大w越小,對於模型的懲罰也就越大,因此也叫作正則化懲罰項。這種懲罰會是的曲線愈來愈平滑,後面還會講到另外一種regularization。 ###對於regularization的VC 理論解釋 正則化出來事後的linear regression就是ridge regression,根據以前的VC bound理論: E_{out}(w) <= E_{in}(w)+Ω(H),其中 Ω(H)是複雜度, Ω(w)=w^Tw表明的是單個hypothesis的複雜度,而 Ω(H)表明的整個hypothesis set的複雜度,因此 Ω(w)是被包含在 Ω(H)裏面的,因此相對來講 E_{in}(w)+w^Tw < E_{out}(w)+Ω(H),相對來講會和 E_{out}更加接近。
而對於VC dimension,既然w被限制了,那麼ridge的確定比origin的小了。 ###General Regularizers 兩個比較經常使用的: ridge:L2範數,Ω(w) = |w|^2 lasso:L1範數,Ω(w) = |w| ridge推導過了,來看看lasso的:
他的正常方向應該是垂直於邊界的,紅色的sign就是方向,而對於在邊界上,只要sign和△Ein不在一條直線上,那麼在正方形的邊界上就必定有一個相似於剛剛ridge綠色份量的份量存在,如上圖,就會向上方移動,而在邊角點實際上是不可微分的,因此通常結果會彙集在邊角的周圍,因此獲得的是一個稀疏矩陣,一些是0,一些不是零。結果會彙集在頂點周圍,優勢就是計算很快了。 上圖是用直觀的理解來解釋regularization,前面的是用VC demension來解釋,再用數值分析的角度看一下: 好比:方程式①: 5x + 7y = 0.7 7x + 10y = 1 x = 0 , y = 0.1 方程式②: 5x + 7y = 0.69 7x + 10y = 1.01 x = -0.17 y = 0.22 只要有一點微小的擾動,結果就會發生很大的變化,這就是病態矩陣,若是X^TX是病態矩陣,那麼兩次的結果可能會相差很大。是否是病態矩陣能夠用條件數來判斷。用條件數來描述病態矩陣其實仍是太抽象了。奇異矩陣就是不存在逆矩陣的方陣。什麼樣的方陣不存在逆矩陣?首先行列式爲0,天然就牽扯出來非滿秩,特徵值只和爲0。而對於近似奇異矩陣,他的行列式很接近於0,因此\frac{1}{|A|}是一個很大的數字,根據求逆矩陣的公式,逆矩陣是能夠經過伴隨矩陣和行列式求的,因此天然差異就很大了,因此病態矩陣也就是近似於奇異矩陣的矩陣了。那麼知道緣由了,咱們要作的就是遠離奇異矩陣。而事實上,ridge regression的結果:
加上一個對角線的值其實就是遠離奇異矩陣。 最後再看一個圖:
lasso可使得權值衰減到0,很容易能夠和頂點相切,因此會使得權值衰減導0;可是ridge只會減小,而不會衰減導0,因此lasso是能夠用來控制權值的數量的。lasso同上也是知足了拉普拉斯分佈,是一個稀疏矩陣,而ridge是高斯分佈。 ###summary 加入正則項是爲了不過擬合,或解進行某種約束,須要解保持某種特性 ①L1正則能夠保證模型的稀疏性,也就是某些參數等於0,L1正則化是L0正則化的最優凸近似,比L0容易求解,而且也能夠實現稀疏的效果, ②L2正則能夠保證模型的穩定性,也就是參數的值不會太大或過小.L2範數是各參數的平方和再求平方根,咱們讓L2範數的正則項最小,可使W的每一個元素都很小,都接近於0。但與L1範數不同的是,它不會是每一個元素爲0,而只是接近於0。越小的參數說明模型越簡單,越簡單的模型越不容易產生過擬合現象。 ③在實際使用中,若是特徵是高維稀疏的,則使用L1正則;若是特徵是低維稠密的,則使用L2正則。 ④L2不能控制feature的「個數」,可是能防止模型overfit到某個feature上;相反L1是控制feature「個數」的,而且鼓勵模型在少許幾個feature上有較大的權重。 總結一下以前學過的,第十八篇博客VC dimension是機器學習的理論保證:
霍夫丁不等式保證了一個hypothesis發生壞事的機率是很小的,Multi霍夫丁不等式保證了這個hypothesis set對於全部的數據集發生的壞事的機率知足的不等式,VC dimension則保證了這個hypothesis set裏面發生的壞事的機率是很小的,這就保證了泛化能力:Ein ≈ Eout。 以後介紹了三種線性模型(PLA比較簡單,不會再講了):
而對於這三種模型,咱們又給出了三種工具:
Feature Transform:經過低維不可線性可分轉換到高維線性可分來解決Nonlinear的狀況。 Regularization:經過增長正則化懲罰項來解決過擬合的問題。 Validation:用於對模型參數的選擇,第一次選擇:是選擇上面模型。第二次選擇就是對模型參數的選擇了,這就用Validation來帥選。 最後是三個比較經常使用的錦囊妙計:
#⑥logistics regression代碼實現

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns

def predict(w, x):
    h = x * w
    h = sigmoid(h)
    if h > 0.5:
        return int(1)
    else:
        return int(0)

def sigmoid(x):
    return np.longfloat(1.0/(1+np.exp(-x)))

def error_rate(h, label):
    m = np.shape(h)[0]
    sum_err = 0.0
    for i in range(m):
        if h[i, 0] > 0 and (1-h[i, 0]) > 0:
            sum_err += (label[i, 0] * np.log(h[i, 0]) + (1-label[i, 0])*np.log(1-h[i, 0]))
        else:
            sum_err += 0
    return sum_err/m

def lr_train_bgd(feature, label, maxCycle, alpha, df):
    n = np.shape(feature)[1]
    m = np.shape(feature)[0]
    w = np.mat(np.random.rand(n,1))
    i = 0
    while True:
        i += 1
        h = sigmoid(feature * w)
        err = label - h
        if i % 100== 0:
            print('error : ', error_rate(h, label))
            d = 0
            scores = []
            for i in range(m):
                score = predict(w, feature[i])
                scores.append(score)
                if score == label[i]:
                    d += 1
            print('train accuracy : ', (d/m)*100, '%')
            if (d/m)*100 >= 90:
                for i in range(m):
                    if df.iloc[i, 2] == 1:
                        c = 'red'
                    else:
                        c = 'blue'
                    plt.scatter(df.iloc[i, 0], df.iloc[i, 1], c=c)
                x = [i for i in range(0, 10)]
                plt.plot(np.mat(x).T, np.mat((-w[0]-w[1]*x)/w[2]).T, c = 'blue')
                plt.show()
                return

        w += alpha * feature.T * err

def loadData(filename):
    df = pd.read_csv(filename, sep=' ', names=['a', 'b', 'label'])
    n, m = df.shape
    features = []
    labels = []
    for i in range(n):
        feature = []
        feature.append(int(1))
        for j in range(1,m):
            feature.append(df.iloc[i, j])
        if df.iloc[i, m-1] == -1:
            labels.append(0)
        else:
            labels.append(1)
        features.append(feature)

    for i in range(n):
        if df.iloc[i, 2] == 1:
            c = 'red'
        else:
            c = 'blue'
        plt.scatter(df.iloc[i, 0], df.iloc[i, 1], c = c)
    plt.show()
    return np.mat(features), np.mat(labels).T, df

if __name__ == '__main__':
    f, t, df = loadData('../Data/testSet.txt')
    lr_train_bgd(f, t, 10000, 0.001, df)

複製代碼

####Github代碼:github.com/GreenArrow2…工具

相關文章
相關標籤/搜索