• 基于信息增益离散化方法
千次阅读
2018-07-31 17:13:26
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 = [float(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
if self.final_bin.__len__() >=5 :
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


更多相关内容
• 针对机器学习领域中的诸多优秀算法只能处理离散属性的特点，提出一种基于词出现和信息增益相结合的多区间连续属性离散化方法（multi-interval discretization based on term presence and information gain，MTPIG）...
• 文章目录离散特征为什么要连续离散化处理的一般过程离散化方法的分类无监督的方法有监督的方法卡方检验（CHI）信息增益法（IG）离散化方法的评价离散化工具sklearn.preprocessing.KBinsDiscretizerpd.cut参考 ...

# 离散特征为什么要连续化

作者：严林

来源：知乎

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

在工业界，很少直接将连续值作为逻辑回归模型的特征输入，而是将连续特征离散化为一系列0、1特征交给逻辑回归模型，这样做的优势有以下几点：

1. 离散特征的增加和减少都很容易，易于模型的快速迭代；

2. 稀疏向量内积乘法运算速度快，计算结果方便存储，容易扩展；

3. 离散化后的特征对异常数据有很强的鲁棒性：比如一个特征是年龄>30是1，否则0。如果特征没有离散化，一个异常数据“年龄300岁”会给模型造成很大的干扰；

4. 逻辑回归属于广义线性模型，表达能力受限；单变量离散化为N个后，每个变量有单独的权重，相当于为模型引入了非线性，能够提升模型表达能力，加大拟合；

5. 离散化后可以进行特征交叉，由M+N个变量变为M*N个变量，进一步引入非线性，提升表达能力；

6. 特征离散化后，模型会更稳定，比如如果对用户年龄离散化，20-30作为一个区间，不会因为一个用户年龄长了一岁就变成一个完全不同的人。当然处于区间相邻处的样本会刚好相反，所以怎么划分区间是门学问；

7. 特征离散化以后，起到了简化了逻辑回归模型的作用，降低了模型过拟合的风险。

李沐曾经说过：模型是使用离散特征还是连续特征，其实是一个“海量离散特征+简单模型” 同 “少量连续特征+复杂模型”的权衡。既可以离散化用线性模型，也可以用连续特征加深度学习。就看是喜欢折腾特征还是折腾模型了。通常来说，前者容易，而且可以n个人一起并行做，有成功经验；后者目前看很赞，能走多远还须拭目以待。

# 离散化处理的一般过程

• 对连续特征值按照某种指定的规则进行排序
• 初步确定连续属性的划分断点
• 按照某种给定的判断标准继续分割断点或合并断点
• 如果第三步得到判断标准的终止条件，则终止整个连续特征离散化的过程，否则继续按第三步执行

# 离散化方法的分类

主要的分类体系有无监督的和有监督的（又分为建立在错误码率、熵值或者统计信息基础上的离散化方法，典型代表是等频、等宽的连续特征离散化方法）、动态的和静态的、全局的和局部的、分列式的（从上至下）和合并式的（从下至上） 、单变量的和多变量的以及直接的和增量式的。

## 无监督的方法

无监督方法都具有的问题就是都需要事先规定划分区间这个参数，常用的方法有分箱法和直观划分，首先来说一下分箱法：

分箱法又分为等宽分箱法和等频分箱法，其实从名字就能看出算法的做法了，前者制定定长的间隔将特征放入不同箱子内，后者根据频率划分箱子，这两种做法都有一定的缺陷。

• 等宽分箱法对异常点比较敏感，比如数据正常范围是30-60，现在出现了一个特征本来是30不小心读取成了300，那么宽度会被拉长，实例就主要集中在前面的箱体中，后面的箱体几乎没有实例，解决的方法主要是设立阈值移除阈值以外的实例。

• 等频分箱法的缺陷是完全按照频率划分会出现实例特征相同却不在同一个箱体内的情况，解决办法也很简单，在划分完成后进行微调就可完成。

• 基于K-Means的聚类分箱方法

直观划分法感觉就没什么技术了，这个算法主要是根据经验和美观，常用的方法划分出来肯定都是34267、64537这样的数，但是人们一般都习惯看到30000、50000这样的数，然后就是加上个人对数据的了解人为划分。

https://blog.csdn.net/u013818406/article/details/70494800

## 有监督的方法

### 1R方法

1R是一种使用分箱的有监督的方法。它把连续的区间分成小的区间，然后再使用类标签对小区间的边界进行调整。每个区间至少包含 6 个实例，除了最后一个区间外，最后一个区间包含所有未被列入其他区间的实例。从第一个实例开始，把前 6 个实例列入第一区间，如果下一个实例与此区间中大多数实例的类标签相同，则把此实例加入区间中，再判定下一个实例按照前述操作能否加入刚才的区间中，否则形成下一个含 6 个实例的新的区间，对下一个实例重复类似的操作，直至结束。然后把区间中的大多数实例的共同类标签作为此区间的类标签，如果相邻区间经过此操作后有相同的类标签，则应把这两个相邻区间合并。

1R离散化方法也是分箱方法，操作仍然比较方便，但又不再需要用户人为指定箱的个数，也克服了无监督的分箱方法的不使用类信息的缺陷，并且能避免把具有相同特征值相同类标签的实例分入不同的小区间中[6]。

### 卡方检验（CHI）

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

χ2表示观察值与理论值之问的偏离程度。计算这种偏离程度的基本思路如下:

• 设A代表某个类别的观察频数，E代表基于H0计算出的期望频数，A与E之差称为残差。

• 显然，残差可以表示某一个类别观察值和理论值的偏离程度，但如果将残差简单相加以表示各类别观察频数与期望频数的差别，则有一定的不足之处。因为残差有正有负，相加后会彼此抵消，总和仍然为0，为此可以将残差平方后求和。

• 另一方面，残差大小是一个相对的概念，相对于期望频数为10时，期望频数为20的残差非常大，但相对于期望频数为1 000时20的残差就很小了。考虑到这一点，人们又将残差平方除以期望频数再求和，以估计观察频数与期望频数的差别。

进行上述操作之后，就得到了常用的χ2统计量，由于它最初是由英国统计学家Karl Pearson在1900年首次提出的，因此也称之为Pearson χ2，其计算公式为

χ 2 = ∑ ( A − E ) 2 E = ∑ i = 1 k ( A i − E i ) 2 E i = ∑ i = 1 k ( A i − n p i ) 2 n p i ( i = 1 , 2 , 3... , k ) \chi^2 =\sum \frac{(A-E)^2}{E} = \sum_{i=1}^k \frac{(A_i-E_i)^2}{E_i} = \sum_{i=1}^k \frac{(A_i-np_i)^2}{np_i} (i=1,2,3...,k)
当n比较大时，χ2统计量近似服从k-1(计算Ei时用到的参数个数)个自由度的卡方分布。

### 信息增益法（IG）

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

# 离散化方法的评价

• 区间的个数：是对模型简洁性的要求
• 离散化所导致的不一致性：离散化后的不一致性不能比离散化之前高。
• 预测准确性：通常通过交叉检验模式建立分叉树来衡量。
• 具有最简单的离散化结果

# 离散化工具

## sklearn.preprocessing.KBinsDiscretizer

Parameters:

n_bins :分桶个数.

encode : {‘onehot’, ‘onehot-dense’, ‘ordinal’}, (default=’onehot’)
分桶后结果的编码方式。

strategy : {‘uniform’, ‘quantile’, ‘kmeans’}, (default=’quantile’)

只支持三种分桶策略,不支持手工给定：

• uniform:每个值作为一个桶
• quantile: 均分，每个桶内的数据量一样
• kmeans: 一维数据聚类
>>> X = [[-2, 1, -4,   -1],
...      [-1, 2, -3, -0.5],
...      [ 0, 3, -2,  0.5],
...      [ 1, 4, -1,    2]]
>>> est = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='uniform')
>>> est.fit(X)
KBinsDiscretizer(...)
>>> Xt = est.transform(X)
>>> Xt
array([[ 0., 0., 0., 0.],
[ 1., 1., 1., 0.],
[ 2., 2., 2., 1.],
[ 2., 2., 2., 2.]])


## pd.cut

适用于数据分割分桶，也适用于将连续特征转化为类别特征，支持将数据等分进各个桶，即KBinsDiscretizer中的quantile方法，也支持手动设定桶区间，主要是用np.linespace实现的。

bins = [0, 4, 10, 30, 45, 99999]
labels = ['Very_Low_Fare', 'Low_Fare', 'Med_Fare', 'High_Fare','Very_High_Fare']
train_orig.Fare[:10]
Out[0]:
0     7.2500
1    71.2833
2     7.9250
3    53.1000
4     8.0500
5     8.4583
6    51.8625
7    21.0750
8    11.1333
9    30.0708
Name: Fare, dtype: float64

pd.cut(train_orig.Fare, bins=bins, labels=labels)[:10]
Out[50]:
0          Low_Fare
1    Very_High_Fare
2          Low_Fare
3    Very_High_Fare
4          Low_Fare
5          Low_Fare
6    Very_High_Fare
7          Med_Fare
8          Med_Fare
9         High_Fare
Name: Fare, dtype: category
Categories (5, object): [High_Fare < Low_Fare < Med_Fare < Very_High_Fare < Very_Low_Fare]


# 参考

展开全文
• ## 连续特征离散化

千次阅读 2017-09-13 13:10:46
RT，尤其在logistic regression上，需要把一些连续特征进行离散化处理。离散化除了一些计算方面等等好处，还可以引入非线性特性，也可以很方便的做cross-feature。 连续特征离散化处理有什么好的方法， 有时候为...

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

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

在特征工程中，特别是logisticregression上，需要把一些连续特征进行离散化处理。离散化除了一些计算方面等等好处，还可以引入非线性特性，也可以很方便的做cross-feature。离散特征的增加和减少都很容易，易于模型的快速迭代。此外，噪声很大的环境中，离散化可以降低特征中包含的噪声，提升特征的表达能力。

连续特征离散化最常用的方法：

（1）划分区间（分箱法）

如1-100岁可以划分为：（0-18）未成年、（18-50）中青年、（50-100）中老年.

这其中包括等距划分、按阶段划分、特殊点划分等。

（2）卡方检验（CHI）

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

χ2表示观察值与理论值之问的偏离程度。计算这种偏离程度的基本思路如下：

(1)设A代表某个类别的观察频数，E代表基于H0计算出的期望频数，A与E之差称为残差

(2)显然，残差可以表示某一个类别观察值和理论值的偏离程度，但如果将残差简单相加以表示各类别观察频数与期望频数的差别，则有一定的不足之处。因为残差有正有负，相加后会彼此抵消，总和仍然为0，为此可以将残差平方后求和

(3)另一方面，残差大小是一个相对的概念，相对于期望频数为10时，期望频数为20的残差非常大，但相对于期望频数为1 000时20的残差就很小了。考虑到这一点，人们又将残差平方除以期望频数再求和，以估计观察频数与期望频数的差别。

进行上述操作之后，就得到了常用的χ2统计量，由于它最初是由英国统计学家Karl Pearson在1900年首次提出的，因此也称之为Pearson χ2，其计算公式为

较大时，χ2统计量近似服从k-1(计算Ei时用到的参数个数)个自由度的卡方分布。

（3）信息增益法（IG）

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

，信息增益为总的熵减去某个分类标准对应的熵。

熵：

条件熵：

V(A)是属性A的值域

S是样本集合

Sv是S种在属性A上值等于v的样本集合

信息增益比率实际在信息增益的基础上，又将其除以一个值，这个值一般被称为为分裂信息量

展开全文
• 特征离散化 机器学习算法预处理的特征离散化包括信息增益方法和其他频率、距离分割方法
• RT，尤其在logistic regression上，需要把一些连续特征进行离散化处理。离散化除了一些计算方面等等好处，还可以引入非线性特性，也可以很方便的做cross-feature。 连续特征离散化处理有什么好的方法， 有时候为什么...
• 连续特征离散化：在什么情况下将连续特征离散化之后可以获得更好的效果？ 题主机器学习大白一个。。最近刚接触CTR预估，发现CTR预估一般都是用LR，而且特征都是离散的。为什么一定要用离散特征呢？这样做的好处...
• 2、离散化特征更容易理解，比如，用户在哪个区间表示高收入和低收入。 3、避免异常值的影响 二、离散化的优势 在机器学习中很少直接将连续值作为逻辑回归的特征输入，而是将连续特征离散化为0，1值，再作为特征输入...
• 比如我们的特征数据在0-100，之间，等宽分成10份，分别为[0-10]，[11-20]，...，[90-100] 假设有个数据值为11，那么其对应的one-hot向量为[0,1,0,0,0,0,0,0,0,0] 等宽分箱法的缺陷：假设有个别特征值过大，那么和...
• 该文介绍了基于离散化方法的T—S模糊控制系统控制器设计的问题。用离散化的方法，将 T—S模糊控制系统转化为一个离散采样系统，并利用离散采样系统的特性，提出了保守性更小的控制器设计方案。避免了T—S...
• s变换到z变换：command：c2d作用：离散化；其中离散化的方法又有很多：前向差分；后向差分；tustin；零极点匹配；脉冲响应；阶跃响应；下面先说一说各种离散方式的特点：前向差分：方法是用一阶前向差分近似替代微分...
• 特征工程中，特别是logistic regression上，需要把一些连续特征进行离散化处理。离散化除了一些计算方面等等好处，还可以引入非线性特性，也可以很方便的做cross-feature。离散特征的增加和减少都很容易，易于模型...
• 离散化背景连续数据经常采用离散化处理之后再放入模型。离散化可以理解为提取特征的过程，比如在LR模型，由于是广义线性模型表达能力有限，因此通过特征离散化来了提高非线性学习能力主要方法等距离散取值范围均匀划...
• 连续特征离散化是采取各种方法将连续的区间划分为小的区间，并将这连续的小区间与离散值关联起来。连续特征离散化的本质是：决定选择多少个分割点和确定分割点的位置。 背景 连续数据经常采用离散化处理之后再放入...
• 首先采用Delta算子离散化的方法将连续时间T-S模糊模型全局离散化，然后，在此离散时间T-S模糊模型的基础上，设计了一个线性状态反馈控制器，最后对整个闭环系统作一次溢出非线性函数运算以保证系统状态的有界性。...
• 使用python语言，实现求特征选择的信息增益，可以同时满足特征中有连续型和离散型属性的情况。 师兄让我做一个特征选择的代码，我在网上找了一下，大部分都是用来求离散型属性的信息益益，但是我的数据是同时...
• 如果想深入研究特征离散化，请直接阅读博文最后的英文文献，以免浪费您的时间！ 一、什么是特征离散化 简单的说，就是把连续特征分段，每一段内的原始连续特征无差别的看成同一个新特征 二、为什么进行离散化 1...
• I . 决策树 分类规则抽取 II . 决策树 过拟合 与 剪枝 ... 连续属性 离散化处理 ( 二分法 | 最优划分点 ) V . 根据 增益率 选择划分属性 VI . 根据 增益率 选择划分属性 计算案例 VII . 决策树 作用 及 优势
• 连续传递函数离散化的方法与原理》由会员分享，可在线阅读，更多相关《连续传递函数离散化的方法与原理(33页珍藏版)》请在人人文库网上搜索。1、数字控制器的模拟化设计目录第一章 模拟化设计基础1第一节 步骤1第...
• 连续传递函数离散化的方法与原理.doc数字控制器的模拟化设计目录第一章 模拟化设计1第一节 步骤1第二节 在MATLAB中离散化3第三节 延时环节的处理5第四节 控制函数分类6第二章 10摘要10比较1第一节 冲击响应不变法...
• 数 字 控 制 器第一章模拟化设计基础数 字 控 制 器第一章模拟化设计基础第一节步骤第二节在MATLAB^离散化 第三节延时e-Ts环节的处理 第四节控制函数分类 第二章离散化算法摘要 比较 第一节 第二节 第三节 第四节 第...
• 关于传递函数的离散化问题 最近思考关于传递函数的离散化问题时，产生了一个误区，在这里记录一下。 当时想到s域到z域的映射时的一个关系式为 $$\sqrt{2} \quad and \quad \sqrt[n]{3}$$ ...
• 在机器学习中，在很多案例中，人们在处理数据的时候，常常把连续特征离散化。那么为什么要用离散特征呢？这么做有什么优势？ 特征离散化 数据离散化是将连续的数据进行分段，使其变为一段段离散化的区间。 连续特征...
• http://www.docin.com/DocinViewer-1404447028-144.swf 5.2.1 连续系统离散化方法 1、反向差分变换法 对于给定的 （5.1） 其微分方程为 ，用反向差分代替微分，得  （5.2） 对（5.2）式
• 一、简介 离散化是通过创建一组跨越变量值范围的连续区间将连续变量转换为离散变量的过程。 1.1 离散化有助于处理异常值和高度偏斜的变量 离散化通过将这些值 与分布的剩余内点值一起放入较低或较高的区间来帮助处理...
• RT，尤其在logistic regression上，需要把一些连续特征进行离散化处理。离散化除了一些计算方面等等好处，还可以引入非线性特性，也可以很方便的做cross-feature。 连续特征离散化处理有什么好的方法， 有时候为...

...