2. 程式人生 > >《程式設計師的第一年》---------- 資料探勘之資料處理（C#基於熵的離散化演算法程式碼）

《程式設計師的第一年》---------- 資料探勘之資料處理（C#基於熵的離散化演算法程式碼）

阿新 • • 發佈：2019-02-10
熵（entropy）是最常用的離散化度量之一。它由Claude Shannon在資訊理論和資訊增益概念的開創性工作中首次引進。基於熵的離散化是一種監督的、自頂向下的分裂技術。它在計算和確定分裂點（劃分屬性區間的資料值）時利用類分佈資訊。為了離散數值屬性A，該方法選擇A的具有最小熵的值作為分裂點，並遞迴地劃分結果區間，得到分層離散化。這種離散化形成A的概念分層。

設D由屬性集和類標號屬性定義的資料元組組成。類標號屬性提供每個元組的類資訊。該集合中屬性A的基於熵的離散化基本方法如下：

（1）A的每個值都可以看作一個劃分A的值域的潛在的區間邊界或分裂點（記作split_ point）。也就是說，A的分裂點可以將D中的元組劃分成分別滿足條件A≤split_point和A > split_point的兩個子集，這樣就建立了一個二元離散化。
（2）正如上面提到的，基於熵的離散化使用元組的類標號資訊。為了解釋基於熵的離散化的基本思想，必須考察一下分類。假定要根據屬性A和某分裂點上的劃分將D中的元組分類。理想地，希望該劃分導致元組的準確分類。例如，如果有兩個類，希望類C1的所有元組落入一個劃分，而類C2的所有元組落入另一個劃分。然而，這不大可能。例如，第一個劃分可能包含許多C1的元組，但也包含某些C2的元組。在該劃分之後，為了得到完全的分類，我們還需要多少資訊？這個量稱作基於A的劃分對D的元組分類的期望資訊需求，由下式給出

其中，D1和D2分別對應於D中滿足條件A≤split_point和A > split_point的元組，|D|是D中元組的個數，如此等等。給定集合的熵函式Entropy根據集合中元組的類分佈來計算。例如，給定
m個類C1, C2, ., Cm，D1的熵是m

 
其中，pi是D1中類Ci的概率，由D1中Ci類的元組數除以D1中的元組總數|D1|確定。這樣，在選擇屬性A的分裂點時，我們希望選擇產生最小期望資訊需求（即min(InfoA(D))）的屬性值。這將導致在用A≤split_point和A > split_point劃分之後，對元組完全分類（還）需要的期望資訊量最小。這等價於具有最大資訊增益的屬性-值對（這方面的進一步細節在第6章討論分類時給出）。注意，Entropy(D2)的值可以類似於式（2-16）計算。

你可能會說，“但是我們的任務是離散化，而不是分類！”是這樣。我們使用分裂點將A的值域劃分成兩個區間，對應於A≤split_point和A > split_point。

（3）確定分裂點的過程遞迴地用於所得到的每個分劃，直到滿足某個終止標準，如當所有候選分裂點上的最小資訊需求小於一個小閾值ε，或者當區間的個數大於閾值max_interval 時終止。

基於熵的離散化可以減少資料量。與迄今為止提到的其他方法不同，基於熵的離散化使用類資訊。這使得它更有可能將區間邊界（分裂點）定義在準確位置，有助於提高分類的準確性。這裡介紹的熵和資訊增益度量也用於決策樹歸納


C#程式碼實現如下：

 using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.OleDb;
using Excel = Microsoft.Office.Interop.Excel;


namespace 連續值離散化
{
    /// <summary> 
    /// 連續型資料離散化。
    ///  要求：
    ///  
    ///     輸入：兩個序列，一個是待離散化的資料序列（如支付延遲時間）
    ///     一個是資料對應的分類（如是否復購）；
    ///     
    ///     操作：基於熵做有監督離散化操作；
    ///     
    ///     輸出：分割點
    ///     
    /// </summary>


    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }


        private void Form1_Load(object sender, EventArgs e)
        {


        }
        private List<Data> dataAll = new List<Data>();
        private List<double> SaveTi ;


        private void btnOk_Click(object sender, EventArgs e)
        {
            SaveTi = new List<double>();
            this.listBox2.Items.Clear();
            //步驟
            //1 根據屬性A值大小對資料集進行升序排序
            //資料集
            List<Data> datas = new List<Data>();


            for (int j = 0, l = dataAll.Count ; j < l; j++)
            {
                Data tempData = new Data();
                tempData.id = j;
                tempData.myClass = dataAll[j].myClass;
                tempData.value = dataAll[j].value;
                datas.Add(tempData);
            }


            #region   新增 測試 資料


            //for (int i = 0; i < 5; i++)
            //{
            //    Data tempData = new Data();
            //    Random rd = new Random();  


            //    string Myclass = "T";
            //    if (i % 3 == 0)
            //    {
            //        Myclass = "F";
            //    }
            //    tempData.id = i;
            //    tempData.myClass = Myclass;
            //    tempData.value = i + 1;
            //    //tempData.value = rd.Next(10) * (i + 1);
            //    //if (i < 2)
            //    //{
            //    //    tempData.value = 1;//rd.Next(10) * (i + 1)
            //    //}


            //    listBox1.Items.Add(tempData.value);


            //    datas.Add(tempData);
            //}


           #endregion


            int counts = datas.Count;//樣本總數 
            try
            {
                this.Print(GetTiByRecursionData(datas));
            }
            catch (Exception ex)
            {


                MessageBox.Show(ex.ToString());
            } 
        }


        private List<Data> Sort(List<Data> datas)
        {
            listBox1.Items.Clear();
            //升序排序  ，對datas類資料集中的屬性A的所有取值從小到大進行排序，不妨設得到的序列為:a1 ,a2,...
            for (int i = 0,l=datas.Count; i < l; i++)
            {
                for (int j = l - 1; i < j; j--)
                {
                    if (datas[i].value > datas[j].value)
                    {
                        Data tempData = new Data();
                        tempData = datas[j];
                        datas[j] = datas[i];
                        datas[i] = tempData;
                    }
                }
            }
            for (int j = 0, l = datas.Count; j < l; j++)
            {
                listBox1.Items.Add(datas[j].value);
            }
            return datas;
        }


        /// <summary>
        /// 取得Ti並做遞迴操作
        /// </summary>
        /// <param name="datas"></param>
        private string  GetTiByRecursionData(List<Data> datas)
        { 
            int counts = datas.Count;//樣本總數  
            if (counts < 1 )
            { 
                return "";
            }
            //dataTi 為Ti為候選分割點 資料集
            List<double> dataTi = new List<double>();
            for (int i = 0; i < counts; i++)
            {
                if (i < counts - 1)
                { 
                    dataTi.Add((double)(datas[i].value + datas[i + 1].value) / 2);
                }
            }
            ////計算每次劃分的資訊增益  Gain(A,T)=I(S1,S2,...Sm)-Ent(A,T)
            //List<double> gainList = new List<double>();


            #region 選擇Ti，使得將其作為分割點劃分S後的熵最小


            //最小熵值
            double minEnt = -1;
            //最小熵值時的Ti
            double isMinEntTi = -1;


            for (int i = 0, l = dataTi.Count; i < l; i++)
            {
                double tempTi = dataTi[i];
                //熵的計算
                double  tempMinEnt=   Ent(datas, tempTi);


                if (minEnt > tempMinEnt || i==0)
                {
                    minEnt = tempMinEnt;
                    isMinEntTi = tempTi;
                } 
            }
            if (SaveTi.Contains(isMinEntTi))
            {
                return "";
            }
            else
            {
                SaveTi.Add(isMinEntTi);
            }


            Dictionary<string, double> classDtAll = new Dictionary<string, double>();
            //取得兩個劃分
            List<Data> dataTiLeft = new List<Data>();
            List<Data> dataTiRight = new List<Data>();


            #region 取兩個劃分 資料集,所有樣本都在這兩個劃分中


            for (int i = 0; i < counts; i++)
            {
                if (datas[i].value <= isMinEntTi)
                {
                    dataTiLeft.Add(datas[i]); 
                }
                else
                {
                    dataTiRight.Add(datas[i]); 


                }
                 this.AddDictionaryValue(classDtAll, datas[i].myClass); 
            }
            #endregion


            if (classDtAll.Count<=1)
            { 
                return  datas[counts-1].value.ToString()+" ";
            } 


            //計算D(I)= f(I)/L(I)  , f(I)=|S| 


            double L_Left=0;
            double L_Right = 0;


            double D_I_Left = 0;
            double D_I_Right = 0;


            if (dataTiLeft.Count > 0)
            { 
                L_Left = dataTiLeft[dataTiLeft.Count - 1].value - dataTiLeft[0].value + 1; 
                D_I_Left = (double)dataTiLeft.Count / L_Left;
           
            }
            if (dataTiRight.Count > 0)
            {
              
                L_Right = dataTiRight[dataTiRight.Count - 1].value - dataTiRight[0].value + 1; 
                D_I_Right = (double)dataTiRight.Count / L_Right;
            }
            //定thresholdValue0 =E(S)
            double thresholdValue0 = this.E(classDtAll, counts);


            //自動計算閥值 
            double thresholdValueLeft = D_I_Left * thresholdValue0;
            double thresholdValueRight = D_I_Right * thresholdValue0;
            string temp=string.Empty;


            //手動設定閾值
            double thresholdValue = Convert.ToDouble(this.txt_gz.Text);


            if (!this.checkBox1.Checked)
            {
                thresholdValue = thresholdValueLeft;
            }


            if (minEnt > thresholdValue)
            {
                temp += this.GetTiByRecursionData(dataTiLeft) + " ";
            }


            if (!this.checkBox1.Checked)
            {
                thresholdValue = thresholdValueRight;
            }
            if (minEnt > thresholdValue)
            { 
                temp += this.GetTiByRecursionData(dataTiRight) + " ";  
              
            }
            if (temp!=string.Empty)
            {
                return temp;
            }
            else
            {
                return isMinEntTi.ToString() + " ";   
                //Ent 為1時兩劃分中的屬性屬於各個不同類 ，為0時兩劃分中的屬性屬於相同類  
            }
         
            #endregion 


        }


        /// <summary>
        /// 列印排序好的分割點
        /// </summary>
        /// <param name="Ti"></param>
        private void Print(string  Ti)
        {
            string[] arr = Ti.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);


            for (int i = 0, l = arr.Length; i < l; i++)
            {
                for (int j = arr.Length-1; j >= i; j--)
                {
                    if (Convert.ToDouble(arr[i]) > Convert.ToDouble(arr[j]))
                    {
                        string temp = arr[i];
                        arr[i] = arr[j];
                        arr[j] = temp;
                    } 
                }
            }


            foreach (string item in arr)
            {


                listBox2.Items.Add(item);
            }
            
        }
   
       
        /// <summary>
        /// 熵的計算
        /// </summary>
        /// <param name="datas"></param>
        /// <param name="p"></param>
        private double Ent(List<Data> datas, double T)
        {
 
            //取得分類資料集 與 當前分類包涵的屬性A的樣本個數
            Dictionary<string, double> classDtLeft = new Dictionary<string, double>();
            Dictionary<string, double> classDtRight = new Dictionary<string, double>();
             //Dictionary<string, double> classDtAll = new Dictionary<string, double>();


            int counts = datas.Count; 


            //取得兩個劃分
            List<Data> dataTiLeft = new List<Data>();
            List<Data> dataTiRight = new List<Data>();


            #region 取兩個劃分 資料集,所有樣本都在這兩個劃分中


            for (int i = 0; i < counts; i++)
            {
                if (datas[i].value <= T)
                {
                    dataTiLeft.Add(datas[i]);
                    this.AddDictionaryValue(classDtLeft, datas[i].myClass); 
                }
                else
                {
                    dataTiRight.Add(datas[i]);
                    this.AddDictionaryValue(classDtRight, datas[i].myClass);
                     
                }
                //this.AddDictionaryValue(classDtAll, datas[i].myClass);
                 
            }
            #endregion 


            //取得兩劃分的樣本個數
            int countLeft = dataTiLeft.Count;
            int countRight = dataTiRight.Count;
            //計算兩劃分的期望值
            //P_k_l為類別l在子集S_k中的概率  (k為引數 如 S_1 =左劃分,S_2 =右劃分)  
            double expectLeft = this.E(classDtLeft, countLeft);
            double expectRight = this.E(classDtRight, countRight);  
              
            double returnEnt = ((double)countLeft / counts) * expectLeft + ((double)countRight / counts) * expectRight;
             
             return returnEnt;
        }


        /// <summary>
        /// 新增值到Dictionary資料集內
        /// </summary>
        /// <param name="classDt"></param>
        /// <param name="myClass"></param>
        private void AddDictionaryValue(Dictionary<string, double> classDt, string myClass)
        {
            if (classDt.ContainsKey(myClass))
            {
                classDt[myClass] = classDt[myClass] + 1;
            }
            else
            {
                classDt.Add(myClass, 1);
            }
        }


        /// <summary>
        /// 計算集合內的期望值
        /// </summary>
        /// <param name="classDt">樣本內部類別 資料集</param>
        /// <param name="sampleCount">劃分後的單個劃分樣本總數</param>
        /// <returns>當前劃分的期望值</returns>
        private double E(Dictionary<string, double> classDt, int sampleCount)
        {


            //計算兩劃分的期望值
            //P_k_l為類別l在子集S_k中的概率  (k為引數 如 S_1 =左劃分) 
            double expect = 0;
            foreach (KeyValuePair<string, double> item in classDt)
            {
                //概率
                double tempProbability = item.Value / sampleCount;
                double tempExpect = tempProbability * Math.Log(tempProbability, 2);
                expect += tempExpect;
            }
            return -expect;
        }


        private void btn_InputExecel_Click(object sender, EventArgs e)
        {
            System.Windows.Forms.OpenFileDialog ofp = new OpenFileDialog();
            ofp.DefaultExt = "xls";
            ofp.Filter = "Excel檔案 (*.xlsx)|*.xlsx|(*.xls)|*.xls"; 
            if (ofp.ShowDialog()==System.Windows.Forms.DialogResult.OK)
            { 
                this.txt_InputExecel.Text=ofp.FileName;
              
            }
        }
        private void Import(string fileName)
        {
          
            List<string> columns = new List<string>(20);
            columns.Add(this.txt_Class.Text);
            columns.Add(this.txt_Number.Text); 


            Excel.Application app = new Excel.Application();
            Excel.Workbook book = app.Workbooks.Open(fileName);
            Excel.Worksheet srcSheet = (Excel.Worksheet)book.Sheets[this.txt_Sheet.Text];
        
            int rows = Convert.ToInt32( this.txt_rows.Text);
            for (int i = 2; i <= rows+1; i++)
            {
                Data tempData = new Data();
                Excel.Range srcRange = srcSheet.get_Range(columns[0] + i, Type.Missing);
                Excel.Range srcRange1 = srcSheet.get_Range(columns[1] + i, Type.Missing); 
                tempData.myClass = Convert.ToString(srcRange.Value);
                tempData.value = Convert.ToDouble(srcRange1.Value);
                tempData.id = i;
                if (tempData.myClass==null)
                {
                    break;
                }
                dataAll.Add(tempData);
            } 
            app.ActiveWorkbook.Close(); 
        }


        /// <summary>
        /// 匯入資料並排序
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_inputE_Click(object sender, EventArgs e)
        {
            this.listBox1.Items.Clear();
            dataAll.Clear();
            if (this.txt_Class.Text != "" && this.txt_InputExecel.Text != "" && this.txt_Number.Text != "" && this.txt_rows.Text != "" && this.txt_Sheet.Text != "")
            {
                try
                {
                    Import(this.txt_InputExecel.Text);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                    return;
                }
                dataAll = this.Sort(dataAll);
                //for (int j = 0, l = dataAll.Count; j < l; j++)
                //{
                //    listBox1.Items.Add(dataAll[j].value);
                //}
           
            }
            else
            {
                MessageBox.Show("請設定完引數再匯入");
                return;
            }
             




        }


        private void btn_sort_Click(object sender, EventArgs e)
        {
            
            dataAll = this.Sort(dataAll);
        }


        private void checkBox1_CheckedChanged(object sender, EventArgs e)
        {
            CheckBox cb = (CheckBox)sender;
            if (cb.Checked)
            {
                this.txt_gz.Enabled = true;
            }
            else
            {
                this.txt_gz.Enabled = false;
            }
        }
 
    }
}

還要優化，請讀者多加說說看法。小弟在此謝過


來自無憂返利網資料探勘編者：http://www.5ufanli.net

相關推薦

《程式設計師的第一年》---------- 資料探勘之資料處理（C#基於熵的離散化演算法程式碼）

熵（entropy）是最常用的離散化度量之一。它由Claude Shannon在資訊理論和資訊增益概念的開創性工作中首次引進。基於熵的離散化是一種監督的、自頂向下的分裂技術。它在計算和確定分裂點（劃分屬性區間的資料值）時利用類分佈資訊。為了離散數值屬性A，該方法選擇A的具

資料探勘之資料處理——SVM神經網路的資料分類預測-義大利葡萄酒種類識別

************* 使用的工具：Matlab 分類器：SVM ************* 1、案例背景： 在葡萄酒製造業中,對於葡萄酒的分類具有很大意義,因為這涉及到不同種類的葡萄酒的存放以及出售價格,採用SVM做為分類器可以有效預測相關葡萄酒的種類,從UCI資料

大資料探勘之資料預處理

資料預處理 資料探勘的第一步就是先對資料進行預處理。既然對資料進行處理，我們就需要先認識一下資料。 資料屬性 資料帶有屬性（attribute），屬性使用屬性值（attribute）去表示。例如身高屬性，屬性值為高度 屬性的型別分類一般有四種，Nominal（名

資料探勘01---文字分析（jieba分詞和詞雲繪製）

一、定義： 文字挖掘：從大量文字資料中抽取出有價值的知識，並且利用這些知識重新組織資訊的過程。 二、語料庫（Corpus） 語料庫是我們要分析的所有文件的集合。 import os import os.path filePaths = [] #定義一個數組變數 #再用

資料探勘-目錄-特徵處理（feature）

Feature Extractors（特徵提取） TF TF-IDF Word2Vec CountVectorizer Feature Transformers（特徵變換） Tokenizer（分詞器）

資料探勘之售房資料分析1

最近再做一批關於售房的資料，感覺自己陷入一個死衚衕裡： 該批資料是儲存再postgresql裡面，是從某售房網站上爬下來的，以資料庫中的一列欄位作為儲存資料，該列欄位是以json的資料形式儲存的，這裡跟我打開了一個新大門，資料庫能儲存json資料格式的資料，而且postgresql還有一套專門的

資料探勘之十大經典演算法

國際權威的學術組織the IEEE International Conference on Data Mining (ICDM) 2006年12月評選出了資料探勘領域的十大經典演算法：C4.5, k-Means, SVM, Apriori, EM, PageRank, AdaBoost, k

資料探勘之FP_Tree演算法實現

轉自http://www.cnblogs.com/zhangchaoyang/articles/2198946.html （格式複製之後有變化，建議直接點連結去部落格園看原文） python程式碼見https://github.com/yantijin/Lean_DataMining F

資料探勘之AdaBoost裝袋提升演算法

python3程式碼實現在https://github.com/yantijin/Lean_DataMining上，時間匆忙，敬請之處錯誤之處，謝謝！ 以下內容轉自：https://blog.csdn.net/androidlushangderen/article/details/4363511

程式設計師第一年的迷茫

從畢業出來，轉專業去學習java到現在已經一年零兩個月了，第一份工作就持續了兩個月，沒學到什麼，只是覺得公司領導的帶領方式有問題，到現在回想起來還是自己太小白了，畢竟外包公司不適合我這種剛出來的小白，沒人帶領，人家想要的只是成果，效率，也沒時間去培養你。 離職後，邊學習邊找工作，也適當放空了自己

資料探勘之關聯規則Apriori演算法

一、Aoriori原始演算法： 頻繁挖掘模式與關聯規則 關聯規則兩個基本的指標(假設有事務A和事務B) 　　1、支援度(suport)：計算公式如下 　　　　 　　2、置信度(confidence)： 　　 關聯規則的挖掘過程： 　　1、設定最小支援度閾值，找出所有的頻繁項集且每個出現的次數要

零基礎入門大資料探勘之spark中的幾種map

今天再來說一下spark裡面的幾種map方法。前面的文章介紹過單純的map，但是spark還有幾種map值得對比一下，主要是下面幾種： map：普通的map flatMap：在普通map的基礎上多了一個操作，扁平化操作； mapPartitions：相對於分割槽P

零基礎入門大資料探勘之spark的rdd

本節簡單介紹一下spark下的基本資料結構RDD，方便理解後續的更多操作。 那麼第一個問題，什麼是rdd。我們知道，大資料一般儲存在分散式叢集裡面，那麼你在對其進行處理的時候總得把它讀出來吧，讀出來後總得把它存成某種格式的檔案吧，就好比程式語言裡面的，這個資料是陣列，那麼你可以以陣列

零基礎入門大資料探勘之reduce方法

上節介紹過大資料裡面（以spark為例）最為基礎典型的操作：map方法，map方法直白的理解就是一個分散式接受處理函式的方法，形式如map(fun)，map方法本身不做處理，沒有map方法，裡面的函式fun就是一個單機的處理函式，有了map，相當於就把這個函式複製到多臺機器上，每臺機器同

資料倉庫與資料探勘之Apriori演算法例項

最近剛上了資料探勘這門課，老師講了兩個演算法，即Apriori演算法和FP-growth演算法，然後佈置了上機作業，挖掘一個有8萬行的記錄的retail.dat，需要從中找出強規則，即同時滿足最小支援度和最小置信度的規則。 Apriori演算法 在這裡給出一個實現找出所有頻繁模式集的

資料探勘之Apriori演算法

python3程式碼如下： #coding = utf-8 import numpy #from python_util import fileread """ 程式所需部分： 建立初始的候選集 根據Lk產生Lk+1

資料探勘之方差分析實驗

本部落格根據非常好的excel資料而編寫，使用python語言操作，預計使用一週的時間更新完成。需要《非常好的excel資料》word文件，歡迎發郵件給[email protected]，免費發放。這篇部落格對應《非常好的excel資料》裡的第5章節。 1.1 單因素方差分析

資料探勘之擬合優度檢驗

本部落格根據非常好的excel資料而編寫，使用python語言操作，預計使用一週的時間更新完成。需要《非常好的excel資料》word文件，歡迎發郵件給[email protected]，免費發放。這篇部落格對應《非常好的excel資料》裡的第4章節。 自由度v=（行數-1）（

大資料探勘之Scala零基礎學習（一）

第5章 函式5.1函式程式程式碼：object section5_1 extends App { // def gcd(x:Int,y:Int):Int=if(x%y==0) y else gcd(

資料探勘之關聯分析一（基本概念）

許多商業企業運營中的大量資料，通常稱為購物籃事務（market basket transaction）。表中每一行對應一個事務，包含一個唯一標識TID。 利用關聯分析的方法可以發現聯絡如關聯規則或頻繁項集。 關聯分析需要處理的關鍵問題： 1. 從大型事