離散データのPython実装と

まず、原則として
、それは離散間隔の期間となるように、（データパケットと呼ばれる）の離散データは、連続データパケットを指します。

：個別のカテゴリ属性かどうかを検討する方法によれば、離散化アルゴリズムを分けることができ教師アルゴリズムと教師なしアルゴリズム。これは、教師アルゴリズムは、情報カテゴリ属性を活かし起因して、それは、より高い分類精度を得ることができることが判明しました。

使用されるデータ離散化手法：

パケット幅
そして、他の周波数ブロック
単変量グループ
パケットベースの情報エントロピー

方法は、データをソートするために事前に必要な離散的なデータのために使用され、昇順にソートされたデータを離散化されているものとします。

図1は、パケット幅
原理：固定幅取得したパケットの数、変数に割り当てられた各グループの幅は等しいです。

等：必要な3つのグループに分け、離散配列[1、7、12、12、22、30、34、38、46]であることがあり、

だから $幅= \ FRAC {X_ {最大} - X_ {分}} {N}$ 、即ち、幅=（46--1）/ 3 = 15

範囲をグループ化した後の結果：[1,16]、（16、31]、（31、46]、最初のパケット間隔を取ることは、完全に閉じられています

グループ化結果：1、7、12、12]、[22、30]、[34、38、46]

図2に示すように、周波数ブロック等
原理：他の周波数ブロックも呼ばれる分位数のパケット、すなわち、パケット、要素の数は、各パケットに対して同じです。

等：必要な3つのグループに分け、離散配列[1、7、12、12、22、30、34、38、46]であることがあり、

だから $NUM = FRAC \ {len_のARR {{N}}}$ 、すなわち、各グループ内の要素の数= 9/3 = 3

グルーピング結果：[1、7、12]、[12、22、30]、[34、38、46]

3、単変量グループ化の
原則：単変量グループ、またランクグループとして知られています。降順または昇順のすべての要素、それはランクである要素が同じグループに入ってくるように、ランキング結果を命じました。

例えば：なるように離散配列[1、7、12、12、22、30、34、38、46]があり、

結果をグループ化する：[1]、[7]、[12、12]、[22]、[30]、[34]、[38]、[46]

4、パケットベースの情報エントロピーの
概念：

（1）情報の量を

シャノンは、情報がランダムなものの不確実性を排除するために使用されていることを信じています。これは、不確実性のこのニュース除去度を見て情報量の尺度です。

情報のサイズと量の確率が入射に反比例します。これは次のように定式化することができます。 $L（X）= -log_ {2} P（X）$

ここで、P（x）は、xが発生する確率を表します。

（2）エントロピー

結果が発生する可能性のある情報の量から出てくる前に、エントロピーは、それが期待されている - それは、必要な情報の量によって引き起こされる可能なすべての事件で、確率変数のすべての可能な値を検討してください。

それは次のように表すことができます。 $E（x）= - \ sum_ {i = 1} ^ {n}はP（X_I）LOG_ {2} P（X_I）$

確率変数データのすべての可能な値に応じて総エントロピーエントロピーEは、すべてのイベントの加重平均で割りました。 $E = \ sum_ {i = 1} ^ {K} w_iE_i$

式では、 $w_i = \ FRAC {M_I} {M}$ それは可能な値の数が発生され、発生する全ての値の合計数であり、x番目のイベントの割合が発生しています。

エントロピーはサンプル収集の不確実性を示しています。エントロピーが大きいほど、サンプル中の不確実性が大きくなります。

したがって、情報エントロピーデータパケットに基づいて、特定のアプローチです。

Aのすべての値について昇順にソートされます。
分割されたデータセットの分離のエントロピー点を最小化するように各トラバースの属性の値は、プロパティの値は,, 2つのセクションに分かれています。
閾値は、エントロピー分割より大きいとステップ2で分割されたデータパケット、再帰的な、指定された数より少なく設定されている場合。

要約：

上記の方法をグループ化、幅及び他の周波数ブロックのグループ化は、実装が簡単であるが、人為的に指定された数のパケットを必要とします。

幅パケットの欠点：離散値に敏感では、属性値が不均一各部に分配されます。要素間隔の多数のいくつかは、いくつかの少ない、簡単に傾きデータにつながります。

幅及び他の欠点を回避し、他のパケット・周波数ブロックが、このような「12」要素の例として、異なるグループに要素を希望することもできます。

第二に、離散的な実現のデータ情報エントロピーに基づいて、

import numpy as np
import math
 
class DiscreateByEntropy:
    def __init__(self, group, threshold):
        self.maxGroup = group # 最大分组数
        self.minInfoThreshold = threshold # 停止划分的最小熵
        self.result = dict()
 
    def loadData(self):
        data = np.array(
            [
                [56,1],[87,1],[129,0],[23,0],[342,1],
                [641,1],[63,0],[2764,1],[2323,0],[453,1],
                [10,1],[9,0],[88,1],[222,0],[97,0],
                [2398,1],[592,1],[561,1],[764,0],[121,1]
            ]
        )
        return data
 
    # 计算按照数据指定数据分组后的Shannon熵
    def calEntropy(self, data):
        numData = len(data)
        labelCounts = {}
        for feature in data:
            # 获得标签,这里只有0或者1
            oneLabel = feature[-1]
            # 设置字典中，标签的默认值
            if labelCounts.get(oneLabel,-1) == -1:
                labelCounts[oneLabel] = 0
            # 统计同类标签的数量
            labelCounts[oneLabel] += 1
        shannoEnt = 0.0
        for key in labelCounts:
            # 同类标签出现的概率,某一标签出现的次数除以所有标签的数量
            prob = float(labelCounts[key])/numData
            # 求熵，以2为底，取对数
            shannoEnt -= prob * math.log2(prob)
        return shannoEnt
 
    # 按照调和信息熵最小化原则分割数据集
    def split(self, data):
        # inf为正无穷
        minEntropy = np.inf
        # 记录最终分割的索引
        index = -1
        # 按照第一列对数据进行排序
        sortData = data[np.argsort(data[:,0])]
        # print(sortData)
        # 初始化最终分割数据后的熵
        lastE1,lastE2 = -1, -1
        # 返回的数据区间，包括数据和对应的熵
        S1 = dict()
        S2 = dict()
        for i in range(len(data)):
            splitData1, splitData2 = sortData[:i+1], sortData[i+1:]
            # 计算信息熵
            entropy1, entropy2 = (
                self.calEntropy(splitData1),
                self.calEntropy(splitData2)
            )
            # 计算调和平均熵
            entropy = entropy1 * len(splitData1) / len(sortData) + entropy2 * len(splitData2) / len(sortData)
            if entropy < minEntropy:
                minEntropy = entropy
                index = i
                lastE1 = entropy1
                lastE2 = entropy2
        S1["entropy"] = lastE1
        S1["data"] = sortData[:index+1]
        S2["entropy"] = lastE2
        S2["data"] = sortData[index+1:]
        return S1, S2, entropy
 
    def train(self,data):
        # 需要遍历的key
        needSplitKey = [0]
 
        self.result.setdefault(0,{})
        self.result[0]["entropy"] = np.inf
        self.result[0]["data"] = data
 
        group = 1
        for key in needSplitKey:
            S1, S2, entropy = self.split(self.result[key]["data"])
            if entropy > self.minInfoThreshold and group < self.maxGroup:
                self.result[key] = S1
                newKey = max(self.result.keys()) + 1
                self.result[newKey] = S2
                needSplitKey.extend([key])
                needSplitKey.extend([newKey])
                group += 1
            else:
                break
 
if __name__ == '__main__':
    dbe = DiscreateByEntropy(group=6,threshold=0.5)
    データ= dbe.loadData（）
    dbe.train（データ）
    の印刷（" 結果が{} " .format（dbe.result））

結果：

見られること、商品の価格は、それぞれのインデックス0,1,2,3,4に対応し、5部に分かれています。

おすすめ