GIS信息关联规则挖掘——Apriori算法的实现(下)

上篇说明了原理,这篇就直接上核心代码了~

代码比较长,所以理解可能有点麻烦,核心思路就是计算选择的维度后遍历数据,逐步进行循环计算置信度,并淘汰每次循环后的最低值。

这里有一点要注意的,我一开始想用arraylist构造一个堆栈结构进行数据遍历的存储跟计算,因为这样效率比较高。。

但是后来发现,那么做的话,如果以后想要对类型跟因子的种类、数量进行修改的话,需要对代码进行大量重构才能实现功能的更新,而对于我朋友这样的代码苦手来说估计跟写天书差不多。。于是在实现的时候我放弃了部分效率,将每个类型单独设置一个数据表,然后每个表写入该类型所有的因子,最后通过在数据库读取这些表的形式进行数据的遍历计算。这样的话,后期想要更改类型跟因子,可以通过直接在数据库修改的方式进行处理,代码也不需要大改了。

(=。= 没办法额,毕竟不是每个人都会写代码的。。。)

namespace FManage
{
    public partial class Analy : Form
    {
        private System.Windows.Forms.CheckBox[] checkBoxFactors;

        private DataSet ds;
        private int[] rowTables;
        private int[] flag;
        private int[] dimention;
        private int[] fee;
        private int p;

        public Analy()
        {
            InitializeComponent();
            this.panel1.SuspendLayout();
            this.SuspendLayout();
        //数据加载过程略
            this.checkBoxFactors = new System.Windows.Forms.CheckBox[6];

	//设置要素选择项
            for (int i = 0; i < 6; i++)
            {
                this.checkBoxFactors[i] = new System.Windows.Forms.CheckBox();
                this.checkBoxFactors[i].AutoSize = true;
                this.checkBoxFactors[i].Location = new System.Drawing.Point(90 + i % 3 * 150, 28 + (int)Math.Floor(Convert.ToDouble(i / 3) * 40));
                this.checkBoxFactors[i].Size = new System.Drawing.Size(84, 16);
                this.checkBoxFactors[i].TabIndex = i + 1;
                this.checkBoxFactors[i].UseVisualStyleBackColor = true;
                this.panel1.Controls.Add(this.checkBoxFactors[i]);
            }

            this.panel1.ResumeLayout(false);
            this.panel1.PerformLayout();
            this.ResumeLayout(false);
            this.PerformLayout();
        }

        private void Analy_Load(object sender, EventArgs e)
        {

            rowTables = new int[8];

            for (int i = 0; i < 8; i++)
            {
                rowTables[i] = ds.Tables[i].Rows.Count;
            }

            dimention = new int[8];
            for (int i = 0; i < 8; i++)
            {
                dimention[i] = ds.Tables[i].Rows.Count;
            }
        }

	//计算选择维度
        private void countfee(ref int[] fee)
        {
            int p;
            for (int i = 0; i < dimention[7]; i++)
            {
                p = 0;
                for (int j = 0; j < 7; j++)
                {
                    if (flag[j] == 1)
                        fee[i] += System.Convert.ToInt32(ds.Tables[7].Rows[i].ItemArray[j + 1]) * (int)Math.Pow(10, p++);
                }
            }
        }

        private void CircleString(int a, int end, ref string[] finalString, ref int[] needle, string[][] tempString)
        {
            for (int i = 0; i < tempString[a].Length; i++)
            {
                needle[a] = i;
                if (a == end - 1)
                {
                    for (int j = 0; j < end; j++)
                    {
                        finalString[p++] = tempString[j][needle[j]];
                    }
                }
                else
                {
                    CircleString(a + 1, end, ref finalString, ref needle, tempString);
                }
            }
        }

        private void CircleCalculationString(int a, int end, ref string[] finalCalculation, ref int[] needleCalculation, string[][] tempCalculation)
        {
            for (int i = 0; i < tempCalculation[a].Length; i++)
            {
                needleCalculation[a] = i;
                if (a == end - 1)
                {
                    for (int j = 0; j < end; j++)
                    {
                        finalCalculation[p++] = tempCalculation[j][needleCalculation[j]];
                    }
                }
                else
                {
                    CircleCalculationString(a + 1, end, ref finalCalculation, ref needleCalculation, tempCalculation);
                }
            }
        }

	//计算支持度和置信度
        private void buttonCalculate_Click(object sender, EventArgs e)
        {
            double zhichiduNumber = Convert.ToDouble(rank1.Text) / 100;
            double zhixinduNumber = Convert.ToDouble(rank2.Text) / 100;
            fee = new int[dimention[7]];
            flag = new int[7];
            flag[0] = 1;
            for (int i = 0; i < 6; i++)
            {
                if (this.checkBoxFactors[i].Checked)
                    flag[i + 1] = 1;
                else
                    flag[i + 1] = 0;
            }
            countfee(ref fee);

            #region ShowString
            string[][] tempString = new string[flag.Sum() - 1][];
            int temp = 0;
            for (int i = 0; i < flag.Sum() - 1; i++)
            {
                do { temp++; if (temp == 7)break; } while (flag[temp] == 0);
                tempString[i] = new string[dimention[temp]];
                for (int j = 0; j < dimention[temp]; j++)
                {
                    tempString[i][j] = ds.Tables[temp].Rows[j].ItemArray[1].ToString();
                }
            }

            int[] needleString = new int[flag.Sum() - 1];
            for (int i = 0; i < flag.Sum() - 1; i++)
            {
                needleString[i] = 0;
            }

            int finalNumber = 1;
            for (int i = 1; i < 7; i++)
            {
                if (flag[i] == 1)
                    finalNumber *= ds.Tables[i].Rows.Count;
            }

            DataTable showTable = new DataTable("showTable");

            DataColumn finalCol = showTable.Columns.Add("ID", typeof(Int32));
            finalCol.AllowDBNull = false;
            finalCol.Unique = true;

            for (int i = 1; i < 7; i++)
            {
                if (flag[i] == 1)
                    showTable.Columns.Add(ds.Tables[7].Columns[i + 1].ColumnName, typeof(String));
            }

            showTable.Columns.Add("支持度(%)", typeof(double));
            showTable.Columns.Add("置信度(%)", typeof(double));

            string[] showString = new string[finalNumber * (flag.Sum() - 1)];
            p = 0;
            CircleString(0, flag.Sum() - 1, ref showString, ref needleString, tempString);

            DataRow showRow;
            p = 0;
            for (int i = 0; i < finalNumber; i++)
            {
                showRow = showTable.NewRow();
                showRow[0] = i + 1;
                for (int j = 0; j < flag.Sum() - 1; j++)
                {
                    showRow[j + 1] = showString[p++];
                }
                showRow[flag.Sum()] = 0;
                showRow[flag.Sum() + 1] = 0;
                showTable.Rows.Add(showRow);
            }
            #endregion
            #region Calculation
            string[][] tempCalculation = new string[flag.Sum()][];
            temp = 0;
            for (int i = 0; i < flag.Sum(); i++)
            {
                tempCalculation[i] = new string[dimention[temp]];
                for (int j = 0; j < dimention[temp]; j++)
                {
                    tempCalculation[i][j] = ds.Tables[temp].Rows[j].ItemArray[0].ToString();
                }
                do { temp++; if (temp == 7)break; } while (flag[temp] == 0);
            }

            int[] needleCalculation = new int[flag.Sum()];
            for (int i = 0; i < flag.Sum(); i++)
            {
                needleCalculation[i] = 0;
            }

            finalNumber = 1;
            for (int i = 0; i < 7; i++)
            {
                if (flag[i] == 1)
                    finalNumber *= ds.Tables[i].Rows.Count;
            }

            DataTable calculationTable = new DataTable("calculationTable");

            for (int i = 0; i < 7; i++)
            {
                if (flag[i] == 1)
                    calculationTable.Columns.Add(ds.Tables[7].Columns[i + 1].ColumnName, typeof(String));
            }

            string[] finalCalculation = new string[finalNumber * flag.Sum()];
            p = 0;
            CircleCalculationString(0, flag.Sum(), ref finalCalculation, ref needleCalculation, tempCalculation);

            DataRow calculationRow;
            p = 0;
            for (int i = 0; i < finalNumber; i++)
            {
                calculationRow = calculationTable.NewRow();
                for (int j = 0; j < flag.Sum(); j++)
                {
                    calculationRow[j] = finalCalculation[p++];
                }
                calculationTable.Rows.Add(calculationRow);
            }
            #endregion

            int[] objectiveFee = new int[finalNumber];
            for (int i = 0; i < finalNumber; i++)
            {
                for (int j = 0; j < flag.Sum(); j++)
                {
                    objectiveFee[i] += System.Convert.ToInt32(calculationTable.Rows[i].ItemArray[j]) * (int)Math.Pow(10, j);
                }
            }

            double[,] times = new double[3, finalNumber / 2];
            for (int i = 0; i < finalNumber / 2; i++)
            {
                for (int j = 0; j < dimention[7]; j++)
                {
                    if (objectiveFee[i] == fee[j])
                        times[0, i]++;
                }
            }
            for (int i = finalNumber / 2; i < finalNumber; i++)
            {
                for (int j = 0; j < dimention[7]; j++)
                {
                    if (objectiveFee[i] == fee[j])
                        times[1, i - finalNumber / 2]++;
                }
            }
            for (int i = 0; i < finalNumber / 2; i++)
            {
                times[2, i] = times[0, i] + times[1, i];
            }
            double[] zhichidu = new double[finalNumber / 2];
            for (int i = 0; i < finalNumber / 2; i++)
            {
                zhichidu[i] = times[2, i] / 1000.0;
            }
            double[] zhixindu = new double[finalNumber / 2];
            for (int i = 0; i < finalNumber / 2; i++)
            {
                if (times[2, i] > 0)
                {
                    zhixindu[i] = ((int)(times[0, i] / times[2, i] * 10000)) / 10000.0;
                }
                else
                    zhixindu[i] = 0;
            }
            for (int i = 0; i < finalNumber / 2; i++)
            {
                showTable.Rows[i][flag.Sum()] = zhichidu[i];
                showTable.Rows[i][flag.Sum() + 1] = zhixindu[i];
            }

            for (int i = 0; i < showTable.Rows.Count; i++)
            {
                showTable.Rows[i][0] = i + 1;
                showTable.Rows[i][flag.Sum()] = (int)(Convert.ToDouble(showTable.Rows[i][flag.Sum()]) * 1000) / 10.0;
                showTable.Rows[i][flag.Sum() + 1] = (int)(Convert.ToDouble(showTable.Rows[i][flag.Sum() + 1]) * 1000) / 10.0;
            }

            this.dataGridView1.DataSource = null;
            this.dataGridView1.DataSource = showTable.DefaultView;
            this.dataGridView1.Visible = true;

        }
    }
}
时间: 2024-10-17 13:19:06

GIS信息关联规则挖掘——Apriori算法的实现(下)的相关文章

推荐系统第4周--- 基于频繁模式的推荐系统和关联规则挖掘Apriori算法

数据挖掘:关联规则挖掘 关联规则挖掘:Apriori算法 提高Apriori的效率 基于散列的算法基于FP tree的算法

数据挖掘-关联分析 Apriori算法和FP-growth 算法

?1.关联分析概念 关联分析是从大量数据中发现项集之间有趣的关联和相关联系. ? ?定义:1.事务:每一条交易称为一个事务,如上图包含5个事务.2.项:交易的每一个物品称为一个项,例如豆奶,啤酒等. 3.项集:包含零个或多个项的集合叫做项集,例如{尿布,啤酒}.4.k?项集:包含k个项的项集叫做k-项集,例如 {豆奶,橙汁}叫做2-项集.5.支持度计数:一个项集出现在几个事务当中,它的支持度计数就是几.例如{尿布, 啤酒}出现在事务002.003和005中,所以           它的支持度计

Apriori算法--关联规则挖掘

我的数据挖掘算法代码:https://github.com/linyiqun/DataMiningAlgorithm 介绍 Apriori算法是一个经典的数据挖掘算法,Apriori的单词的意思是"先验的",说明这个算法是具有先验性质的,就是说要通过上一次的结果推导出下一次的结果,这个如何体现将会在下面的分析中会慢慢的体现出来.Apriori算法的用处是挖掘频繁项集的,频繁项集粗俗的理解就是找出经常出现的组合,然后根据这些组合最终推出我们的关联规则. Apriori算法原理 Aprio

数据挖掘算法之关联规则挖掘(一)---apriori算法

关联规则挖掘算法在生活中的应用处处可见,几乎在各个电子商务网站上都可以看到其应用 举个简单的例子 如当当网,在你浏览一本书的时候,可以在页面中看到一些套餐推荐,本书+有关系的书1+有关系的书2+...+其他物品=多少¥ 而这些套餐就很有可能符合你的胃口,原本只想买一本书的你可能会因为这个推荐而买了整个套餐 这与userCF和itemCF不同的是,前两种是推荐类似的,或者你可能喜欢的商品列表 而关联规则挖掘的是n个商品是不是经常一起被购买,如果是,那个n个商品之中,有一个商品正在被浏览(有被购买的

关联规则挖掘(基本概念和Apriori算法)

关联规则挖掘的研究一直是数据挖掘领域的一个重要方向. 关联规则挖掘的目的是从大型事务数据库中挖掘出不同项目之间的关联关系 ,找出潜在的行为模式. 关联规则概念是由 Agrawal 等人在1993年率先提出的, 并随后提出了Apriori算法. 基本概念: 定义1  关联规则挖掘的事务数据库记为TDB,TDB={T1,T2,…,Tk},Tk={i1,i2,…,ip},Tk称为事务,ip称为项目. 定义2  设I={i1,i2,…,im}是TDB中全体项目组成的集合.每一个事务T是I中一组项目的集合

C#下RSA算法的实现(适用于支付宝和易宝支付)

C#下RSA算法的实现(适用于支付宝和易宝支付) 目录(?)[-] RSA算法代码 RSA算法测试代码 RSA算法代码: [csharp] view plain copy using System; using System.Collections.Generic; using System.Text; using System.IO; using System.Security.Cryptography; namespace RSA.Class { /// <summary> /// 类名:

Python学习(三) 八大排序算法的实现(下)

本文Python实现了插入排序.基数排序.希尔排序.冒泡排序.高速排序.直接选择排序.堆排序.归并排序的后面四种. 上篇:Python学习(三) 八大排序算法的实现(上) 1.高速排序 描写叙述 通过一趟排序将要排序的数据切割成独立的两部分,当中一部分的全部数据都比另外一部分的全部数据都要小,然后再按此方法对这两部分数据分别进行高速排序,整个排序过程能够递归进行,以此达到整个数据变成有序序列. 1.先从数列中取出一个数作为基准数. 2.分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全

使用Apriori算法和FP-growth算法进行关联分析(Python版)

===================================================================== <机器学习实战>系列博客是博主阅读<机器学习实战>这本书的笔记也包含一些其他python实现的机器学习算法 算法实现均采用python github 源码同步:https://github.com/Thinkgamer/Machine-Learning-With-Python ==================================

浅谈数据挖掘中的关联规则挖掘

数据挖掘是指以某种方式分析数据源,从中发现一些潜在的有用的信息,所以数据挖掘又称作知识发现,而关联规则挖掘则是数据挖掘中的一个很重要的 课题,顾名思义,它是从数据背后发现事物之间可能存在的关联或者联系.举个最简单的例子,比如通过调查商场里顾客买的东西发现,30%的顾客会同时购买床 单和枕套,而购买床单的人中有80%购买了枕套,这里面就隐藏了一条关联:床单—>枕套,也就是说很大一部分顾客会同时购买床单和枕套,那么对于商 场来说,可以把床单和枕套放在同一个购物区,那样就方便顾客进行购物了.下面来讨论