RT，尤其在logistic regression上，需要把一些連續特徵進行離散化處理。離散化除了一些計算方面等等好處，還可以引入非線性特性，也可以很方便的做cross-feature。

連續特徵離散化處理有什麼好的方法， 有時候為什麼不直接歸一化？

這裡主要說明監督的變換方法；

連續性變數轉化成離散型變數大致有兩類方法：

（1）卡方檢驗方法；

（2）資訊增益方法；

一： 卡方檢驗方法

1.1 分裂方法

1.2 合併方法

分裂方法，就是找到一個分裂點看，左右2個區間，在目標值上分佈是否有顯著差異，有顯著差異就分裂，否則就忽略。這個點可以每次找差異最大的點。合併類似，先劃分如果很小單元區間，按順序合併在目標值上分佈不顯著的相鄰區間，直到收斂。

二：資訊增益方法

2.1 分裂方法

2.2 合併方法

參考文獻：

1 ： csdn部落格：

採用資訊增益合併方法的連續特徵離散化程式：

1. import numpy as np  
2. class
    Feature_Discretization(object):  
3.     def __init__(self):  
4.         self.min_interval = 1
5.         self.min_epos = 0.05
6.         self.final_bin = []  
7.     def fit(self, x, y, min_interval = 1):  
8.         self.min_interval = min_interval  
9.         x = np.floor(x)  
10.         x = np.int32(x)  
11.         min_val = np.min(x)  
12.         bin_dict = {}  
13.         bin_li = []  
14.         for i in range(len(x)):  
15.             pos = (x[i] - min_val)/min_interval * min_interval  + min_val  
16.             target = y[i]  
17.             bin_dict.setdefault(pos,[0,0])             
18.             if target == 1:  
19.                 bin_dict[pos][0] += 1
20.             else:  
21.                 bin_dict[pos][1] += 1
22.         for key ,val in bin_dict.iteritems():  
23.             t = [key]  
24.             t.extend(val)  
25.             bin_li.append(t)  
26.         bin_li.sort(cmp=None, key=lambda x : x[0], reverse=False)  
27.         print bin_li  
28.         L_index = 0
29.         R_index = 1
30.         self.final_bin.append(bin_li[L_index][0])  
31.         whileTrue:             
32.             L = bin_li[L_index]              
33.             R = bin_li[R_index]  
34.             # using infomation gain;
35.             p1 =  L[1]/ (L[1] + L[2] + 0.0)  
36.             p0 =  L[2]/ (L[1] + L[2] + 0.0)  
37.             if p1 <= 1e-5or p0 <= 1e-5:  
38.                 LGain = 0
39.             else:  
40.                 LGain = -p1*np.log(p1) - p0 * np.log(p0)  
41.             p1 =  R[1]/ (R[1] + R[2] + 0.0)  
42.             p0 =  R[2]/ (R[1] + R[2] + 0.0)  
43.             if p1 <= 1e-5or p0 <= 1e-5:  
44.                 RGain = 0
45.             else:  
46.                 RGain = -p1*np.log(p1) - p0 * np.log(p0)  
47.             p1 = (L[1] + R[1])/ (L[1] + L[2] + R[1] + R[2] + 0.0)  
48.             p0 = (L[2] + R[2])/ (L[1] + L[2] + R[1] + R[2] + 0.0)  
49.             if p1 <= 1e-5or p0 <= 1e-5:  
50.                 ALLGain = 0
51.             else:  
52.                 ALLGain = -p1*np.log(p1) - p0 * np.log(p0)  
53.             if np.absolute(ALLGain - LGain - RGain) <= self.min_epos:  
54.                 # concat the interval;
55.                 bin_li[L_index][1] += R[1]  
56.                 bin_li[L_index][2] += R[2]  
57.                 R_index += 1
58.             else:                  
59.                 L_index = R_index  
60.                 R_index = L_index + 1
61.                 self.final_bin.append(bin_li[L_index][0])  
62.             if R_index >= len(bin_li):  
63.                 break
64.         print'feature bin:',self.final_bin  
65.     def transform(self,x):  
66.         res = []  
67.         for e in x:  
68.             index = self.get_Discretization_index(self.final_bin, e)  
69.             res.append(index)  
70.         res = np.asarray(res)  
71.         return res  
72.     def get_Discretization_index(self ,Discretization_vals, val ):     
73.         index = -1
74.         for i in range(len(Discretization_vals)):  
75.             e = Discretization_vals[i]  
76.             if val <= e:  
77.                 index = i              
78.                 break
79.         return index