3种特征分箱方法！

转x33g5p2x  于2022-08-17 转载在 其他  
字(3.6k)|赞(0)|评价(0)|浏览(956)

一般在建立分类模型时，当我们进行特征工程的工作经常需要对连续型变量进行离散化的处理，也就是将连续型字段转成离散型字段。

离散化的过程中，连续型变量重新进行了编码。特征离散化后，模型会更稳定，降低了模型过拟合的风险。本文主要介绍3种常见的特征分箱方法：

分箱特点

  1. 连续型变量执行离散化的分箱操作，能够更加简洁地呈现数据信息
  2. 消除特征变量的量纲影响，因为分箱之后都是类别数，例如：0,1,2...
  3. 能够在一定程度上减少异常值的影响，对异常数据有很强的鲁棒性

模拟数据

模拟一份简单的数据和收入INCOME相关

In [1]:

  1. import pandas as pd
  2. import numpy as np

In [2]:

  1. df = pd.DataFrame({"ID":range(10),
  2.                   "INCOME":[0,10,20,150,35,78,50,49,88,14]})
  3. df

sklearn之KBinsDiscretizer类

本文中介绍的3种分箱操作都是基于sklearn中的KBinsDiscretizer类，官网学习地址：

https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.KBinsDiscretizer.html

  1. from sklearn.preprocessing import KBinsDiscretizer
  3. sklearn.preprocessing.KBinsDiscretizer(n_bins=5, 
  4.                                        encode='onehot', 
  5.                                        strategy='quantile', 
  6.                                        dtype=None, 
  7.                                        subsample='warn', 
  8.                                        random_state=None)

全部参数解释：

全部属性信息：

重点解释3个参数的使用：

n_bins

参数n_bins参数上指定需要分箱的个数，默认是5个

strategy

指定不同的分箱策略strategy：KBinsDiscretizer类实现了不同的分箱策略，可以通过参数strategy进行选择：

  • 等宽：uniform 策略使用固定宽度的bins；箱体的宽度一致
  • 等频：quantile 策略在每个特征上使用分位数(quantiles)值以便具有相同填充的bins
  • 聚类：kmeans 策略基于在每个特征上独立执行的k-means聚类过程定义bins。

encode

encode参数表示分箱后的离散字段是否需要进一步进行独热编码或者其他编码处理

KBinsDiscretizer类只能识别列向量，需要将DataFrame的数据进行转化：

In [3]:

  1. income = np.array(df["INCOME"].tolist()).reshape(-1,1)
  2. income

Out[3]:

  1. array([[  0],
  2.        [ 10],
  3.        [ 20],
  4.        [150],
  5.        [ 35],
  6.        [ 78],
  7.        [ 50],
  8.        [ 49],
  9.        [ 88],
  10.        [ 14]])

使用之前先导进来：

In [4]:

  1. from sklearn.preprocessing import KBinsDiscretizer

等宽分箱

所谓的等宽分箱就是将数据分成等宽的几份，比如模拟数据中INCOME的范围是0-150。现在将其等宽分成3份，那么每一份对应的取值范围是：[0,50),[50,100)[100,150]

In [5]:

  1. from sklearn.preprocessing import KBinsDiscretizer
  3. dis = KBinsDiscretizer(n_bins=3,
  4.                        encode="ordinal",
  5.                        strategy="uniform"
  6.                       )
  7. dis

Out[5]:

  1. KBinsDiscretizer(encode='ordinal', n_bins=3, strategy='uniform')

In [6]:

  1. label_uniform = dis.fit_transform(income)  # 转换器
  2. label_uniform

Out[6]:

  1. array([[0.],
  2.        [0.],
  3.        [0.],
  4.        [2.],
  5.        [0.],
  6.        [1.],
  7.        [1.],
  8.        [0.],
  9.        [1.],
  10.        [0.]])

等宽分箱的边界查看：

In [7]:

  1. dis.bin_edges_

Out[7]:

  1. array([array([  0.,  50., 100., 150.])], dtype=object)

In [8]:

  1. dis.n_bins

Out[8]:

  1. 3

等频分箱

等频分箱指的是每个区间内包含的取值个数是相同的，和等宽分箱的区别：

  • 等频分箱：每个区间内包括的值一样多，pd.qcut
  • 等宽分箱：每两区间之间的距离是一样的，pd.cut

在实施等频分箱之前，我们需要先对数据进行升序排列，然后取中间值进行分箱

In [9]:

  1. # 1、先排序
  2. sort_df = sorted(df["INCOME"])
  3. sort_df

Out[9]:

  1. [0, 10, 14, 20, 35, 49, 50, 78, 88, 150]

分成2个类别

In [10]:

  1. # 2、中间值：35和49的均值
  2. (35 + 49) / 2

Out[10]:

  1. 42.0

下面我们以42作为等频分箱的依据：

In [11]:

  1. dis = KBinsDiscretizer(n_bins=2,
  2.                        encode="ordinal",
  3.                        strategy="quantile"
  4.                       )
  6. dis.fit_transform(income)  # 转换器

Out[11]:

  1. array([[0.],
  2.        [0.],
  3.        [0.],
  4.        [1.],
  5.        [0.],
  6.        [1.],
  7.        [1.],
  8.        [1.],
  9.        [1.],
  10.        [0.]])

In [12]:

  1. dis.bin_edges_

Out[12]:

  1. array([array([  0.,  42., 150.])], dtype=object)

分成3个类别

总共是10个元素，分成3个类，10/3=3...1，前面两个3个元素，最后一个是4个元素，即最后一个箱体会包含余数部分的元素：

In [13]:

  1. dis = KBinsDiscretizer(n_bins=3,
  2.                        encode="ordinal",
  3.                        strategy="quantile"
  4.                       )
  6. label_quantile = dis.fit_transform(income)  # 转换器
  7. label_quantile

Out[13]:

  1. array([[0.],
  2.        [0.],
  3.        [1.],
  4.        [2.],
  5.        [1.],
  6.        [2.],
  7.        [2.],
  8.        [1.],
  9.        [2.],
  10.        [0.]])

In [14]:

  1. dis.bin_edges_  # 分箱边界

Out[14]:

  1. array([array([  0.,  20.,  50., 150.])], dtype=object)

In [15]:

  1. sort_df  # 排序后的数据

Out[15]:

  1. [0, 10, 14, 20, 35, 49, 50, 78, 88, 150]

聚类分箱

聚类分箱指的是先对连续型变量进行聚类，然后所属样本的类别作为标识来代替原来的数值。

In [16]:

  1. from sklearn import cluster

In [17]:

  1. kmeans = cluster.KMeans(n_clusters=3)
  3. kmeans.fit(income)

Out[17]:

  1. KMeans(n_clusters=3)

聚类完成后查看每个样本所属的类别：

In [18]:

  1. kmeans.labels_

Out[18]:

  1. array([1, 1, 1, 2, 1, 0, 0, 0, 0, 1], dtype=int32)

使用KBinsDiscretizer来实施聚类分箱：

In [19]:

  1. dis = KBinsDiscretizer(n_bins=3,
  2.                        encode="ordinal",
  3.                        strategy="kmeans"
  4.                       )
  6. label_kmeans = dis.fit_transform(income)  # 转换器
  7. label_kmeans

Out[19]:

  1. array([[0.],
  2.        [0.],
  3.        [0.],
  4.        [2.],
  5.        [0.],
  6.        [1.],
  7.        [0.],
  8.        [0.],
  9.        [1.],
  10.        [0.]])

In [20]:

  1. dis.bin_edges_  # 分箱边界

Out[20]:

  1. array([array([  0.        ,  54.21428571, 116.5       , 150.        ])],
  2.       dtype=object)

3种方法对比

In [21]:

  1. df["label_uniform"] = label_uniform
  2. df["label_quantile"] = label_quantile
  3. df["label_kmeans"] = label_kmeans
  5. df

参考

  • 特征离散化（分箱）综述：https://zhuanlan.zhihu.com/p/68865422
  • 书籍《特征工程入门与实践》
  • sklearn官网

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/junhongzhang/article/details/126239109

内容来源于网络，如有侵权，请联系作者删除！

机器学习python数据分析大数据聚类

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com