连续特征离散化和归一化

原文：http://blog.csdn.net/hero_fantao/article/details/34533533

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

 

2. 论文：连续值的离散化. 许文烈. 成均馆大学。http://stat.skku.ac.kr/myhuh/homepage/specialLectures/SDULecture(Chinese).pdf

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

 

 

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