2. 程式人生 > >機器學習小組知識點27：資料預處理之資料離散化（Data Discretization）

機器學習小組知識點27：資料預處理之資料離散化（Data Discretization）

阿新 • • 發佈：2018-12-22

離散化和概念分層產生

通過將屬性域劃分為區間，離散化技術可以用來減少給定連續屬性值的個數。區間的標號可以替代實際的資料值。如果使用基於判定樹的分類挖掘方法，減少屬性值的數量特別有好處。通常，這種方法是遞迴的，大量的時間花在每一步的資料排序上。因此，待排序的不同值越少，這種方法就應當越快。許多離散化技術都可以使用，以便提供屬性值的分層或多維劃分——概念分層

對於給定的數值屬性，概念分層定義了該屬性的一個離散化。通過收集並用較高層的概念（對
於年齡屬性，如young, middle-age 和senior）替換較低層的概念（如，年齡的數值值），概念分層可以用來歸約資料。通過這種泛化，儘管細節丟失了，但泛化後的資料更有意義、更容易解釋，並且所需的空間比原資料少。在歸約的資料上進行挖掘，與在大的、未泛化的資料上挖掘相比，所需的I/O 操作更少，並且更有效

對於使用者或領域專家，人工地定義概念分層可能是一項令人乏味、耗時的任務。幸而，許多分層蘊涵在資料庫模式中，並且可以在模式定義級定義。概念分層常常自動地產生，或根據資料分佈的統計分析動態地加以提煉。

數值屬性的概念分層可以根據資料分佈分析自動地構造。五種數值概念分層產生方法：分
箱、直方圖分析、聚類分析、基於熵的離散化和通過“自然劃分”的資料分段。

分箱

分箱方法。這些方法也是離散化形式。例如，通過將資料分佈到箱中，並用箱中的平均值或中值替換箱中的每個值，可以將屬性值離散化。就象用箱的平均值或箱的中值平滑一樣。這些技術可以遞迴地作用於結果劃分，產生概念分層。

直方圖分析

直方圖分析演算法遞迴地用於每一部分，自動地產生多級概念分層，直到到達一個預先設定的概念層數，過程終止。也可以對每一層使用最小區間長度來控制遞迴過程。最小區間長度設定每層每部分的最小寬度，或每層每部分中值的最少數目。

聚類分析

聚類演算法可以用來將資料劃分成聚類或群。每一個聚類形成概念分層的一個結點，而所有的結點在同一概念層。每一個聚類可以進一步分成若干子聚類，形成較低的概念層。聚類也可以聚集在一起，以形成分層結構中較高的概念層

基於熵的離散化

一種基於資訊的度量稱作熵，可以用來遞迴地劃分數值屬性A 的值，產生分層的離散化。這種離散化形成屬性的數值概念分層。給定一個數據元組的集合S，基於熵對A 離散化的方法如下：
A 的每個值可以認為是一個潛在的區間邊界或閾值T。例如，A 的值v 可以將樣本S劃分成分別滿足條件A<v 和A≥v 的兩個子集，這樣就建立了一個二元離散化。
給定S，所選擇的閾值是這樣的值，它使其後劃分得到的資訊增益最大。
其中，S

1和S2 分別對應於S 中滿足條件A<T和A≥T 的樣本。對於給定的集合，它的熵函式根據集合中樣本的類分佈來計算

演算法描述如下：

STEP 1:

（1）初始化分裂點集合為空，屬性所有取值集合為全集。

（2）按照屬性值的大小順序，將屬性值集合和對應的類標號集合排序。

（3）選擇最佳分類點（熵值最小）將屬性分類為兩個區間。

（4）遞迴處理所得到的兩個區間。

STEP 2:

（1）合併所有的相鄰、區間類資訊熵為0且區間裡屬性類別相同的區間。

（2）計算所有的相鄰區間合併後的區間類資訊嫡，合併計算得到的區間類資訊嫡最小且不超過閾值心的相鄰區間

（3）重複（2）直到不再滿足條件

具體實現如下：

#coding=utf-8
#以下為需要調節的引數
######################################################
ClassNum = 33 #設定類的總數，以生成統計不同類樣本數量
######################################################
FeatureNum = 145 #生成需要離散化的屬性陣列
#######################################################
InfoThreshold = 0.5 #熵值大於此值時不再合併
#######################################################
MaxGroup = 70 #最大離散化成多少組（分割點數加1）
#######################################################
MinGroup = 5 #最少離散化成多少組（分割點數加1）
#######################################################
BlockSize = 5 #抽樣大小，每BlockSize個數據抽取一個
#######################################################
MaxDeep = 7 #對大遞迴深度
#######################################################
MinSplit = 3000 #葉節點小於此值時不再分裂
#######################################################
MinLeaf = 100 #控制最小葉節點大小
#######################################################
NeedDisCol = [....] #需要離散化的維列表，預設維數從1開始（0對應id號）
######################################################
#訓練集及類標
fTrain = open("...")
fLabel = open("...") #轉化後的單列類標
######################################################
#寫入檔案
fDis = open("...", "a+")

#將NeedDisCol轉變為0開始
for i in range(len(NeedDisCol)):
 NeedDisCol[i] = NeedDisCol[i] - 1

from pandas import Series, DataFrame
import pandas as pd
import random
import math
import numpy as np

ItTrain = pd.read_csv(fTrain, chunksize = BlockSize)
ItLabel = pd.read_csv(fLabel, chunksize = BlockSize)

#定義同時迭代兩個檔案的函式,返回list
def getLine(It, rd):
 for df in It:
 aList = df.values[:, 1:].tolist() #去掉id列,返回指定行
 if rd >= len(aList):
 return aList[0]
 else:
 return aList[rd]
 return False

#抽取樣本資料
TrainSet = []
LabelSet = []
count = 0
while True:
 #產生隨機數，並更新已讀取檔案的行數
 rd = int(random.random() * BlockSize)
 count = count + BlockSize

 TrainList = getLine(ItTrain, rd)
 if not TrainList:
 break
 else:
 TrainSet.append(TrainList)
 LabelList = getLine(ItLabel, rd)
 if not LabelList:
 break
 else:
 LabelSet.append(LabelList)
 ########################################
 if count % 100000 == 0:
 print "讀取了%d行" % count
 ########################################



#將類標按照特徵升序排列
def SortTogether(theFeature , theLabel):
 arr = np.array(theFeature)
 NumSort = np.argsort(arr)
 #複製thelabel\theFeature
 copyOfFeature = [0]*len(theFeature)
 copyOfLabel = [0]*len(theLabel)
 for i in range(len(theFeature)):
 copyOfFeature[i] = theFeature[i]
 copyOfLabel[i] = theLabel[i]
 #按獲得的索引NumSort排序
 for i in range(len(theFeature)):
 theFeature[i] = copyOfFeature[NumSort[i]]
 theLabel[i] = copyOfLabel[NumSort[i]]


#將每個類標標上對應的tip（表示其(包含)前面的各類統計）
def TipTheLabel(theLabel):
 TipLabel = []
 for i in range(len(theLabel)):
 inTip = [0] * (ClassNum + 1) #從一開始
 TipLabel.append(inTip)
 TipLabel[0][theLabel[0]] = 1
 for i in range(1, len(theLabel)):
 for j in range(1, ClassNum + 1):
 TipLabel[i][j] = TipLabel[i - 1][j]
 TipLabel[i][theLabel[i]] = TipLabel[i][theLabel[i]] + 1
 return TipLabel


#獲取對應區間的類的數量列表
def GetPointNumList(theLabel, start, end, TipLabel):
 result = []
 if start >= end or start < 0 or end >= len(theLabel):
 return [0] * ClassNum
 for i in range(1,ClassNum + 1):
 classCounter = TipLabel[end][i] - TipLabel[start][i]
 result.append(classCounter)
 return result

#計算特點的熵值
def GetEntropyOfCertainPoint(theLabel, start, end, thePoint, TipLabel):
 if start == end:
 return 0
 LList = GetPointNumList(theLabel, start, thePoint - 1, TipLabel)
 RList = GetPointNumList(theLabel, thePoint, end, TipLabel)
 NL = float(thePoint - start)
 NR = float(end - thePoint + 1)
 EntropyL = 0
 EntropyR = 0
 for aClassNum in LList:
 if aClassNum == 0:
 continue
 else:
 p = aClassNum / NL
 EntropyL = EntropyL - p * math.log(p)
 for aClassNum in RList:
 if aClassNum == 0:
 continue
 else:
 p = aClassNum / NR
 EntropyR = EntropyR - p * math.log(p)
 result = (NL * EntropyL) / (NL + NR) + (NR * EntropyR) / (NL + NR)
 return result


#獲取有最大熵值的點,越小越好
def GetMaxEntropyPoint(theFeature, theLabel, start, end, TipLabel, ThisEntropy):
 MinPoint = start + MinLeaf
 MinEntropy = GetEntropyOfCertainPoint(theLabel, start, end, MinPoint, TipLabel)

 #i = MinPoint + 20
 #while True: 

 for i in range(MinPoint + 1, end - MinLeaf):
 theEntropy = GetEntropyOfCertainPoint(theLabel, start, end, i, TipLabel)
 if MinEntropy >= theEntropy:
 MinEntropy = theEntropy
 MinPoint = i
 #print "執行到球maxpoint", MaxPoint
 ThisEntropy[0] = MinEntropy
 return MinPoint

#合併左右分裂列表及本分裂點
def GetCombinList(LList, thePoint, RList):
 theList = []
 for aNum in LList:
 theList.append(aNum)
 theList.append(thePoint)
 for aNum in RList:
 theList.append(aNum)
 return theList

#遞迴離散化函式
def GetDisPointList(theFeature , theLabel, start, end, Deep, TipLabel):
 #大於最大遞迴深度，返回
 if Deep > MaxDeep:
 return []
 #小於最小分裂數，返回
 if end - start < MinSplit:
 return []
 #分割之前的資訊熵
 #BeforeEntropy = GetEntropyOfCertainPoint( theLabel, start, end, start + 1, TipLabel)
 #分割
 ThisEntropy = [0] #留作擴充套件
 thePoint = GetMaxEntropyPoint(theFeature, theLabel, start, end, TipLabel, ThisEntropy)
 LList = GetDisPointList(theFeature, theLabel, start, thePoint - 1, Deep + 1, TipLabel)
 RList = GetDisPointList(theFeature, theLabel, thePoint, end, Deep + 1, TipLabel)
 CombinList = GetCombinList(LList, thePoint, RList)
 return CombinList

#最大熵離散化函式
def DisACol(theFeature , theLabel, ToTipLabel): 
 SortTogether(theFeature, theLabel)
 TipLabel = TipTheLabel(theLabel)
 DisPointList = GetDisPointList(theFeature , theLabel, 0, len(theFeature) - 1, 0, TipLabel)
 #print 'DisACol'
 ToTipLabel[0] = TipLabel
 return DisPointList

#由分裂點下表獲取分裂點值
def GetDisNumFromPoint(theDisPointList, theFeature):
 result = []
 for aPoint in theDisPointList:
 result.append(theFeature[aPoint])
 return result

#獲取列對應的拷bei
def getCertainCol(theSet, theCol):
 result = []
 for item in theSet:
 result.append(item[theCol])
 return result

#刪除相同的點
def DelEqual(alist, theFeature):
 i = len(alist) - 1
 while True:
 if i<1:
 break
 #如果相鄰分割點對應的值相同，則刪除一個
 if theFeature[alist[i]] == theFeature[alist[i-1]]:
 del alist[i-1]
 i = i - 1
 return alist

#獲取列表中臨近分割區間的最小合併資訊熵
def GetMinSplitPoint(List, theLabel, MinEntropy, TipLabel):
 MinPoint = 0
 TheEntropy = GetEntropyOfCertainPoint(theLabel, 0, List[1], 1, TipLabel)
 for i in range(1, len(List)-1):
 iEntropy = GetEntropyOfCertainPoint(theLabel, List[i-1], List[i+1], List[i-1] + 1, TipLabel)
 if iEntropy < TheEntropy:
 MinPoint = i
 TheEntropy = iEntropy
 iEntropy = GetEntropyOfCertainPoint(theLabel, List[-2], len(theLabel) - 1, List[-2] + 1, TipLabel)
 if iEntropy < TheEntropy:
 MinPoint = len(List) - 1
 TheEntropy = iEntropy
 MinEntropy[0] = TheEntropy
 return MinPoint

#合併資訊熵小於閾值的區間InfoThreshold = 0.5,MinGroup = 20
def CombineResult(List, theLabel, TipLabel):
 MinEntropy = [0]
 while True:
 if len(List) <= MinGroup:
 break
 MinPoint = GetMinSplitPoint(List, theLabel, MinEntropy, TipLabel)
 if MinEntropy[0] >= InfoThreshold and len(List) < MaxGroup:
 break
 else:
 del List[MinPoint]
 print "結束合併，資訊熵= %f" % MinEntropy[0]
 return List

#逐列檢查，判斷離散點（用於分割離散區間）
SaveAllColDisPoint = []
for i in range(FeatureNum):
 newlist = [-100000]
 SaveAllColDisPoint.append(newlist)
for aCol in NeedDisCol:
 theFeature = getCertainCol(TrainSet, aCol) #深度拷貝
 theLabel = getCertainCol(LabelSet, 0)
 TipLabel = [0]
 theDisPointList = DisACol(theFeature , theLabel, TipLabel)
 TipLabel = TipLabel[0]
 theDisPointList = DelEqual(theDisPointList, theFeature)
 theDisPointList = CombineResult(theDisPointList, theLabel, TipLabel)
 theDisNumList = GetDisNumFromPoint(theDisPointList, theFeature)
 SaveAllColDisPoint[aCol] = theDisNumList
 print SaveAllColDisPoint[aCol]
 print "判斷%d列完成" % aCol

#由列表獲取寫入行
count = 1
def getLineFromList(aItem, count):
 theLine = 'X' + str(count) + ','
 for num in aItem:
 theLine = theLine + str(num) + ','
 return theLine[:-1] + '\n'

for aItem in SaveAllColDisPoint:
 fDis.write(getLineFromList(aItem, count))
 count = count + 1

fTrain.close()
fDis.close()
fLabel.close()

通過自然劃分分段

3-4-5 規則可以用於將數值資料劃分成相對一致、“自然的”區間。一般地，該規則根據最重要的數字上的值區域，遞迴地、逐層地將給定的資料區域劃分為3、4 或5 個等長的區間。該規則如下：
如果一個區間在最重要的數字上包含3、6、7 或9 個不同的值，則將該區間劃分成3 個區間（對於3、6 和9，劃分成3 個等寬的區間；而對於7，按2-3-2 分組，劃分成3 個區間）；
如果它在最重要的數字上包含2、4 或8 個不同的值，則將區間劃分成4 個等寬的區間；
如果它在最重要的數字上包含1、5 或10 個不同的值，則將區間劃分成5 個等寬的區間。
該規則可以遞迴地用於每個區間，為給定的數值屬性建立概念分層。由於在資料集中可能有特別大的正值和負值，最高層分段簡單地按最小和最大值可能導致扭曲的結果。例如，在資產資料集中，少數人的資產可能比其他人高几個數量級。按照最高資產值分段可能導致高度傾斜的分層。這樣，頂層分段可以根據代表給定資料大多數的資料區間（例如，第5 個百分位數到第95 個百分位數）進行。越出頂層分段的特別高和特別低的值將用類似的方法形成單獨的區間。此處類似於分位數劃分區間。

相關推薦

機器學習小組知識點27：資料預處理之資料離散化（Data Discretization）

離散化和概念分層產生 通過將屬性域劃分為區間，離散化技術可以用來減少給定連續屬性值的個數。區間的標號可以替代實際的資料值。如果使用基於判定樹的分類挖掘方法，減少屬性值的數量特別有好處。通常，這種方法是遞迴的，大量的時間花在每一步的資料排序上。因此，待排序的不同

資料預處理之獨熱編碼（One-Hot）：為什麼要使用one-hot編碼？

一、問題由來 最近在做ctr預估的實驗時，還沒思考過為何資料處理的時候要先進行one-hot編碼，於是整理學習如下： 在很多機器學習任務如ctr預估任務中，特徵不全是連續值，而有可能是分類值。如下：   　　　　分類變數（定量特徵）與連續變數（定性特徵）。我們訓練模型的變數，一般分為兩種形式。以廣告

資料預處理之資料抽樣

資料抽樣 在資料建模階段，一般需要將樣本分為3部分：訓練集、驗證集、測試集。訓練集用來估計模型，驗證集用來確定網路結構或者控制模型複雜度的引數，測試集檢驗最終選擇模型的效能如何。一般劃分為70%、15%、15%。當資料量較小時，留少部分作為測試集，把其餘N個樣本採用K折交叉驗證法。即將樣

資料預處理之資料離散化

資料離散化的意義 資料離散化是指將連續的資料進行分段，使其變為一段段離散化的區間。分段的原則有基於等距離、等頻率或優化的方法。資料離散化的原因主要有以下幾點： 1**.演算法需要：** 比如決策樹、樸素貝葉斯等演算法，都是基於離散型的資料展開的。如果要使用

資料預處理之獨熱編碼（One-Hot Encoding）

比如 sex:[“male”, “female”] country: [‘china’,’USA’,’Japan’] 正常數字量化後： “male”, “female”用0,1表示; ‘china’,’USA’,’Japan’用0,1,2表示。 現

資料預處理之資料標準化

資料標準化的意義 在對資料集建模前，常常要對資料的某一特徵或幾個特徵進行規範化處理，其目的在於將特徵值歸一到同一個維度，消除比重不平衡的問題。 常用的標準化方法有 最大-最小標準化、零-均值標準化 和 小數定標標準化。 最大-最小標準化 最大-最小標準化

資料預處理之抽取文字資訊（2）

摘要：大資料技術與我們日常生活越來越緊密，要做大資料，首要解決資料問題。原始資料存在大量不完整、不一致、有異常的資料，嚴重影響到資料建模的執行效率，甚至可能導致模型結果的偏差，因此要資料預處。資料預處理主要是將原始資料經過文字抽取、資料清理、資料整合、資料處理、資料變換、資料降維等處理後，不

【Python資料預處理】 歸一化（按列減均值，除方差），標準化（按列縮放到指定範圍），正則化（範數）

一、標準化（Z-Score），或者去除均值和方差縮放 公式為：(X-mean)/std  計算時對每個屬性/每列分別進行。 將資料按期屬性（按列進行）減去其均值，並處以其方差。得到的結果是，對於每個屬性/每列來說所有資料都聚集在0附近，方差為1。 實現時，有兩種不同

資料預處理中歸一化（Normalization）與損失函式中正則化（Regularization）解惑

背景：資料探勘/機器學習中的術語較多，而且我的知識有限。之前一直疑惑正則這個概念。所以寫了篇博文梳理下 摘要： 　　1.正則化（Regularization） 　　　　1.1 正則化的目的　 　　　　1.2 結構風險最小化（SRM）理論 　　　　1.3 L1範數

資料預處理之歸一化

min_max_scaler = preprocessing.MinMaxScaler() X_train_minmax = min_max_scaler.fit_transform(X_train) X_test_minmax = min_max_scaler.transform(X_test) 2、標

資料預處理之歸一化(normalization)

概念介紹：歸一化是利用特徵的最大最小值，將特徵的值縮放到[new_min,new_max]區間，對於每一列的特徵使用min-max函式進行縮放，計算公式如下程式碼示例：import numpy as n

機器學習 --2 特徵預處理 之 資料將維

特徵選擇 概念 特徵選擇就是單純地從提取到的所有特徵中選擇部分特徵作為訓練集特徵，特徵在選擇前和選擇後可以改變值、也不改變值，但是選擇後的特徵維數肯定比選擇前小，畢竟我們只選擇了其中的一部分特徵。 方差過濾式 # 按照方差過濾 from sklearn.f

機器學習 --2 特徵預處理 之 資料標準化

歸一化: API位置 sklearn.preprocessing 歸一化: 特點：通過對原始資料進行變換把資料對映到(預設為[0,1])之間 注意也可以通過指定MinMaxScalar 裡邊的feature_range 來指定縮放的範圍 示例程式碼

斯坦福cs231n學習筆記（8）------神經網路訓練細節（資料預處理、權重初始化）

神經網路訓練細節系列筆記： 這一篇，我們將繼續介紹神經網路訓練細節。 一、Data Preprocessing（資料預處理） 如圖是原始資料，資料矩陣X有三種常見的資料預處理形式，其中我們假定X的大小為[N×D]（N是資料的數量，D是它們的維數

吳恩達的機器學習程式設計作業11：nnCostFunction 求解神經網路的代價函式（含BP演算法）

function [J grad] = nnCostFunction(nn_params, ... input_layer_size, ...

機器學習經典算法具體解釋及Python實現--線性回歸（Linear Regression）算法

ica single 方便 最好的 而且 == show des fun （一）認識回歸 回歸是統計學中最有力的工具之中的一個。機器學習監督學習算法分為分類算法和回歸算法兩種，事實上就是依據類別標簽分布類型為離散型、連續性而定義的。顧名思義。分類算法用於離散型分布

資料預處理--克服資料不平衡

  這種問題和業務需求也有很強的相關性，可能根據領域知識也能解決一些問題。   一篇綜述論文：《Learning from Imbalanced Data》。 不平衡資料評估指標   1）單一評估指標、ROC曲線和PR曲線見機器學習：準確率(Precision)、召回率(Rec

資料預處理--輸入歸一化/標準化/放縮

輸入歸一化/標準化   Alex 和 Caffe中的初始化引數都是基於均值歸一化的，如果不做歸一化，會因為輸入大了一半，導致訓練失敗。這也是為什麼Caffe強制為樣本計算影象均值的原因。   這樣，畫素值[0,255]被調整成了近似[-128,128]。儘管影象資料格式規整，但是做一

資料預處理之缺失值處理

資料預處理.1 缺失值處理 刪除法 刪除小部分樣本，在樣本量大時（刪除部分所佔比例小於5%時）可以使用 插補法 —均值插補：分為定距型（插入均值）和非定距型（眾數或者中值） —迴歸插補：線性和非線性迴歸 —極大似然估計M

Python資料預處理之---統計學的t檢驗，卡方檢驗以及均值，中位數等

Python資料預處理過程：利用統計學對資料進行檢驗，對連續屬性檢驗正態分佈，針對正態分佈屬性繼續使用t檢驗檢驗方差齊次性，針對非正態分佈使用Mann-Whitney檢驗。針對分類變數進行卡方檢驗（涉及三種卡方的檢驗：Pearson卡方，校準卡方，精準卡方）等。