邏輯迴歸

　　邏輯迴歸其實是一個分類演算法而不是迴歸演算法。通常是利用已知的自變數來預測一個離散型因變數的值（像二進位制值0/1，是/否，真/假）。簡單來說，它就是通過擬合一個邏輯函式（logit fuction）來預測一個事件發生的概率。所以它預測的是一個概率值，自然，它的輸出值應該在0到1之間。

此時可以看看一個部落格，推導公式：http://www.cnblogs.com/daguankele/p/6549891.html 

它的核心思想是，如果線性迴歸的結果輸出是一個連續值，而值的範圍是無法限定的，那我們有沒有辦法把這個結果值對映為可以幫助我們判斷的結果呢。而如果輸出結果是 (0,1) 的一個概率值，這個問題就很清楚了。我們在數學上找了一圈，還真就找著這樣一個簡單的函數了，就是很神奇的sigmoid函式(如下)：

    如果把sigmoid函式影象畫出來，是如下的樣子：

　　優點：計算代價不高，易於理解和實現 
　　缺點：容易欠擬合，分類精度可能不高 
　　適用資料型別：數值型和標稱型資料

　　我們都知道邏輯迴歸是和Sigmod函式一起的，為了實現邏輯迴歸分類器，我們可以在每一個特徵上都乘以一個迴歸係數，然後將所有的結果值相加，將總和代入S函式，進而得到一個範圍在0~1之間的數值。任何大於0.5的資料被分人1類，小於0.5被歸為0類。 
　　而現在有了分類器的函數了，那麼上面提到的最佳迴歸係數怎麼求呢？這裡就出現了基於最優化方法的最佳迴歸係數的確定。 
　　 
　　梯度上升法：要找到某函式的最大值，最好的方法就是沿著該函式的梯度方向探尋。梯度上升法用來求函式的最大值

梯度上升法虛擬碼：

//每個迴歸係數初始化為1
//重複R次：
    //計算整個資料集的梯度
    //使用alpha*gradient更新迴歸係數的向量
    //返回迴歸係數

演算法思想：

1、訓練

1.1、初始化權重：

1.2、載入資料；

1.3、計算hypothesis

1.4、計算Loss

1.5、計算損失函式J（theta）：如果明白變化可以看看極大似然推導公式

1.6、想要最小化損失函式minJ（theta），更新theta（梯度下降法）

即：倒數求解可以私下導一導

2、測試：

練習程式碼：

#! /usr/bin/python 
# -*- coding: utf-8 -*-

import os 
import string 
import sys
import math


class LogisticRegression :
    def __init__ ( self ) :
        self.__X = []   #特徵集合
        self.__Y = []    #標籤
        self.__theta = []  #權重
        self.__LEARNING_RATE = 7   #學習率
        self.__FEATURE_CNT = 1 + 2   #特徵數
        self.__load_training_data ()  #載入資料
        self.__SAMPLE_CNT = len ( self.__Y )   #樣本數
        self.__feature_scaling ()   #特徵縮放

        for idx in range ( 0, self.__FEATURE_CNT ) :
            self.__theta.append(0)

    def __load_training_data(self) :
        fp = open ( "testSet.txt", "r" )
        for line in fp.readlines() :
            (x1, x2,y) = line.strip('\r\n').split ( '\t' )
            self.__X.append ( [1, float(x1), float(x2)] )
            self.__Y.append(float(y))
        fp.close()        

    def __feature_scaling(self) :
        max_value = []
        min_value = []
        for fidx in range ( 0, self.__FEATURE_CNT ) :
            max_value.append(0)
            min_value.append(100)

        for idx in range ( 0, self.__SAMPLE_CNT) :
            for fidx in range ( 1, self.__FEATURE_CNT ) :
                if max_value[fidx] < self.__X[idx][fidx] :
                    max_value[fidx] = self.__X[idx][fidx]
                if min_value[fidx] > self.__X[idx][fidx] :
                    min_value[fidx] = self.__X[idx][fidx]
        for idx in range ( 0, self.__SAMPLE_CNT) :
            x = self.__X[idx]
            for fidx in range ( 1, self.__FEATURE_CNT ) :
                self.__X[idx][fidx] = ( x[fidx] - min_value[fidx] ) / ( max_value[fidx] - min_value[fidx] )  


    def batch_learning_alogrithm (self) :
        last_loss = 0
        for  itr in range ( 1, 100000 ) :
            #1、訓練資料
            self.__training ()
            loss = self.__get_loss ()
            sys.stdout.write ( "After %s iteratorion loss = %lf\n" % (itr, loss) )

            if math.fabs ( loss - last_loss)  <= 0.01 :
                break;
            last_loss = loss

        sys.stdout.write ( "The coef of the logistic model :\n")
        for idx in range ( 0, self.__FEATURE_CNT ) :
            sys.stdout.write ( "theta[%d] = %lf\n" % ( idx, self.__theta[idx]) )

    def __training (self) :
        #初始化權重為[0 0 0]
        weight = []
        for idx in range ( 0, self.__FEATURE_CNT ) :
            weight.append(0) 
    
        """計算loss"""
        for idx in range ( 0, self.__SAMPLE_CNT) :
            x = self.__X[idx]
            y = self.__Y[idx]
            h = self.__sigmoid( x ) 
            for fidx in range ( 0, self.__FEATURE_CNT ) :
                weight[fidx] +=  ( h - y ) * x[fidx]

        """更新權重"""
        for idx in range ( 0, self.__FEATURE_CNT ) :
            self.__theta[idx] -= self.__LEARNING_RATE * weight[idx] / self.__SAMPLE_CNT

    def __sigmoid ( self, x ) :
        logit = 0
        for idx in range ( 0, self.__FEATURE_CNT):
            logit += self.__theta[idx] * x[idx]
        return 1.0 / ( 1.0 + math.exp ( -logit ) )
        
    def __get_loss (self ) :
        loss = 0
        for idx in range ( 0, self.__SAMPLE_CNT) :
            x = self.__X[idx]
            y = self.__Y[idx]
            h = self.__sigmoid( x ) 
            loss += y * math.log (h) + ( 1 - y ) * math.log ( 1 - h )
        return loss
 

    def test ( self ) :
        wrong_ans = 0
        for idx in range ( 0, self.__SAMPLE_CNT) :
            x = self.__X[idx]
            y = self.__Y[idx]
            h = self.__sigmoid( x ) 
            check = 0
            if y > 0.5 and h< 0.5  :
                check = -1
            if y < 0.5 and h > 0.5 :
                check = -1
            sys.stdout.write ( "樣本 %d : 真值 = %.2lf, 預測 = %.2lf check = %d\n" % ( idx, y, h, check ))
            wrong_ans -= check    
        print "錯誤 = %d" % wrong_ans
            
if __name__ == "__main__" :
    lr = LogisticRegression()
    lr.batch_learning_alogrithm ()
    lr.test()
 

補充：

對於資料輸入一般講資料和標籤分開:

 def __load_training_data(self):
        fp = open("./ex4x.dat", "r")
        for line in fp.readlines():
            (x1, x2) = line.strip('\r\n').split()
            self.__X.append([1, float(x1), float(x2)])
        fp.close()

        fp = open("./ex4y.dat", "r")
        for line in fp.readlines():
            y = line.strip('\r\n\t')
            self.__Y.append(float(y))
        fp.close()

testSet.txt

-0.017612	14.053064	0
-1.395634	4.662541	1
-0.752157	6.538620	0
-1.322371	7.152853	0
0.423363	11.054677	0
0.406704	7.067335	1
0.667394	12.741452	0
-2.460150	6.866805	1
0.569411	9.548755	0
-0.026632	10.427743	0
0.850433	6.920334	1
1.347183	13.175500	0
1.176813	3.167020	1
-1.781871	9.097953	0
-0.566606	5.749003	1
0.931635	1.589505	1
-0.024205	6.151823	1
-0.036453	2.690988	1
-0.196949	0.444165	1
1.014459	5.754399	1
1.985298	3.230619	1
-1.693453	-0.557540	1
-0.576525	11.778922	0
-0.346811	-1.678730	1
-2.124484	2.672471	1
1.217916	9.597015	0
-0.733928	9.098687	0
-3.642001	-1.618087	1
0.315985	3.523953	1
1.416614	9.619232	0
-0.386323	3.989286	1
0.556921	8.294984	1
1.224863	11.587360	0
-1.347803	-2.406051	1
1.196604	4.951851	1
0.275221	9.543647	0
0.470575	9.332488	0
-1.889567	9.542662	0
-1.527893	12.150579	0
-1.185247	11.309318	0
-0.445678	3.297303	1
1.042222	6.105155	1
-0.618787	10.320986	0
1.152083	0.548467	1
0.828534	2.676045	1
-1.237728	10.549033	0
-0.683565	-2.166125	1
0.229456	5.921938	1
-0.959885	11.555336	0
0.492911	10.993324	0
0.184992	8.721488	0
-0.355715	10.325976	0
-0.397822	8.058397	0
0.824839	13.730343	0
1.507278	5.027866	1
0.099671	6.835839	1
-0.344008	10.717485	0
1.785928	7.718645	1
-0.918801	11.560217	0
-0.364009	4.747300	1
-0.841722	4.119083	1
0.490426	1.960539	1
-0.007194	9.075792	0
0.356107	12.447863	0
0.342578	12.281162	0
-0.810823	-1.466018	1
2.530777	6.476801	1
1.296683	11.607559	0
0.475487	12.040035	0
-0.783277	11.009725	0
0.074798	11.023650	0
-1.337472	0.468339	1
-0.102781	13.763651	0
-0.147324	2.874846	1
0.518389	9.887035	0
1.015399	7.571882	0
-1.658086	-0.027255	1
1.319944	2.171228	1
2.056216	5.019981	1
-0.851633	4.375691	1
-1.510047	6.061992	0
-1.076637	-3.181888	1
1.821096	10.283990	0
3.010150	8.401766	1
-1.099458	1.688274	1
-0.834872	-1.733869	1
-0.846637	3.849075	1
1.400102	12.628781	0
1.752842	5.468166	1
0.078557	0.059736	1
0.089392	-0.715300	1
1.825662	12.693808	0
0.197445	9.744638	0
0.126117	0.922311	1
-0.679797	1.220530	1
0.677983	2.556666	1
0.761349	10.693862	0
-2.168791	0.143632	1
1.388610	9.341997	0
0.317029	14.739025	0