public static List <AssociationRule> Mine(ItemsetCollection db, ItemsetCollection L, double confidenceThreshold)
{
List <AssociationRule> allRules = new List <AssociationRule>();
foreach (Itemset itemset in L)
{
ItemsetCollection subsets = Bit.FindSubsets(itemset, 0); //get all subsets
foreach (Itemset subset in subsets)
{
double confidence = (db.FindSupport(itemset) / db.FindSupport(subset)) * 100.0;
if (confidence >= confidenceThreshold)
{
AssociationRule rule = new AssociationRule();
rule.X.AddRange(subset);
rule.Y.AddRange(itemset.Remove(subset));
rule.Support = db.FindSupport(itemset);//itemset.Support;// db.FindSupport(itemset);
rule.Confidence = confidence;
if (rule.X.Count > 0 && rule.Y.Count > 0)
{
allRules.Add(rule);
}
}
}
}
return(allRules);
}
public static ItemsetCollection FindSubsets(Itemset itemset, int n)
{
ItemsetCollection subsets = new ItemsetCollection();
BigInteger subsetCount = (BigInteger)Math.Pow(2, itemset.Count);
for (BigInteger i = 0; i < subsetCount; i++)
{
if (n == 0 || GetOnCount(i, itemset.Count) == n)
{
string binary = DecimalToBinary(i, itemset.Count);
Itemset subset = new Itemset();
for (int charIndex = 0; charIndex < binary.Length; charIndex++)
{
if (binary[charIndex] == '1')
{
subset.Add(itemset[charIndex]);
}
}
subsets.Add(subset);
}
}
return(subsets);
}
private double FindSupport(ItemsetCollection L, Itemset subset)
{
double min = 100;
foreach (Itemset itemset in L)
{
if (itemset.Contains(subset))
{
if (min > itemset.Support)
{
min = itemset.Support;
}
}
}
return(min);
}
private static FPTree CreateTree(ItemsetCollection T)
{
FPTree tree = new FPTree();
List[] list_frequencyItems_TID;
int i = 0;
list_frequencyItems_TID = ToList(T);
for (i = 0; i < T.Count; i++)
{
List list = new List();
list = list_frequencyItems_TID[i];
tree = tree.InsertNode(tree, list);
}
return(tree);
}
public static ItemsetCollection DoApriori(ItemsetCollection db, double supportThreshold)
{
Itemset I = db.GetUniqueItems();
ItemsetCollection L = new ItemsetCollection(); //resultant large itemsets
ItemsetCollection Li = new ItemsetCollection(); //large itemset in each iteration
ItemsetCollection Ci = new ItemsetCollection(); //pruned itemset in each iteration
//first iteration (1-item itemsets)
foreach (int item in I)
{
Ci.Add(new Itemset()
{
item
});
}
//next iterations
int k = 2;
while (Ci.Count != 0)
{
//set Li from Ci (pruning)
Li.Clear();
foreach (Itemset itemset in Ci)
{
itemset.Support = db.FindSupport(itemset);
if (itemset.Support >= supportThreshold)
{
Li.Add(itemset);
L.Add(itemset);
}
}
//set Ci for next iteration (find supersets of Li)
Ci.Clear();
Ci.AddRange(Bit.FindSubsets(Li.GetUniqueItems(), k)); //get k-item subsets
k += 1;
}
return(L);
}
private static List[] ToList(ItemsetCollection frequencyItemsTID)
{
List[] mangList = new List[frequencyItemsTID.Count];
int i = 0, j = 0;
for (i = 0; i < frequencyItemsTID.Count; i++)
{
List list = new List();
list = list.CreateList();
Node node = new Node();
//Tao List cho TID
if (frequencyItemsTID[i] != null)
{
for (j = 0; j < frequencyItemsTID[i].Count; j++)
{
node = node.CreateNode(frequencyItemsTID[i][j]);
list = list.InsertTail(list, node);
}
}
mangList[i] = list;
}
return(mangList);
}
public static ItemsetCollection DoAprioriNew(ItemsetCollection db, double supportThreshold)
{
//Itemset I = db.GetUniqueItems();
ItemsetCollection Fre = new ItemsetCollection(); //List of Items > support
ItemsetCollection L = new ItemsetCollection(); //resultant large itemsets
ItemsetCollection T = new ItemsetCollection(); //frequent items
//item > support
Itemset I = db.GetUniqueItems();
foreach (int item in I)
{
Itemset itemset = new Itemset()
{
item
};
itemset.Support = db.FindSupport(itemset);
if (itemset.Support >= supportThreshold)
{
Fre.Add(itemset);
}
}
ItemsetCollection subsets = Bit.FindSubsets(Fre.GetUniqueItems(), 0); //get all subsets
//Dictionary<Itemset, int> subsetsDic = subsets.Select((x, i) => new {x = x, i = 0 }).ToDictionary(k => k.x,k=>k.i);
//frequent items
foreach (Itemset itemdata in db)
{
Itemset itemset = new Itemset();
foreach (Itemset itemFre in Fre)
{
if (itemdata.Contains(itemFre[0]))
{
itemset.Add(itemFre[0]);
}
}
if (itemset.Count > 0)
{
T.Add(itemset);
foreach (Itemset items in subsets)
{
if (itemset.Contains(items))
{
items.Support++;
}
}
}
}
foreach (Itemset items in subsets)
{
if (items.Count > 0)
{
items.Support = (items.Support / (double)db.Count) * 100.0;
if (items.Support >= supportThreshold)
{
L.Add(items);
}
}
}
return(L);
}
public static ItemsetCollection DoFPGrowthParallel(ItemsetCollection db, double supportThreshold)
{
ItemsetCollection Fre = new ItemsetCollection(); //List of Items > support
ItemsetCollection T = new ItemsetCollection(); //frequent items
List <ItemsetCollection> P = new List <ItemsetCollection>();
ItemsetCollection FPTreeCon = new ItemsetCollection(); //Conditional FP-Tree
//item > support
//Itemset I = db.GetUniqueItems();
//foreach (string item in I)
//{
// Itemset itemset = new Itemset() { item };
// itemset.Support = db.FindSupport(itemset);
// if (itemset.Support >= supportThreshold)
// {
// Fre.Add(itemset);
// }
//}
//// sort item
//Fre.Sort(delegate (Itemset x, Itemset y)
//{
// if (x.Support > y.Support) return -1;
// else if (x.Support < y.Support)
// return 1;
// else return 0;
//});
////Fre = ParallelFre(db, supportThreshold);
////frequent items
//foreach (Itemset itemdata in db)
//{
// Itemset itemset = new Itemset();
// foreach (Itemset itemFre in Fre)
// {
// if (itemdata.Contains(itemFre[0]))
// {
// itemset.Add(itemFre[0]);
// }
// }
// T.Add(itemset);
//}
T = ParallelFPGrowth(db, supportThreshold, ref Fre);
// create FP Tree
FPTree tree = CreateTree(T);
// Conditional Patern Bases
foreach (Itemset itemset in Fre)
{
ItemsetCollection itemsetCollection = new ItemsetCollection();
for (int j = 0; j < tree.countNode; j++)
{
var node = tree.arrayNode[j];
if (node.itemName.Equals(itemset[0]) && !node.visited)
{
node.visited = true;
var nodeparent = node.nodeParent;
while (nodeparent.itemName > -1)
{
int index = itemsetCollection.FindIndex(nodeparent.itemName);
if (index > -1)
{
itemsetCollection[index].Support += node.count;
}
else
{
Itemset item = new Itemset();
item.Support = node.count;
item.Add(nodeparent.itemName);
itemsetCollection.Add(item);
}
nodeparent = nodeparent.nodeParent;
}
}
}
P.Add(itemsetCollection);
}
// Conditional FP-Tree
for (int i = 0; i < P.Count; i++)
{
ItemsetCollection itemsetCollection = new ItemsetCollection();
//itemsetCollection.Add(Fre[i]); //hoán vị sau
foreach (var item in P[i])
{
if (db.Support(item) >= supportThreshold)
{
itemsetCollection.Add(item);
}
}
ItemsetCollection subsets = Bit.FindSubsets(itemsetCollection.GetUniqueItems(), 0); //get all subsets
foreach (Itemset items in subsets)
{
items.Add(Fre[i][0]);
items.Support = db.FindSupport(items);
if (items.Support >= supportThreshold)
{
FPTreeCon.Add(items);
}
}
}
return(FPTreeCon);
}
private static ItemsetCollection ParallelFPGrowth(ItemsetCollection db, double supportThreshold, ref ItemsetCollection F)
{
ItemsetCollection Fre = new ItemsetCollection();//List of Items > support
Dictionary <int, int> ItemCount = new Dictionary <int, int>();
Dictionary <int, int> ItemCount1 = new Dictionary <int, int>();
ItemsetCollection T = new ItemsetCollection();//frequent items
ItemsetCollection T1 = new ItemsetCollection();
int n = db.Count / 2;
Thread t1 = new Thread(() =>
{
for (int i = 0; i < n; i++)
{
foreach (int item in db[i])
{
if (ItemCount1.ContainsKey(item))
{
ItemCount1[item] += 1;
}
else
{
ItemCount1.Add(item, 1);
}
}
}
});
t1.Start();
Thread t2 = new Thread(() =>
{
for (int j = n; j < db.Count; j++)
{
foreach (int item in db[j])
{
if (ItemCount.ContainsKey(item))
{
ItemCount[item] += 1;
}
else
{
ItemCount.Add(item, 1);
}
}
}
});
t2.Start();
t1.Join();
t2.Join();
foreach (KeyValuePair <int, int> keyvalue in ItemCount1)
{
if (ItemCount.ContainsKey(keyvalue.Key))
{
ItemCount[keyvalue.Key] += keyvalue.Value;
}
else
{
ItemCount.Add(keyvalue.Key, keyvalue.Value);
}
}
double count = db.Count;
foreach (KeyValuePair <int, int> keyvalue in ItemCount)
{
Itemset itemset = new Itemset()
{
keyvalue.Key
};
itemset.Support = ((double)keyvalue.Value / count) * 100.0;
if (itemset.Support >= supportThreshold)
{
Fre.Add(itemset);
}
}
Fre.Sort(delegate(Itemset x, Itemset y)
{
if (x.Support > y.Support)
{
return(-1);
}
else if (x.Support < y.Support)
{
return(1);
}
else
{
return(0);
}
});
F = Fre;
Thread t11 = new Thread(() =>
{
for (int i = 0; i < n; i++)
{
Itemset itemset = new Itemset();
foreach (Itemset itemFre in Fre)
{
if (db[i].Contains(itemFre[0]))
{
itemset.Add(itemFre[0]);
}
}
if (itemset.Count > 0)
{
T1.Add(itemset);
}
}
});
t11.Start();
Thread t12 = new Thread(() =>
{
for (int i = n; i < db.Count; i++)
{
Itemset itemset = new Itemset();
foreach (Itemset itemFre in Fre)
{
if (db[i].Contains(itemFre[0]))
{
itemset.Add(itemFre[0]);
}
}
if (itemset.Count > 0)
{
T.Add(itemset);
}
}
});
t12.Start();
t11.Join();
t12.Join();
foreach (var item in T1)
{
T.Add(item);
}
return(T);
}
