示例#1
0
        //计算多阶模式

        public SortedList <string, List <List <int> > > MoreSize(SortedList <string, List <List <int> > > LastCN, SortedList <int, SortedSet <int> > INs, double min_prev, List <int> TypeCountList, List <int> TypeinsList, double w, double min_occ)
        {
            SortedList <string, List <List <int> > > T = new SortedList <string, List <List <int> > >();//拿出上一阶模式进行扩展
            int                k = 0;
            Occupation         classoccupation = new Occupation();
            List <List <int> > li = new List <List <int> >()
            {
            };

            T.Add("extend", li);
            int index = 0;

            //扩展每一个上一阶的待扩展模式pk-1
            //对于每一个上一阶模式,都对其进行扩展,其模式扩展集合可以确定模式扩展的特征,其邻居矩阵可以使得该模式能够直接扩展出所有的下一阶超模式
            #region
            foreach (var patternitem in LastCN.Take(LastCN.Count - 1))//对于每一个待扩展模式pk-1
            {
                //Console.WriteLine("listtend" + listt.Count() + "," + jj);
                //if (patternitem.Key.Contains("extend")) { break; }

                List <int> extendset = new List <int>();//记录所有由pname扩展出的频繁超模式的特征集合
                //===============筛选得到扩展特征集合
                #region
                StringInstance snew = new StringInstance();
                //SortedSet<int> extendset = new SortedSet<int>();

                var        extendlist1 = LastCN["extend"][index];
                var        extendlist2 = snew.SplitString1(patternitem.Key, '+').Select <string, int>(x => Convert.ToInt32(x));//得到pk-1自身模式的特征并转为整数类型
                List <int> extendlist3 = new List <int>();
                for (int i = 0; i < extendlist1.Count(); i++)
                {
                    if (extendlist1[i] > extendlist2.Last())
                    {
                        extendlist3.Add(extendlist1[i]);
                    }
                }
                //var extendlist3 = extendlist1;//=============================得到模式扩展候选特征集合
                //需要将小于末尾的特征也去掉

                List <int> pnamelist = new List <int>();
                pnamelist = extendlist2.ToList();//==============================================被扩展模式pk-1的特征集
                //string pname = "";
                StringBuilder ppp = new StringBuilder();
                ppp.Append(extendlist2.ToList()[0]);
                for (int i = 1; i < extendlist2.Count(); i++)
                {
                    ppp.Append("+");
                    ppp.Append(extendlist2.ToList()[i]);
                }
                string pname1 = ppp.ToString();
                string pname  = patternitem.Key;
                //==========================向下闭合剪枝
                SortedSet <int> newextend = new SortedSet <int>(); //====================再次用剪枝把可扩展特征删选一遍以获得模式的最小扩展
                int             sign      = 1;
                foreach (var exitem1 in extendlist3)               //针对每一个扩展模式
                {
                    string exitem = "";
                    if (exitem1 < 10)
                    {
                        exitem = "0" + exitem1;
                    }
                    else
                    {
                        exitem = exitem1.ToString();
                    }
                    string testpname    = patternitem.Key + "+" + exitem.ToString();
                    var    testnamelist = snew.SplitString1(testpname, '+');
                    foreach (var comb in Combinations(testnamelist, 0, testnamelist.Count, testnamelist.Count - 1))//测试子模式,对于ABC(tlist),从tlist[0]开始索引,得到tlist.Count个sizek - 1阶的组合
                    {
                        StringBuilder l     = new StringBuilder();
                        string[]      hcomb = comb.Take(testnamelist.Count - 1).ToArray();
                        l.Append(hcomb[0]);
                        for (int jj = 1; jj < comb.Take(testnamelist.Count - 1).Count(); jj++)
                        {
                            l.Append("+");
                            l.Append(hcomb[jj]);
                        }
                        l.ToString();
                        if (!LastCN.ContainsKey(l.ToString()))
                        {
                            sign = 0;
                            break;
                        }//剪枝步
                    }
                    if (sign == 1)//若该模式频繁
                    {
                        newextend.Add(int.Parse(exitem));          //再次用剪枝把可扩展特征删选一遍以获得模式的最小矩阵
                    }
                }

                //== ==================================扩展特征再进行筛选,去掉参与度不够的特征

                List <int> listjj     = new List <int>(); //存放第j个特征参与在pname+j表实例中的个数
                List <int> newextend1 = new List <int>();
                newextend1 = newextend.ToList();          //存放newextend矩阵列对应的特征号
                                                          //初始化listjj,其长度为扩展特征的个数
                for (int ii = 0; ii < newextend1.Count; ii++)
                {
                    listjj.Add(0);
                }
                SortedSet <int> unionCN = new SortedSet <int>()
                {
                };
                for (int ii = 0; ii < LastCN[pname].Count - 1; ii++)//得到所有的有序集合
                {
                    unionCN.UnionWith(LastCN[pname][ii]);
                }
                foreach (var unitem in unionCN)//得到每个候选扩展特征的参与个数
                {
                    if (newextend.Contains(TypeinsList[unitem]))
                    {
                        listjj[newextend1.IndexOf(TypeinsList[unitem])]++;
                    }
                }
                //如果不频繁直接将其从候选特征中删除

                List <double> PIJlist        = new List <double>();
                List <int>    realextendlist = new List <int>();//新建真正的扩展特征集合

                for (int ii = 0; ii < listjj.Count; ii++)
                {
                    double f1sum = double.Parse((TypeCountList[newextend1[ii]] - TypeCountList[newextend1[ii] - 1]).ToString());
                    double pri   = double.Parse(listjj[ii].ToString()) / f1sum;
                    if (pri > min_prev)
                    {
                        realextendlist.Add(newextend1[ii]); //得到扩展特征j
                        PIJlist.Add(pri);                   //得到j的参与度
                    }
                }
                #endregion
                //===============使用真正的候选realextendset集合中的特征连接行实例并计算,列宽为realextendlist的秩,对应的值在CN中找
                //listiinj是列宽为realextendlist的秩,行数为pname行实例的长度,每个格存放扩展特征f邻近某一条行实例的实例集合
                List <List <SortedSet <int> > > listiinj = new List <List <SortedSet <int> > >();//listi中的j,即j个 realextendlist中的特征分别参与在模式pname每一条行实例中的集合//+j中的k-1阶的参与率最小值
                for (int ii = 0; ii < LastCN[pname].Count - 1; ii++)
                {
                    List <SortedSet <int> > mm = new List <SortedSet <int> >();
                    for (int jj = 0; jj < realextendlist.Count; jj++)//初始化listi中的j的矩阵
                    {
                        SortedSet <int> rowset = new SortedSet <int>()
                        {
                        };
                        mm.Add(rowset);
                    }
                    listiinj.Add(mm);
                }
                //===============测试每一个超模式pk,即pname+realextendlist[jj]
                #region
                for (int jj = 0; jj < realextendlist.Count; jj++)//对于每一个J特征
                {
                    //realextendlist[jj]为某一扩展特征,patternitem.value为待扩展模式的表实例
                    List <List <int> > listt = new List <List <int> >();//一个表实例单位
                    Console.WriteLine("listtbegin" + listt.Count() + "," + jj);
                    List <List <int> > patternitemlist = new List <List <int> >();
                    patternitemlist.AddRange(patternitem.Value);//初始化,带扩展模式pk-1的表实例及邻居

                    //针对每一列,即每一个realextendlist[jj],建立包含该特征实例的行实例表
                    List <int> rowlist = new List <int>();
                    for (int ii = 0; ii < LastCN[pname].Count - 1; ii++)//针对每一行遍历含有realextendlist[jj]特征的lastT中的行实例
                    {
                        //==============================================这里是一个剪纸,如果rowset的秩/pname中实例总数max的那个<prev,那么pname+j不用计算就丢掉了
                        foreach (var item in LastCN[pname][ii])
                        {
                            if (TypeinsList[item] == realextendlist[jj]) //如果该行含有特征j
                            {
                                rowlist.Add(ii);                         //收集参加了含有特征j的pname模式的行实例的行号
                                listiinj[ii][jj].Add(item);
                            }
                        }
                    }
                    rowlist.Distinct();
                    List <int> rowlist1 = new List <int>();
                    rowlist1.AddRange(rowlist.Distinct());
                    rowlist.Clear();
                    rowlist.AddRange(rowlist1);

                    //求得行实例邻居表 /*
                    List <SortedSet <int> > listrowinj = new List <SortedSet <int> >();//初始化,长度为上一个阶lastT的阶,pname=ABC的时候,listrowinj[0]=Aset,即A的所有参加在ABCD中的实例的集合
                    for (int ii = 0; ii < pnamelist.Count; ii++)
                    {
                        SortedSet <int> newset = new SortedSet <int>()
                        {
                        };
                        listrowinj.Add(newset);//用来计算参与率
                    }
                    //listrowij的作用是计算pname中各个特征参加在pname+realextend[jj]中的参与率

                    //提取rowlist中的行号生成pname+realextend[jj]的表实例
                    for (int ii = 0; ii < rowlist.Count; ii++)                    //对于每一行
                    {
                        for (int iii = 0; iii < pnamelist.Count(); iii++)         //
                        {
                            listrowinj[iii].Add(LastCN[pname][rowlist[ii]][iii]); //存放了所有参与在T中的k-1阶特征的实例投影,及ABC的话,listrowinj.count=3,listrowinj[0]放A在ABCD中的实例集合
                                                                                  //takepnameins.Add(LastCN[pname][ii][iii]);//存放ii行的pname的行实例
                        }//每一列代表Pname中的一个特征参与在panme+realextend[jj]中的实例集
                        if (listiinj[ii][jj].Count > 0)
                        {
                            foreach (var itee in listiinj[rowlist[ii]][jj])
                            {
                                List <int> takepnameins = new List <int>();
                                takepnameins.AddRange(LastCN[pname][rowlist[ii]].Take(pnamelist.Count()));
                                takepnameins.Add(itee);
                                listt.Add(GetRowCN(takepnameins, INs));
                            }
                        }
                    }
                    //得到j特征的listrowinj之后要对其进行计算
                    List <double> PIIlist = new List <double>();     //ABC的参与率
                    //求得pname+realextend[jj]参与率
                    for (int iii = 0; iii < listrowinj.Count; iii++) //计算 listrowinj每一个特征在其中的参与率,即pname在testpname中的特征参与率
                    {
                        List <int> plist = new List <int>();
                        plist = pnamelist.ToList();//拆分上一阶pname模式的所有特征
                        double f1sum = double.Parse((TypeCountList[plist[iii]] - TypeCountList[plist[iii] - 1]).ToString());
                        double pri   = double.Parse(listrowinj[iii].Count.ToString()) / f1sum;
                        PIIlist.Add(Math.Round(pri, 2));     //对每一个上一阶模式特征分别计算参与率
                    }
                    PIIlist.Add(Math.Round(PIJlist[jj], 2)); //得到pname+j的所有特征参与率
                    List <int> PIIset = new List <int>();
                    //for (int iii = 0; iii < PIIlist.Count; iii++)
                    //{
                    //    PIIset.Add(int.Parse((PIIlist[iii] * 100.00).ToString()));//===============这里其实也可以存放所有特征的pr
                    //}
                    PIIset.Add(int.Parse((PIIlist.Min() * 100.00).ToString()));
                    #endregion
                    //================================================================================开始计算所有的值
                    Console.WriteLine("listtend" + listt.Count() + "," + jj);

                    if (PIIlist.Min() > min_prev)
                    {
                        Console.WriteLine("111PI" + PIIlist.Min());
                        string newpname = "";
                        if (realextendlist[jj] < 10)
                        {
                            newpname = pname + "+" + "0" + realextendlist[jj];
                        }
                        else
                        {
                            newpname = pname + "+" + realextendlist[jj];
                        }
                        extendset.Add(realextendlist[jj]);
                        List <SortedSet <int> > palist = classoccupation.PA(PIIlist.Count, listt);
                        List <SortedSet <int> > calist = classoccupation.CA(palist[palist.Count - 1], listt);
                        double OI = Math.Round(classoccupation.OccupationIndex(palist, calist), 2);
                        if (OI > min_occ)
                        {
                            double wpo = w * PIIlist.Min() + (1 - w) * OI;
                            wpo = Math.Round(wpo, 2);
                            double     PI        = PIIlist.Min();
                            List <int> resultset = new List <int>();
                            resultset.Add(int.Parse((PI * 100.00).ToString()));
                            resultset.Add(int.Parse((OI * 100.00).ToString()));
                            resultset.Add(int.Parse((wpo * 100.00).ToString()));
                            listt.Add(resultset);//末尾加上参与度

                            Console.WriteLine("newpname" + newpname);
                            Console.WriteLine("PI" + PIIlist.Min());
                            T.Add(newpname, listt);
                            // T["extend"].Add(realextendlist.ToList());
                        }
                    }

                    //=======================================满足参与度之后看是否满足占有率

                    //  }//计算每个pname+jj模式结尾

                    // 测试完毕所有的pname + j之后可以得到所有与i频繁的所有特征,与其结合才能得到下一阶频繁的extenedTypeset
                    //对于每一个i开头的二阶模式,保留一个T作为extendset
                }

                for (int ii = 0; ii < extendset.Count; ii++)
                {
                    T["extend"].Add(extendset);
                }

                index++;
            }

            // }
            #endregion
            //结束待扩展模式
            return(T);
        }
        public SortedList <string, List <List <int> > > WeightPrevalenceT(string pname, int index, SortedList <string, List <List <int> > > LastCN, SortedList <int, SortedSet <int> > INs, double min_prev, List <int> TypeCountList, List <int> TypeinsList, double w, double min_occ)
        {
            Occupation classoccupation = new Occupation();
            SortedList <string, List <List <int> > > T = new SortedList <string, List <List <int> > >();
            List <List <int> > li = new List <List <int> >()
            {
            };

            T.Add("extend", li);
            int extendflag = 0;//记录得到多少个频繁模式

            #region
            //===========================================================测试频繁子阶
            StringInstance snew = new StringInstance();
            //对于每一个上一阶模式,都对其进行扩展,其模式扩展集合可以确定模式扩展的特征,其邻居矩阵可以使得该模式测试其所有的下一阶
            //SortedSet<int> extendset = new SortedSet<int>();
            var extendlist1 = LastCN["extend"][index];
            // extendlist1 = LastCN[snew.SplitString1(pname, '+')[0] + "+extend"][0].ToList();
            var           extendlist2 = snew.SplitString1(pname, '+').Select <string, int>(x => Convert.ToInt32(x));//将扩展特征中属于自身模式的特征去掉
            var           extendlist3 = extendlist1.Except(extendlist2);
            List <string> pnamelist1  = snew.SplitString1(pname, '+');
            List <int>    pnamelist   = new List <int>();

            for (int ii = 0; ii < pnamelist1.ToList().Count; ii++)
            {
                pnamelist.Add(int.Parse(pnamelist1.ToList()[ii]));
            }


            SortedSet <int> newextend = new SortedSet <int>(); //====================再次用剪枝把可扩展特征删选一遍以获得模式的最小扩展
            int             sign      = 1;
            foreach (var exitem in extendlist3)                //针对每一个扩展模式
            {
                string testpname    = pname + "+" + exitem.ToString();
                var    testnamelist = snew.SplitString1(testpname, '+');
                foreach (var comb in Combinations(testnamelist, 0, testnamelist.Count, testnamelist.Count - 1))//测试子模式,对于ABC(tlist),从tlist[0]开始索引,得到tlist.Count个sizek - 1阶的组合
                {
                    StringBuilder l     = new StringBuilder();
                    string[]      hcomb = comb.Take(testnamelist.Count - 1).ToArray();
                    l.Append(hcomb[0]);
                    for (int jj = 1; jj < comb.Take(testnamelist.Count - 1).Count(); jj++)
                    {
                        l.Append("+");
                        l.Append(hcomb[jj]);
                    }
                    l.ToString();
                    if (!LastCN.ContainsKey(l.ToString()))
                    {
                        sign = 0;
                        break;
                    }//剪枝步
                }
                if (sign == 1)//若该模式频繁
                {
                    newextend.Add(exitem);          //再次用剪枝把可扩展特征删选一遍以获得模式的最小矩阵
                }
            }

            //扩展特征再进行筛选,去掉参与度不够的特征
            List <int> listjj     = new List <int>(); //存放第j个特征参与在pname+j表实例中的个数
            List <int> newextend1 = new List <int>();
            newextend1 = newextend.ToList();          //存放newextend矩阵列对应的特征号
                                                      //初始化listjj,其长度为扩展特征的个数
            for (int ii = 0; ii < newextend1.Count; ii++)
            {
                listjj.Add(0);
            }
            SortedSet <int> unionCN = new SortedSet <int>()
            {
            };
            for (int ii = 0; ii < LastCN[pname].Count - 1; ii++)//得到所有的有序集合
            {
                unionCN.UnionWith(LastCN[pname][ii]);
            }
            foreach (var unitem in unionCN)//得到每个候选扩展特征的参与个数
            {
                if (newextend.Contains(TypeinsList[unitem]))
                {
                    listjj[newextend1.IndexOf(TypeinsList[unitem])]++;
                }
            }
            //如果不频繁直接将其从候选特征中删除
            //新建真正的扩展特征集合
            List <double> PIJlist        = new List <double>();
            List <int>    realextendlist = new List <int>();

            for (int ii = 0; ii < listjj.Count; ii++)
            {
                double f1sum = double.Parse((TypeCountList[newextend1[ii]] - TypeCountList[newextend1[ii] - 1]).ToString());
                double pri   = double.Parse(listjj[ii].ToString()) / f1sum;
                if (pri > min_prev)
                {
                    realextendlist.Add(newextend1[ii]); //得到扩展特征j
                    PIJlist.Add(pri);                   //得到j的参与度
                }
            }

            //=======================================================使用真正的候选realextendset集合中的特征连接行实例并计算,列宽为newextend的秩,对应的值在CN中找
            List <List <int> >      listt    = new List <List <int> >();      //一条行实例单位
            List <SortedSet <int> > listiinj = new List <SortedSet <int> >(); //j个 特征分别参与在模式pname+j中的k-1阶的参与率最小值
            List <int> extendset             = new List <int>();              //开始计算以pname为头的模式的扩展特征
            for (int ii = 0; ii < realextendlist.Count; ii++)                 //初始化
            {
                SortedSet <int> rowset = new SortedSet <int>()
                {
                };
                listiinj.Add(rowset);
            }
            for (int jj = 0; jj < realextendlist.Count; jj++)                       //对于每一个J特征
            {
                List <SortedSet <int> > listrowinj = new List <SortedSet <int> >(); //初始化,长度为上一个阶lastT的阶,pname=ABC的时候,listrowij[0]=Aset,即A的所有参加在ABCD中的实例的集合
                for (int ii = 0; ii < snew.SplitString1(pname, '+').Count; ii++)
                {
                    SortedSet <int> newset = new SortedSet <int>()
                    {
                    };
                    listrowinj.Add(newset);//用来计算参与率
                }
                //针对每一列,建立包含该特征实例的行实例表
                List <int> rowset = new List <int>();
                for (int ii = 0; ii < LastCN[pname].Count - 1; ii++)//针对每一行遍历有j的lastT中的行实例
                {
                    //==============================================这里是一个剪纸,如果rowset的秩/pname中实例总数max的那个<prev,那么pname+j不用计算就丢掉了
                    foreach (var item in LastCN[pname][ii])
                    {
                        if (TypeinsList[item] == realextendlist[jj]) //如果该行含有特征j
                        {
                            rowset.Add(ii);                          //收集参加了含有特征j的pname模式的行实例的行号
                        }
                    }
                }
                //用行实例行数剪纸
                List <int> pnametypecount = new List <int>();

                for (int ii = 0; ii < pnamelist.Count(); ii++)
                {
                    pnametypecount.Add(TypeCountList[pnamelist.ToList()[ii]] - TypeCountList[pnamelist.ToList()[ii] - 1]);
                }
                double pirow = double.Parse(rowset.Count().ToString()) / double.Parse(pnametypecount.Max().ToString());

                if (pirow > min_prev || pirow == min_prev)//用行实例行数剪纸条件下
                {
                    //求得行事例邻居表
                    for (int ii = 0; ii < rowset.Count; ii++)//对于每一行
                    {
                        List <int> takepnameins = new List <int>();
                        for (int iii = 0; iii < pnamelist.Count(); iii++)                 //
                        {
                            listrowinj[iii].Add(LastCN[pname][rowset.ToList()[ii]][iii]); //存放了所有参与在T中的k-1阶特征的实例投影,及ABC的话,listrowinj.count=3,listrowinj[0]放A在ABCD中的实例集合
                            //takepnameins.Add(LastCN[pname][ii][iii]);//存放ii行的pname的行实例
                        }//每一列
                        takepnameins.AddRange(LastCN[pname][rowset.ToList()[ii]].Take(pnamelist.Count()));
                        listt.Add(GetRowCN(takepnameins, INs));
                        //foreach (var item in LastCN[pname][ii])
                        //{
                        //    if (TypeinsList[item] == realextendlist[jj])//构建行实例邻居
                        //    {

                        //        listt.Add(GetRowCN(takepnameins, INs));//得到该行实例的邻居
                        //    }
                        //}
                    }
                    //得到j特征的listrowinj之后要对其进行计算
                    List <double> PIIlist = new List <double>();     //ABC的参与率
                    //求得testpname参与率
                    for (int iii = 0; iii < listrowinj.Count; iii++) //计算 listrowinj每一个特征在其中的参与率,即pname在testpname中的特征参与率
                    {
                        List <int> plist = new List <int>();
                        plist = pnamelist.ToList();//拆分上一阶pname模式的所有特征
                        double f1sum = double.Parse((TypeCountList[plist[iii]] - TypeCountList[plist[iii] - 1]).ToString());
                        double pri   = double.Parse(listrowinj[iii].Count.ToString()) / f1sum;
                        PIIlist.Add(Math.Round(pri, 2));//对每一个上一阶模式特征分别计算参与率
                    }
                    //PIIlist.Add(Math.Round(PIJlist[jj], 2));//得到pname+j的所有特征参与率
                    List <int> PIIset = new List <int>();
                    //for (int iii = 0; iii < PIIlist.Count; iii++)
                    //{
                    //    PIIset.Add(int.Parse((PIIlist[iii] * 100.00).ToString()));//===============这里其实也可以存放所有特征的pr
                    //}
                    PIIset.Add(int.Parse((PIIlist.Min() * 100.00).ToString()));
                    #endregion
                    //================================================================================开始计算所有的值
                    if (PIIlist.Min() > min_prev)
                    {
                        string newpname = pname + "+" + realextendlist[jj];
                        extendset.Add(realextendlist[jj]);
                        List <SortedSet <int> > palist = classoccupation.PA(PIIlist.Count, listt);
                        List <SortedSet <int> > calist = classoccupation.CA(palist[palist.Count - 1], listt);
                        double OI  = Math.Round(classoccupation.OccupationIndex(palist, calist), 2);
                        double wpo = w * PIIlist.Min() + (1 - w) * OI;
                        wpo = Math.Round(wpo, 2);
                        double     PI        = PIIlist.Min();
                        List <int> resultset = new List <int>();
                        resultset.Add(int.Parse((PI * 100.00).ToString()));
                        resultset.Add(int.Parse((OI * 100.00).ToString()));
                        resultset.Add(int.Parse((wpo * 100.00).ToString()));
                        listt.Add(PIIset);//末尾加上参与度
                        T.Add(newpname, listt);
                        extendflag++;
                    }
                    //=======================================满足参与度之后看是否满足占有率
                }//计算每个pname+jj模式结尾

                // 测试完毕所有的pname + j之后可以得到所有与i频繁的所有特征,与其结合才能得到下一阶频繁的extenedTypeset
                //对于每一个i开头的二阶模式,保留一个T作为extendset
            }
            for (int ii = 0; ii < extendflag; ii++)
            {
                T["extend"].Add(extendset);
            }

            return(T);
        }