public SortedList <int, Instance> instancelized(List <string> m)//所有的实例;读取文件之后对文件中的数据进行处理//这里的m已经经过m.sort排序 { SortedList <int, Instance> listins = new SortedList <int, Instance>(); StringInstance o = new StringInstance(); for (int i = 1; i < m.Count; i++) { Instance ino = new Instance(); List <string> si = new List <string>(); si = o.SplitInstance(".", "(", ",", ")", m[i]); ino.Id = i + 1; ino.Type = int.Parse(si[0]); ino.x = int.Parse(si[2]); ino.y = int.Parse(si[3]); listins.Add(i + 1, ino); } return(listins); }
//得到某个k-1阶模式扩展到k阶的频繁模式 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)); } //得到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); }
public SortedList <int, SortedSet <int> > InstanceNeighbor(int maxx, int maxy, int d, StringBuilder[,] co, SortedList <int, Instance> stlistin)//实例邻居集,输入为矩阵和实例号为主键的实例集合//返回所有实例的有序邻居集 { StringInstance si = new StringInstance(); SortedList <int, SortedSet <int> > nei = new SortedList <int, SortedSet <int> >(); // foreach (var item in stlistin) //初始化邻居集 { SortedSet <int> s = new SortedSet <int>(); s.Add(item.Key); nei.Add(item.Key, s); } Instance insexample = new Instance(); for (int i = 0; i < maxx + 1; i++)//-------------------------------------------------------开始遍历格 { for (int j = 0; j < maxy + 1; j++) { if (!co[i, j].Equals("")) { //string[] cp1 = co[i, j].ToString().Split(';');//拆分同一格子内实例号 List <string> cp1 = new List <string>(); cp1 = si.SplitString1(co[i, j].ToString(), ';'); List <int> indexcount = new List <int>();//存放统一特征编号 for (int ii = 0; ii < cp1.Count() - 1; ii++) { int index1 = Int32.Parse(cp1[ii].ToString()); indexcount.Add(index1); //存放统一特征编号并且已经经过排序 } indexcount.Sort(); for (int ii = 0; ii < indexcount.Count - 1; ii++) //----------------一格之间邻居,先查看是否是同一特征 { for (int jj = ii + 1; jj < indexcount.Count; jj++) { // 格内邻居不需要经过计算 if (stlistin[indexcount[ii]].Type != stlistin[indexcount[jj]].Type) { nei[indexcount[ii]].Add(indexcount[jj]); } } } for (int ii = 0; ii < cp1.Count - 1; ii++)//----------------不同格之间邻居 { int index = Int32.Parse(cp1[ii].ToString()); double x = stlistin[index].x; double y = stlistin[index].y; if (i != maxx && j != maxy && j != 0)//---------------------中间的格子 { StringBuilder p0 = new StringBuilder(); p0.Append(co[i, j + 1]); p0.Append(co[i + 1, j - 1]); p0.Append(co[i + 1, j]); p0.Append(co[i + 1, j + 1]); //string[]p2=new string[100*1024*1024]; string[] p2 = p0.ToString().Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); for (int iii = 0; iii < p2.Length; iii++) { //string[] p3 = p2[iii].Split('(', ',', ')'); if (stlistin[Int32.Parse(p2[iii].ToString())].Type != stlistin[index].Type) { if (insexample.distance(x, y, stlistin[Int32.Parse(p2[iii].ToString())].x, stlistin[Int32.Parse(p2[iii].ToString())].y, d))//若邻近 { if (stlistin[indexcount[ii]].Type != stlistin[Int32.Parse(p2[iii])].Type) { nei[index].Add(Int32.Parse(p2[iii])); } } } } } else if (j == 0 && i != maxx && j != maxy)//---------------------最左边的格子 { StringBuilder p0 = new StringBuilder(); p0.Append(co[i, j + 1]); p0.Append(co[i + 1, j]); p0.Append(co[i + 1, j + 1]); //string[] p2 = p0.ToString().Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); List <string> p2 = new List <string>(); p2 = si.SplitString1(p0.ToString(), ';'); for (int iii = 0; iii < p2.Count; iii++) { if (stlistin[Int32.Parse(p2[iii].ToString())].Type != stlistin[index].Type) { if (insexample.distance(x, y, stlistin[Int32.Parse(p2[iii].ToString())].x, stlistin[Int32.Parse(p2[iii].ToString())].y, d))//若邻近 { if (stlistin[indexcount[ii]].Type != stlistin[Int32.Parse(p2[iii])].Type) { nei[index].Add(Int32.Parse(p2[iii])); } } } } } else if (j == maxy && i != maxx)//---------------------最右边的格子 { StringBuilder p0 = new StringBuilder(); p0.Append(co[i + 1, j - 1]); p0.Append(co[i + 1, j]); List <string> p2 = new List <string>(); p2 = si.SplitString1(p0.ToString(), ';'); //string[] p2 = p0.ToString().Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); for (int iii = 0; iii < p2.Count; iii++) { if (stlistin[Int32.Parse(p2[iii].ToString())].Type != stlistin[index].Type) { if (insexample.distance(x, y, stlistin[Int32.Parse(p2[iii].ToString())].x, stlistin[Int32.Parse(p2[iii].ToString())].y, d))//若邻近 { if (stlistin[indexcount[ii]].Type != stlistin[Int32.Parse(p2[iii])].Type) { nei[index].Add(Int32.Parse(p2[iii])); } } } } } else if (i == maxx && j != maxy)//---------------------最下的格子 { string p1 = co[i, j + 1].ToString(); //string[] p2 = p1.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries); List <string> p2 = new List <string>(); p2 = si.SplitString1(co[i, j + 1].ToString(), ';'); for (int iii = 0; iii < p2.Count; iii++) { if (stlistin[Int32.Parse(p2[iii].ToString())].Type != stlistin[index].Type) { if (insexample.distance(x, y, stlistin[Int32.Parse(p2[iii].ToString())].x, stlistin[Int32.Parse(p2[iii].ToString())].y, d))//若邻近 { if (stlistin[indexcount[ii]].Type != stlistin[Int32.Parse(p2[iii])].Type) { nei[index].Add(Int32.Parse(p2[iii])); } } } } } } //for循环拆分co[i,j] } //----若co[i,j]不等于空 } //co[i,j]循环 } return(nei); }
private void buttonTest_Click(object sender, EventArgs e)//测试 { //测试字符串分割实例 #region /* * string str = "a.1(2.5,4.3)"; * stringinstance o=new stringinstance(); * o.splitinstance(".","(",",",")",str); * string m = ""; * for (int i = 0; i < o.splitinstance(".", "(", ",", ")", str).count; i++) * { * * m=o.splitinstance(".", "(", ",", ")", str)[i]; //----这就是你要的结果 * messagebox.show(m); * } */ #endregion //测试PA #region List <SortedSet <int> > list = new List <SortedSet <int> >(); //装实例表 List <SortedSet <int> > listPA = new List <SortedSet <int> >(); //装PA包括的实例 //List<SortedSet<int>> listline = new List<SortedSet<int>>(); List <int> listline = new List <int>(); //装每个PA包括的行号 SortedSet <int> ssin1 = new SortedSet <int>() { 1, 4, 7 }; SortedSet <int> ssin2 = new SortedSet <int>() { 1, 4, 8 }; SortedSet <int> ssin3 = new SortedSet <int>() { 2, 5, 9 }; SortedSet <int> ssin4 = new SortedSet <int>() { 3, 6, 9 }; SortedSet <int> ssin5 = new SortedSet <int>() { }; list.Add(ssin1); list.Add(ssin2); list.Add(ssin3); list.Add(ssin4); list.Add(ssin5); List <SortedSet <int> > listcn = new List <SortedSet <int> >(); //装实例邻居表 List <SortedSet <int> > listCA = new List <SortedSet <int> >(); //装CA包括的实例 SortedSet <int> csin1 = new SortedSet <int>() { 1, 4, 7, 10, 11, 14 }; SortedSet <int> csin2 = new SortedSet <int>() { 1, 4, 8, 10, 14 }; SortedSet <int> csin3 = new SortedSet <int>() { 2, 5, 9, 12, 15 }; SortedSet <int> csin4 = new SortedSet <int>() { 3, 6, 9, 13, 16 }; listcn.Add(csin1); listcn.Add(csin2); listcn.Add(csin3); listcn.Add(csin4); //装邻居 SortedList <int, SortedSet <int> > INs = new SortedList <int, SortedSet <int> >(); //装实例邻居表 //例子中共有16个实例,5个特征 SortedSet <int> In1 = new SortedSet <int>() { 1, 4, 7, 8, 10, 11, 14, 16, 18 }; INs.Add(1, In1); SortedSet <int> In2 = new SortedSet <int>() { 4, 1, 7, 8, 10, 11, 14, 17 }; INs.Add(4, In2); SortedSet <int> In3 = new SortedSet <int>() { 4, 1, 7, 10, 11, 14, 19 }; INs.Add(7, In3); //首先赋值第一行初始化 //listPA.Add(list[0]);//PA初始化 // listline.Add(0);//行号初始化 //for (int i = 1; i < list.Count(); i++)//讲实例表分到不同的PA中 //{ // int j = listPA.Count - 1; // SortedSet<int> tmpset = new SortedSet<int>(); // if (listPA[j].Overlaps(list[i])) // { // listPA[j].UnionWith(list[i]); // } // else // { // listline.Add(i); // listPA.Add(list[i]); // } //} //Occupation oc = new Occupation(); //oc.PA(list); //for (int i = 0; i < oc.PA(list).Count(); i++)//讲实例表分到不同的PA中 //{ // StringBuilder m = new StringBuilder(); // foreach (var item in oc.PA(list)[i]) // { // m.Append(item.ToString()); m.Append(","); // } // MessageBox.Show(m.ToString()); //} #endregion //=========================================================================测试公共邻域 #region //List<int> line = new List<int>(); //foreach (var item in oc.PA(list)[oc.PA(list).Count() - 1])//取出listline //{ // line.Add(item); //} //for (int i = 0; i < line.Count()-1; i++) //{ // SortedSet<int> tmpset = new SortedSet<int>(); // tmpset = listcn[line[i]]; // for (int j = line[i]+1; j < line[i + 1]; j++) // { // tmpset.UnionWith(listcn[j]); // } // listCA.Add(tmpset); //} //listPA = oc.PA(list); //listCA = oc.CA(oc.PA(list)[oc.PA(list).Count() - 1], listcn); //for (int i = 0; i < listCA.Count(); i++)//讲实例表分到不同的PA中 //{ // StringBuilder m1 = new StringBuilder(); // foreach (var item in listCA[i]) // { // m1.Append(item); // m1.Append(","); // } // MessageBox.Show(m1.ToString()); //} //double index = oc.OccupationIndex(oc.CA(oc.PA(list)[oc.PA(list).Count() - 1], listcn), oc.PA(list)); // MessageBox.Show(index.ToString()); //for (int i = 0; i < listline.Count(); i++)//讲实例表分到不同的PA中 //{ // MessageBox.Show(listline[i].ToString()); //} #endregion //==================================================测试组合函数 #region //Prevalence newp = new Prevalence(); //StringInstance snew = new StringInstance(); //string testpname = "A+B+C+D"; //foreach (var comb in Prevalence.Combinations(snew.SplitString1(testpname, '+'), 0, snew.SplitString1(testpname, '+').Count, snew.SplitString1(testpname, '+').Count - 1))//测试子模式,对于ABC(tlist),从tlist[0]开始索引,得到tlist.Count个sizek - 1阶的组合 //{ // StringBuilder l = new StringBuilder(); // string[] hcomb = comb.Take(snew.SplitString1(testpname, '+').Count - 1).ToArray(); // l.Append(hcomb[0]); // for (int jj = 1; jj < comb.Take(snew.SplitString1(testpname, '+').Count - 1).Count(); jj++) // { // l.Append("+"); // l.Append(hcomb[jj]); // } // l.ToString(); // //if (!lastT.ContainsKey(l.ToString())) // //{ // // sign = 0; // // break; // //}//剪枝步 // MessageBox.Show(l.ToString()); //} #endregion //测试枚举 #region //string h = "ABC"; //SortedSet<int> listve = new SortedSet<int>(); //listve.Add(1); listve.Add(3); listve.Add(4); listve.Add(6); listve.Add(7); listve.Add(9); //var q = from int s5 in listve // where s5>5 //字符串是以A开头,并且长度为4位的 // select s5; //for (int i = 0; i < q.ToList().Count(); i++)//讲实例表分到不同的pa中 //{ // MessageBox.Show(q.ToList()[i].ToString()); //} #endregion //测试筛选频繁模式扩展特征 #region SortedSet <int> newextend = new SortedSet <int>() { 4, 5 }; List <int> listjj = new List <int>(); //存放第j个特征参与在pname+j表实例中的个数 List <int> extendlist = new List <int>(); List <int> TypeinsList = new List <int>(); //TypeinsList.Add(0); TypeinsList.Add(3); TypeinsList.Add(6); TypeinsList.Add(9); TypeinsList.Add(13); TypeinsList.Add(16); TypeinsList.Add(0); TypeinsList.Add(1); TypeinsList.Add(1); TypeinsList.Add(1); TypeinsList.Add(2); TypeinsList.Add(2); TypeinsList.Add(2); TypeinsList.Add(3); TypeinsList.Add(3); TypeinsList.Add(3); TypeinsList.Add(4); TypeinsList.Add(4); TypeinsList.Add(4); TypeinsList.Add(4); TypeinsList.Add(5); TypeinsList.Add(5); TypeinsList.Add(5); /* extendlist = newextend.ToList();//存放newextend矩阵列对应的特征号 * //初始化listjj,其长度为扩展特征的个数 * for (int ii = 0; ii < extendlist.Count; ii++) * { * listjj.Add(0); * } * SortedSet<int> unionCN = new SortedSet<int>() { }; * for (int ii = 0; ii < listcn.Count; ii++)//得到所有的有序集合 * { * unionCN.UnionWith(listcn[ii]); * } * foreach (var unitem in unionCN) * { * if (newextend.Contains(TypeinsList[unitem])) * { * listjj[extendlist.IndexOf(TypeinsList[unitem])]++; * } * } * for (int i = 0; i < listjj.Count(); i++)//讲实例表分到不同的PA中 * { * * MessageBox.Show(listjj[i].ToString()); * } * * //测试行实例邻居 * Prevalence pc = new Prevalence(); * SortedSet<int> row = new SortedSet<int>() { 1, 4, 7 }; * * foreach (var item in pc.GetRowCN(row, INs)) * { * MessageBox.Show(item.ToString()); * } * * }*/ #endregion string pname = "1+2+4"; List <int> list1 = new List <int>(); list1.Add(1); list1.Add(2); list1.Add(3); list1.Add(4); list1.Add(5); StringInstance snew = new StringInstance(); // extendlist1 = LastCN[snew.SplitString1(pname, '+')[0] + "+extend"][0].ToList(); var extendlist2 = snew.SplitString1(pname, '+').Select <string, int>(x => Convert.ToInt32(x)); //将扩展特征中属于自身模式的特征去掉 extendlist2.ToList(); var extendlist3 = list1.Except(extendlist2); //得到所有的模式扩展候选特征集合 List <int> pnamelist = new List <int>(); //被扩展模式pk-1的特征集 pnamelist = extendlist2.ToList(); for (int i = 0; i < pnamelist.Count; i++) { MessageBox.Show(pnamelist[i].ToString()); } }//test函数结尾
//计算多阶模式 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); }