在工業界，很少直接將連續值作為邏輯迴歸模型的特徵輸入，而是將連續特徵離散化為一系列0、1特徵交給邏輯迴歸模型，這樣做的優勢有以下幾點：

0. 離散特徵的增加和減少都很容易，易於模型的快速迭代；

1. 稀疏向量內積乘法運算速度快，計算結果方便儲存，容易擴充套件；

2. 離散化後的特徵對異常資料有很強的魯棒性：比如一個特徵是年齡>30是1，否則0。如果特徵沒有離散化，一個異常資料“年齡300歲”會給模型造成很大的干擾；

3. 邏輯迴歸屬於廣義線性模型，表達能力受限；單變數離散化為N個後，每個變數有單獨的權重，相當於為模型引入了非線性，能夠提升模型表達能力，加大擬合；

4. 離散化後可以進行特徵交叉，由M+N個變數變為M*N個變數，進一步引入非線性，提升表達能力；

5. 特徵離散化後，模型會更穩定，比如如果對使用者年齡離散化，20-30作為一個區間，不會因為一個使用者年齡長了一歲就變成一個完全不同的人。當然處於區間相鄰處的樣本會剛好相反，所以怎麼劃分區間是門學問；

6. 特徵離散化以後，起到了簡化了邏輯迴歸模型的作用，降低了模型過擬合的風險。

李沐曾經說過：模型是使用離散特徵還是連續特徵，其實是一個“海量離散特徵+簡單模型” 同 “少量連續特徵+複雜模型”的權衡。既可以離散化用線性模型，也可以用連續特徵加深度學習。就看是喜歡折騰特徵還是折騰模型了。通常來說，前者容易，而且可以n個人一起並行做，有成功經驗；後者目前看很贊，能走多遠還須拭目以待。

查看了一些連續特徵離散化的綜述論文後我選擇了一些方法做說明，連續特徵離散化主要分為有監督方法與無監督方法

1.無監督方法

無監督方法都具有的問題就是都需要認為規定劃分區間這個引數，常用的方法有分箱法和直觀劃分，首先來說一下分箱法：

分箱法又分為等寬分箱法和等頻分箱法，其實從名字就能看出演算法的做法了，前者制定定長的間隔將特徵放入不同箱子內，後者根據頻率劃分箱子，這兩種做法都有一定的缺陷。等寬分箱法對異常點比較敏感，比如資料正常範圍是30-60，現在出現了一個特徵本來是30不小心讀取成了300，那麼寬度會被拉長，例項就主要集中在前面的箱體中，後面的箱體幾乎沒有例項，解決的方法主要是設立閾值移除閾值以外的例項。等頻分箱法的缺陷是完全按照頻率劃分會出現例項特徵相同卻不在同一個箱體內的情況，解決辦法也很簡單，在劃分完成後進行微調就可完成。

直觀劃分法感覺就沒什麼技術了，這個演算法主要是根據經驗和美觀，常用的方法劃分出來肯定都是34267、64537這樣的數，但是人們一般都習慣看到30000、50000這樣的數，然後就是加上個人對資料的瞭解人為劃分。

個人感覺無監督方法的連續特徵離散化並不是很靠譜，原因就是不知道設計的目的單純考慮離散化對結果是更好還是更差這個不確定性太大了。

2.有監督方法

1R方法：這個方法是分箱法的有監督版本，把前6個例項放入箱子中，然後後面例項放入箱子時，對比當前例項標籤與箱子中大部分例項標籤是否相同，如果相同放入，如果不相同，那麼形成下一個6例項的新箱子，等到最後全部放入箱子中，將箱子中大多數例項標籤作為箱子的標籤，再將標籤相同的箱子合併

基於卡方的離散方法：首先將數值特徵的每個不同值看做一個區間對每對相鄰區間計算卡方統計量，如果大於閾值就合併，遞迴進行直到找不到卡方統計大於閾值的時候停止

卡方計算方法 http://www.cnblogs.com/emanlee/archive/2008/10/25/1319569.html

基於熵的離散方法：其實就是照搬了決策樹的思路，使用合成的方法或者分裂的方法根據熵計算和閾值判定來決定合成或分裂，上一段合成的程式碼

import numpy as np  
  
  
class Feature_Discretization(object):  
      
    def __init__(self):  
          
        self.min_interval = 1   #最小間隔
        self.min_epos = 0.05    #資訊增益閾值
        self.final_bin = []     #最終邊界
          
      
    def fit(self, x, y, min_interval = 1):  
        self.min_interval = min_interval  
        x = np.floor(x)  
        x = np.int32(x)  
        min_val = np.min(x)  
        bin_dict = {}  
        bin_li = []  
        for i in range(len(x)):  
            pos = (x[i] - min_val)/min_interval * min_interval  + min_val  
            target = y[i]  
            bin_dict.setdefault(pos,[0,0])             
            if target == 1:  
                bin_dict[pos][0] += 1                  
            else:  
                bin_dict[pos][1] += 1      #標籤one-hot的操作
          
        for key ,val in bin_dict.iteritems():  
            t = [key]  
            t.extend(val)  
            bin_li.append(t)  
          
        bin_li.sort(cmp=None, key=lambda x : x[0], reverse=False)  
        print bin_li  
              
       
        L_index = 0   
        R_index = 1  
        self.final_bin.append(bin_li[L_index][0])  
        while True:             
            L = bin_li[L_index]              
            R = bin_li[R_index]  
            # using infomation gain;  
            p1 =  L[1]/ (L[1] + L[2] + 0.0)  
            p0 =  L[2]/ (L[1] + L[2] + 0.0)  
              
            if p1 <= 1e-5 or p0 <= 1e-5:  
                LGain = 0   
            else:  
                LGain = -p1*np.log(p1) - p0 * np.log(p0)  
              
            p1 =  R[1]/ (R[1] + R[2] + 0.0)  
            p0 =  R[2]/ (R[1] + R[2] + 0.0)  
            if p1 <= 1e-5 or p0 <= 1e-5:  
                RGain = 0   
            else:  
                RGain = -p1*np.log(p1) - p0 * np.log(p0)  
              
            p1 = (L[1] + R[1])/ (L[1] + L[2] + R[1] + R[2] + 0.0)  
            p0 = (L[2] + R[2])/ (L[1] + L[2] + R[1] + R[2] + 0.0)  
              
            if p1 <= 1e-5 or p0 <= 1e-5:  
                ALLGain = 0   
            else:  
                ALLGain = -p1*np.log(p1) - p0 * np.log(p0)  
              
            if np.absolute(ALLGain - LGain - RGain) <= self.min_epos:  #根據資訊增益判定是否合成
                # concat the interval;  
                bin_li[L_index][1] += R[1]  
                bin_li[L_index][2] += R[2]  
                R_index += 1  
              
            else:                  
                L_index = R_index  
                R_index = L_index + 1  
                self.final_bin.append(bin_li[L_index][0])  
              
            if R_index >= len(bin_li):  
                break  
          
        print 'feature bin:',self.final_bin  
          
      
    def transform(self,x):  
        res = []  
        for e in x:  
            index = self.get_Discretization_index(self.final_bin, e)  
            res.append(index)  
          
        res = np.asarray(res)  
        return res  
      
    def get_Discretization_index(self ,Discretization_vals, val ):     
        index = -1  
        for i in range(len(Discretization_vals)):  
            e = Discretization_vals[i]  
            if val <= e:  
                index = i              
                break  
                      
        return index