连续特征离散化

RT，尤其在logistic regression上，需要把一些连续特征进行离散化处理。离散化除了一些计算方面等等好处，还可以引入非线性特性，也可以很方便的做cross-feature。

连续特征离散化处理有什么好的方法， 有时候为什么不直接归一化？

这里主要说明监督的变换方法；

连续性变量转化成离散型变量大致有两类方法：

（1）卡方检验方法；

（2）信息增益方法；

一： 卡方检验方法

1.1 分裂方法

1.2 合并方法

分裂方法，就是找到一个分裂点看，左右2个区间，在目标值上分布是否有显著差异，有显著差异就分裂，否则就忽略。这个点可以每次找差异最大的点。合并类似，先划分如果很小单元区间，按顺序合并在目标值上分布不显著的相邻区间，直到收敛。

二：信息增益方法

2.1 分裂方法

2.2 合并方法

这个和决策树的学习很类似。分裂方法，就是找到一个分裂点看，左右2个区间，看分裂前后信息增益变化阈值，如果差值超过阈值（正值，分列前-分裂后信息熵），则分裂。每次找差值最大的点做分裂点，直到收敛。合并类似，先划分如果很小单元区间，按顺序合并信息增益小于阈值的相邻区间，直到收敛。

参考文献：

1 ： csdn博客：

x2检验（chi-square test）或称卡方检验

http://www.cnblogs.com/emanlee/archive/2008/10/25/1319569.html

采用信息增益合并方法的连续特征离散化程序：

[python] view plain copy

 

 

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