public void All_rules_are_returned_for_minsup_0_and_minconf_0()
{
//Given
var a = new ItemSet <IFact <string> >(factA);
var b = new ItemSet <IFact <string> >(factB);
Database <string> database = new Database <string>(new List <string>()
{
"A", "B"
});
var ruleGenerator = new AssociationRuleGenerator <string>(database, apriori, candidateRuleGenerator, filterer);
//When
var rules = ruleGenerator.Generate(0, 0);
//Then
var aImpliesB = new AssociationRule <string>(a, b);
var bImpliesA = new AssociationRule <string>(b, a);
Assert.Equal(2, rules.Count);
Assert.Contains(aImpliesB, rules);
Assert.Contains(bImpliesA, rules);
aImpliesB = rules.Find(x => x.Equals(aImpliesB));
bImpliesA = rules.Find(x => x.Equals(bImpliesA));
Assert.Equal(0, aImpliesB.RelativeSupport);
Assert.Equal(0, bImpliesA.RelativeSupport);
Assert.Equal(0, aImpliesB.Confidence);
Assert.Equal(0, bImpliesA.Confidence);
}
public AssociationRule CreateRule(AssociationRule associationRule)
{
using (var cc = new CustomersContext())
{
AssociationRule rule = new AssociationRule();
List <AssociationRule> rules = cc.AssociationRules.ToList();
bool found = false;
foreach (var item in rules)
{
if (associationRule.Equals(item))
{
rule = item;
found = true;
break;
}
}
if (!found)
{
rule = cc.AssociationRules.Add(new AssociationRule()
{
Confidence = associationRule.Confidence
});
cc.SaveChanges();
return(rule);
}
else
{
rule.Confidence = associationRule.Confidence;
cc.SaveChanges();
return(null);
}
}
}
public List <AssociationRule> SaveToDatabase(List <AssociationRule> associationRules)
{
IAssociationRuleRepository associationRuleRepository = new AssociationRuleRepository();
IRuleConditionRepository ruleConditionRepository = new RuleConditionRepository();
IRuleResultRepository ruleResultRepository = new RuleResultRepository();
List <AssociationRule> createdAssociationRules = new List <AssociationRule>();
foreach (var associationRule in associationRules)
{
AssociationRule createdRule = associationRuleRepository.CreateRule(associationRule);
if (createdRule != null)
{
foreach (var condition in associationRule.RuleConditions)
{
condition.RuleId = createdRule.Id;
RuleCondition createdCondition = ruleConditionRepository.CreateCondition(condition);
createdRule.RuleConditions.Add(createdCondition);
}
foreach (var result in associationRule.RuleResults)
{
result.RuleId = createdRule.Id;
RuleResult createdResult = ruleResultRepository.CreateResult(result);
createdRule.RuleResults.Add(createdResult);
}
createdAssociationRules.Add(createdRule);
}
}
return(createdAssociationRules);
}
public IEnumerable <FlatDimensionDto> GetFilterValues(AssociationRule rule)
{
var ret = new List <FlatDimensionDto>();
foreach (var condition in rule.ConditionValues)
{
var dimension = _data.GetDimension(condition.Dimension.Id);
var dimensionDto = new FlatDimensionDto
{
Id = dimension.Id,
Name = dimension.Name,
DimensionValues = new List <DimensionValueDto>(),
DatasetName = rule.MiningTask.DataSet.Name,
Prefix = rule.MiningTask.DataSet.GetPrefix()
};
var allValues = _data.GetAllDimValues(dimension.Id);
var dimValue = allValues.Single(dv => dv.Value == condition.Value);
dimensionDto.DimensionValues.Add(new DimensionValueDto
{
Dimension = dimensionDto,
Value = dimValue.Value,
Id = _querier.GetValuesOfDimension(dimensionDto, new Column
{
Name = Constants.String.Value,
Value = dimValue.Value
}).Single().Id
});
ret.Add(dimensionDto);
}
return(ret);
}
public void Only_rules_meeting_minsup_and_minconf_requirements_are_returned()
{
//Given
var ab = new ItemSet <IFact <string> >(new List <IFact <string> >()
{
factA, factB
});
var abc = new ItemSet <IFact <string> >(new List <IFact <string> >()
{
factA, factB, factC
});
var bc = new ItemSet <IFact <string> >(new List <IFact <string> >()
{
factB, factC
});
Database <string> database = new Database <string>(new List <string>()
{
"AB", "ABC", "BC"
});
var ruleGenerator = new AssociationRuleGenerator <string>(database, apriori, candidateRuleGenerator, filterer);
//When
var rules = ruleGenerator.Generate(0.5, 0.6);
//Then
var a = new ItemSet <IFact <string> >(factA);
var b = new ItemSet <IFact <string> >(factB);
var c = new ItemSet <IFact <string> >(factC);
var aImpliesB = new AssociationRule <string>(a, b);
var bImpliesA = new AssociationRule <string>(b, a);
var cImpliesB = new AssociationRule <string>(c, b);
var bImpliesC = new AssociationRule <string>(b, c);
Assert.Equal(4, rules.Count);
Assert.Contains(aImpliesB, rules);
Assert.Contains(bImpliesA, rules);
Assert.Contains(cImpliesB, rules);
Assert.Contains(bImpliesC, rules);
aImpliesB = rules.Find(x => x.Equals(aImpliesB));
bImpliesA = rules.Find(x => x.Equals(bImpliesA));
cImpliesB = rules.Find(x => x.Equals(cImpliesB));
bImpliesC = rules.Find(x => x.Equals(bImpliesC));
Assert.Equal(2.0 / 3, aImpliesB.RelativeSupport);
Assert.Equal(2.0 / 3, bImpliesA.RelativeSupport);
Assert.Equal(2.0 / 3, cImpliesB.RelativeSupport);
Assert.Equal(2.0 / 3, bImpliesC.RelativeSupport);
Assert.Equal(1, aImpliesB.Confidence);
Assert.Equal(2.0 / 3, bImpliesA.Confidence);
Assert.Equal(1, cImpliesB.Confidence);
Assert.Equal(2.0 / 3, bImpliesC.Confidence);
}
private AssociationRule GetMatchingRule(List <AssociationRule> rules, AssociationRule rule)
{
return(rules
.SingleOrDefault(assocRule =>
DimensionValuesMatch(assocRule.AntecedentValues.ToList(), rule.AntecedentValues.ToList()) &&
DimensionValuesMatch(assocRule.ConditionValues.ToList(), rule.ConditionValues.ToList()) &&
SuccedentMeasuresMatch(assocRule.Succedents.FirstOrDefault(), rule.Succedents.Single())));
}
public List <AssociationRule> GetRules(List <DimensionValue> dimensionValues, List <Measure> measures)
{
var ret = new List <AssociationRule>();
var associationRules = _doc.SelectNodes("//*[local-name()='AssociationRule']");
var dbas = _doc.SelectNodes("//*[local-name()='DBA']").Cast <XmlNode>().ToList();
foreach (XmlNode rule in associationRules)
{
var antecedentName = rule.Attributes["antecedent"].InnerText;
var succedentName = rule.Attributes["consequent"].InnerText;
var antecedentDba = dbas.Single(dba => dba.Attributes["id"].InnerText == antecedentName);
var succedentDba = dbas.Single(dba => dba.Attributes["id"].InnerText == succedentName);
var antecedentText =
antecedentDba.ChildNodes.Cast <XmlNode>().Single(childNode => childNode.LocalName.Equals("Text")).InnerText;
var succedentText =
succedentDba.ChildNodes.Cast <XmlNode>().Single(childNode => childNode.LocalName.Equals("Text")).InnerText;
var aadString =
rule.ChildNodes.Cast <XmlNode>()
.Single(
childNode =>
childNode.LocalName.Equals("IMValue") &&
childNode.Attributes["name"].InnerText == "AAD")
.InnerText;
var aadValue = Convert.ToDouble(aadString, NumberFormatInfo.InvariantInfo);
var baseString =
rule.ChildNodes.Cast <XmlNode>()
.Single(
childNode =>
childNode.LocalName.Equals("IMValue") &&
childNode.Attributes["name"].InnerText == "BASE")
.InnerText;
var baseValue = Convert.ToDouble(baseString, NumberFormatInfo.InvariantInfo);
var ruleText = rule.ChildNodes.Cast <XmlNode>().Single(childNode => childNode.LocalName.Equals("Text")).InnerText;
var assocRule = new AssociationRule
{
Text = ruleText,
AntecedentValues = GetLiteralConjunction(antecedentText, dimensionValues),
Succedents = new List <Succedent> {
GetSuccedent(succedentText, measures, aadValue, baseValue)
},
ConditionValues = new List <DimensionValue>()
};
var conditionExists = rule.Attributes["condition"] != null;
if (conditionExists)
{
var conditionName = rule.Attributes["condition"].InnerText;
var conditionDba = dbas.Single(dba => dba.Attributes["id"].InnerText == conditionName);
var conditionText =
conditionDba.ChildNodes.Cast <XmlNode>().Single(childNode => childNode.LocalName.Equals("Text")).InnerText;
assocRule.ConditionValues = GetLiteralConjunction(conditionText, dimensionValues);
}
ret.Add(assocRule);
}
return(ret);
}
//confidence = 80%
private List <AssociationRule> GetRules()
{
List <AssociationRule> allRules = new List <AssociationRule>();
AssociationRule rule1 = new AssociationRule();
rule1.X = new Itemset {
5
};
rule1.Y = new Itemset {
2
};
rule1.Confidence = 100;
allRules.Add(rule1);
AssociationRule rule2 = new AssociationRule();
rule2.X = new Itemset {
2
};
rule2.Y = new Itemset {
5
};
rule2.Confidence = 100;
allRules.Add(rule2);
AssociationRule rule3 = new AssociationRule();
rule3.X = new Itemset {
1
};
rule3.Y = new Itemset {
3
};
rule3.Confidence = 100;
allRules.Add(rule3);
AssociationRule rule4 = new AssociationRule();
rule4.X = new Itemset {
5, 3
};
rule4.Y = new Itemset {
2
};
rule4.Confidence = 100;
allRules.Add(rule4);
AssociationRule rule5 = new AssociationRule();
rule5.X = new Itemset {
2, 3
};
rule5.Y = new Itemset {
5
};
rule5.Confidence = 100;
allRules.Add(rule5);
return(allRules);
}
public List <AssociationRule> ProccessApriori(double minSupport, double minConfidence, List <Product> products, List <Purchase> purchases)
{
Dictionary <List <Product>, double> frequentItems = GetL1FrequentItems(minSupport, products, purchases);
Dictionary <List <Product>, double> allFrequentItems = new Dictionary <List <Product>, double>();
foreach (var item in frequentItems)
{
allFrequentItems.Add(item.Key, item.Value);
}
Dictionary <List <Product>, double> candidates = new Dictionary <List <Product>, double>();
double purchasesCount = purchases.Count;
do
{
candidates = GenerateCandidates(frequentItems, purchases);
frequentItems = GetFrequentItems(candidates, minSupport, purchasesCount);
foreach (var item in frequentItems)
{
if (!allFrequentItems.ContainsKey(item.Key))
{
allFrequentItems.Add(item.Key, item.Value);
}
}
}while (candidates.Count != 0);
HashSet <Rule> rules = GenerateRules(allFrequentItems);
List <Rule> strongRules = GetStrongRules(minConfidence, rules, allFrequentItems);
List <AssociationRule> AssociationRules = new List <AssociationRule>();
foreach (var rule in strongRules)
{
AssociationRule associationRule = new AssociationRule();
foreach (var cond in rule.xList)
{
RuleCondition condition = new RuleCondition();
condition.ProductId = cond.Id;
associationRule.RuleConditions.Add(condition);
}
foreach (var res in rule.yList)
{
RuleResult result = new RuleResult();
result.ProductId = res.Id;
associationRule.RuleResults.Add(result);
}
associationRule.Confidence = Convert.ToDecimal(rule.Confidence);
AssociationRules.Add(associationRule);
}
List <AssociationRule> savedRules = SaveToDatabase(AssociationRules);
return(savedRules);
}
public void Generate()
{
ConcurrentBag <AssociationRule> result = new ConcurrentBag <AssociationRule>();
foreach (Row row in InformationSystem.Rows)
{
List <Attribute> attrs = row.Attributes.Where(x =>
InformationSystem.DecisionAttributes[x.Name] == true).Select(x => x).ToList();
foreach (Attribute decisionAttribute in attrs)
{
Condition decisionAttributeInResult = new Condition(decisionAttribute);
IList <Condition> conditions = new List <Condition>();
separatedRows = InformationSystem.Rows.GetRowsSeparatedByAttribute(row, decisionAttribute);
IList <Row> separatedRowsCopy = separatedRows;
int alreadyCovered = 0;
while (alreadyCovered < MinimumNumberOfRowsToSeparate)
{
IList <Subset> subsets = separatedRowsCopy.CreateSubsets(row, decisionAttribute, true);
string subsetWithMaxElements = subsets
.OrderByDescending(x => x.Quotient)
.Select(x => x.Name)
.First();
alreadyCovered += subsets.Where(x => x.Name == subsetWithMaxElements)
.Select(x => x.Count).First();
conditions.Add(new Condition(
row.Attributes.Where(x => x.Name == subsetWithMaxElements).First()));
separatedRowsCopy = separatedRowsCopy
.RemoveElementsFromAlreadyCoveredSubsets(subsets, subsetWithMaxElements);
}
var rule = new AssociationRule(conditions, decisionAttributeInResult);
var supportAndConfidence = rule.CalculateSupportAndConfidence(InformationSystem.Rows);
rule.Support = supportAndConfidence.Item1.Round();
rule.Confidence = supportAndConfidence.Item2.Round();
result.Add(rule);
alreadyCovered = 0;
separatedRows = null;
}
}
Rules(result);
}
public static Tuple <decimal, decimal> CalculateSupportAndConfidence(this AssociationRule rule,
IList <Row> rows)
{
List <bool> contains;
int rowsContainsAllConditions = 0;
int result = 0;
bool containsDecisionAttr = false;
foreach (Row singleRow in rows)
{
contains = new List <bool>();
foreach (var singleCondition in rule.Conditions)
{
if (singleRow.Attributes.Contains(singleCondition.Attribute))
{
contains.Add(true);
}
}
if (singleRow.Attributes.Contains(rule.Decision.Attribute))
{
containsDecisionAttr = true;
}
if (contains.Count == rule.Conditions.Count && containsDecisionAttr == true)
{
result++;
}
if (contains.Count == rule.Conditions.Count)
{
rowsContainsAllConditions++;
}
containsDecisionAttr = false;
}
rule.RowsQuantity = result;
decimal support = System.Convert.ToDecimal(result * 100) / rows.Count;
decimal confidence = System.Convert.ToDecimal(result * 100) / rowsContainsAllConditions;
return(new Tuple <decimal, decimal>(support, confidence));
}
public Tuple <int, int> GetXAndLegendDimensionsId(AssociationRule rule, DimensionTree tree)
{
int xDimId, legendDimId;
switch (rule.AntecedentValues.Count)
{
case 1:
xDimId = rule.AntecedentValues.Single().Dimension.Id;
legendDimId = rule.ConditionValues.Any() ? rule.ConditionValues.First().Dimension.Id : 0;
break;
case 2:
var firstDimension = rule.AntecedentValues.ToList()[0].Dimension;
var secondDimension = rule.AntecedentValues.ToList()[1].Dimension;
var firstIsRoot = tree.IsRoot(firstDimension.Id);
var secondIsRoot = tree.IsRoot(secondDimension.Id);
if (firstIsRoot != secondIsRoot)
{
if (firstIsRoot)
{
xDimId = firstDimension.Id;
legendDimId = secondDimension.Id;
}
else
{
xDimId = secondDimension.Id;
legendDimId = firstDimension.Id;
}
}
else
{
xDimId = firstDimension.Id;
legendDimId = secondDimension.Id;
}
break;
default:
throw new InvalidDataException($"Wrong count of antecedent values in rule {rule.Id}.");
}
return(Tuple.Create(xDimId, legendDimId));
}
/// <summary>
/// Iterative rules generating method
/// </summary>
/// <param name="itemset">Frequent pattern ItemSet from which we generate rules</param>
/// <param name="LookupRules">LookUp association rule list</param>
private void GenRule(ItemSet itemset, List <AssociationRule> LookupRules)
{
int bits = itemset.ItemsNumber;
UInt64 enumerator = 1;
UInt64 combination;
UInt64 max = 1;
int index;
// max represent "overflow" condition
max = max << bits;
while (enumerator < max)
{
index = 0;
combination = enumerator;
// left side creation LHR (am_1)
ItemSet am_1 = new ItemSet();
while (combination > 0)
{
if ((combination % 2) == 1)
{
am_1.Add(itemset.Items[index]);
}
combination = combination >> 1;
index++;
}
// Current rule creation
AssociationRule rule = new AssociationRule();
rule.LeftSide = am_1;
rule.RightSide = itemset - am_1;
rule.LeftSide.ItemsSupport = 0;
rule.RightSide.ItemsSupport = 0;
rule.Support = itemset.ItemsSupport;
if (!((rule.LeftSide.ItemsNumber == 0) || (rule.RightSide.ItemsNumber == 0)))
{
LookupRules.Add(rule);
}
enumerator++;
}
}
public static Tuple <int, int> CalculateUpperAndLowerBound(this AssociationRule rule,
int minimumNumberOfRowsToSeparate, IList <int> deltas)
{
int upperBound = rule.Length;
List <decimal> l = new List <decimal>();
for (int i = 0; i < deltas.Count; i++)
{
int counter = 0;
for (int j = 1; j <= i; j++)
{
//if (j == 0)
//{
// continue;
//}
//else
//{
//try
//{
counter += deltas[j - 1];
//}
//catch (ArgumentOutOfRangeException)
//{
//}
}
int denominator = deltas[i];
var iteration = Math.Ceiling(
Convert.ToDecimal(minimumNumberOfRowsToSeparate - counter) / denominator);
l.Add(iteration);
}
int lowerBound = Convert.ToInt32(l.Max());
return(new Tuple <int, int>(upperBound, lowerBound));
}
public List <AssociationRule> GenerateRules(List <ItemSet> patterns, double minSupport, double minConfidence)
{
DateTime start = DateTime.Now;
Console.WriteLine("Generating rules for {0} patterns...", patterns.Count);
ARuleCalculator calc = new ARuleCalculator(patterns, dataSet.Count);
List <AssociationRule> rules = new List <AssociationRule>();
foreach (ItemSet pattern in patterns)
{
if (pattern.Items.Count() >= 2)
{
foreach (var item in pattern.Items)
{
IEnumerable <string> rule_from = pattern.Items.Where(p => !p.Equals(item)).ToList();
string rule_to = item;
AssociationRule rule = new AssociationRule(rule_from, rule_to);
rule.Support = pattern.Support / dataSet.Count;
rule.Confidence = calc.GetConfidence(rule.Support, rule.Rule_From);
if (rule.Confidence >= minConfidence)
{
rule.Lift = calc.GetLift(rule.Confidence, rule.Rule_To);
if (rule.Lift > 1)
{
rules.Add(rule);
}
}
}
}
}
DateTime end = DateTime.Now;
Console.WriteLine("Generated {0} rules in {1} seconds", rules.Count, (end - start).TotalSeconds);
return(rules);
}
public void Generate()
{
ConcurrentBag <AssociationRule> result = new ConcurrentBag <AssociationRule>();
var task = Task.Factory.StartNew(() =>
{
int index = 0;
foreach (Row row in InformationSystem.Rows)
{
var counter = Task.Factory.StartNew(() =>
{
lock (locker)
{
Notify(++index);
if (index == InformationSystem.Rows.Count)
{
Rules(result);
}
}
}, CancellationToken.None, TaskCreationOptions.None, scheduler);
#region algorithm body
decimal gamma = InformationSystem.Gamma;
decimal alpha = InformationSystem.Alpha;
IList <Row> separatedRows;
List <Attribute> attrs = row.Attributes.Where(x =>
InformationSystem.DecisionAttributes[x.Name] == true).Select(x => x).ToList();
foreach (Attribute decisionAttribute in attrs)
{
Condition decisionAttributeInResult = new Condition(decisionAttribute);
IList <Condition> conditions = new List <Condition>();
separatedRows = InformationSystem.Rows.GetRowsSeparatedByAttribute(row, decisionAttribute);
decimal M = System.Math.Ceiling(separatedRows.Count() * (1 - alpha));
decimal N = System.Math.Ceiling(separatedRows.Count() * (1 - gamma));
IList <Row> separatedRowsCopy = separatedRows;
int alreadyCovered = 0;
while (alreadyCovered < M)
{
IList <Subset> subsets = separatedRowsCopy.CreateSubsets(row, decisionAttribute, false);
//here we must calculate for each subset its quotient: w(fj)/min(|U(T,r,d,fj)\D|,N-|D|)
//where D is output set, empty at the beginning
Dictionary <Subset, decimal> quotients = new Dictionary <Subset, decimal>();
subsets.Where(x => x.Count > 0).ToList().ForEach(subset =>
{
quotients[subset] =
System.Convert.ToDecimal(Weights.Where(x => x.Key == subset.Name)
.Select(x => x.Value).First()) /
System.Math.Min(subset.Rows.Count, N - alreadyCovered);
});
string subsetWithMinimumQuotient = quotients
.OrderBy(x => x.Value)
.Select(x => x.Key)
.First()
.Name;
alreadyCovered += subsets.Where(x => x.Name == subsetWithMinimumQuotient)
.Select(x => x.Count).First();
conditions.Add(new Condition(
row.Attributes.Where(x => x.Name == subsetWithMinimumQuotient).First()));
separatedRowsCopy = separatedRowsCopy
.RemoveElementsFromAlreadyCoveredSubsets(subsets, subsetWithMinimumQuotient);
}
var rule = new AssociationRule(conditions, decisionAttributeInResult);
var supportAndConfidence = rule.CalculateSupportAndConfidence(InformationSystem.Rows);
rule.Support = supportAndConfidence.Item1.Round();
rule.Confidence = supportAndConfidence.Item2.Round();
result.Add(rule);
alreadyCovered = 0;
separatedRows = null;
}
#endregion
}
return(result);
});
}
/// <summary>
/// Construct (partial) association rules.
/// </summary>
public IEnumerable <RuleCount> Generate()
{
int index = 0;
//TaskScheduler sch = TaskScheduler.Current;
List <ConcurrentBag <AssociationRule> > result2 =
new List <ConcurrentBag <AssociationRule> >();
ConcurrentBag <AssociationRule> result =
new ConcurrentBag <AssociationRule>();
// Parallel.ForEach(InformationSystem.Rows, (row) => //
Task[] tasks = new Task[InformationSystem.Rows.Count];
// foreach (Row row in InformationSystem.Rows)
// {
for (int i = 0; i < InformationSystem.Rows.Count; i++)
{
tasks[i] = new Task((n) =>
{
#region body
IList <Row> separatedRows;
var row = InformationSystem.Rows[i];
ConcurrentBag <AssociationRule> result3 = new ConcurrentBag <AssociationRule>();
foreach (Attribute decisionAttribute in row.Attributes)
//each attribute is treated as a decision attribute
{
Condition
decisionAttributeInResult
=
new Condition(
decisionAttribute);
IList <Condition> conditions =
new List <Condition>();
separatedRows =
InformationSystem.Rows.GetRowsSeparatedByAttribute(row, decisionAttribute);
IList <Row> separatedRowsCopy = separatedRows;
int alreadyCovered = 0;
int minimumNumberOfRowsToSeparate
= System.Convert.ToInt32(
System.Math.Ceiling((1 - InformationSystem.Alpha) * separatedRows.Count));
while (alreadyCovered < minimumNumberOfRowsToSeparate)
{
IList <Subset> subsets =
separatedRowsCopy.CreateSubsets(row, decisionAttribute);
string
subsetWithMaxElements = subsets.OrderByDescending(x => x.Count)
.Select(x => x.Name)
.First();
alreadyCovered +=
subsets.Where(
x =>
x.Name ==
subsetWithMaxElements)
.Select(
x => x.Count)
.First();
conditions.Add(new Condition
(
row.Attributes.Where(x => x
.Name ==
subsetWithMaxElements)
.First
()));
separatedRowsCopy = separatedRowsCopy
.RemoveElementsFromAlreadyCoveredSubsets
(subsets,
subsetWithMaxElements);
}
var rule = new AssociationRule(
conditions,
decisionAttributeInResult);
rule.Support = decimal.Round(
rule.CalculateSupport(
InformationSystem.Rows), 2);
rule.Confidence = decimal.Round(
rule.CalculateConfidence(
InformationSystem.Rows), 2);
result.Add(rule);
// result3.Add(rule);
// );
alreadyCovered = 0;
separatedRows = null;
}
//
#endregion
}, CancellationToken.None, TaskCreationOptions.LongRunning);
tasks[i].ContinueWith((p) =>
{
int o;
lock (locker)
{
o = ++index;
}
Notify(o);
}
, CancellationToken.None, TaskContinuationOptions.None, Scheduler);
tasks[i].Start();
tasks[i].Wait();
}
// Task.WaitAll(tasks);
var group = result.GroupBy(
z => z,
(rule, count) => new RuleCount
{
Rule = rule,
Count = count.Count()
},
new AssociationRulesComparer());
return(group);
}
public void Generate()
{
ConcurrentBag <AssociationRule> result = new ConcurrentBag <AssociationRule>();
var task = Task.Factory.StartNew(() =>
{
int index = 0;
foreach (Row row in InformationSystem.Rows)
{
var counter = Task.Factory.StartNew(() =>
{
lock (locker)
{
Notify(++index);
if (index == InformationSystem.Rows.Count)
{
Rules(result);
}
}
}, CancellationToken.None, TaskCreationOptions.None, scheduler);
#region algorithm body
IList <Row> separatedRows;
List <Attribute> attrs = row.Attributes.Where(x =>
InformationSystem.DecisionAttributes[x.Name] == true).Select(x => x).ToList();
foreach (Attribute decisionAttribute in attrs)
{
Condition decisionAttributeInResult = new Condition(decisionAttribute);
IList <Condition> conditions = new List <Condition>();
separatedRows =
InformationSystem.Rows.
GetRowsSeparatedByAttribute
(row,
decisionAttribute);
IList <Row> separatedRowsCopy = separatedRows;
int alreadyCovered = 0;
int minimumNumberOfRowsToSeparate
= System.Convert.ToInt32(System.Math
.Ceiling((1 - InformationSystem.Alpha) * separatedRows.Count));
while (alreadyCovered < minimumNumberOfRowsToSeparate)
{
IList <Subset> subsets = separatedRowsCopy.CreateSubsets(row, decisionAttribute, true);
string subsetWithMaxElements = subsets
.OrderByDescending(x => x.Quotient)
.Select(x => x.Name)
.First();
alreadyCovered += subsets.Where(
x => x.Name == subsetWithMaxElements)
.Select(x => x.Count)
.First();
conditions.Add(new Condition(
row.Attributes.Where(x => x.Name == subsetWithMaxElements).First()));
separatedRowsCopy = separatedRowsCopy
.RemoveElementsFromAlreadyCoveredSubsets
(subsets, subsetWithMaxElements);
}
var rule = new AssociationRule(conditions, decisionAttributeInResult);
var supportAndConfidence = rule.CalculateSupportAndConfidence(InformationSystem.Rows);
rule.Support = supportAndConfidence.Item1.Round();
rule.Confidence = supportAndConfidence.Item2.Round();
result.Add(rule);
alreadyCovered = 0;
separatedRows = null;
}
#endregion
}
return(result);
});
}
public void Generate()
{
ConcurrentBag <AssociationRule> result = new ConcurrentBag <AssociationRule>();
ConcurrentBag <AlgorithmProgressExecution> algExecution = new ConcurrentBag <AlgorithmProgressExecution>();
ConcurrentBag <Task> tasks = new ConcurrentBag <Task>();
int index = 0;
foreach (Row singleRow in InformationSystem.Rows)
{
List <Attribute> attrs = singleRow.Attributes.Where(x =>
InformationSystem.DecisionAttributes[x.Name] == true).Select(x => x).ToList();
foreach (Attribute decisionAttribute in attrs)
{
var localCopy = System.Tuple.Create <Row, Attribute>(singleRow, decisionAttribute);
Task <AssociationRule> task = Task.Factory.StartNew <AssociationRule>((variables) =>
{
var decAttr = ((System.Tuple <Row, Attribute>)variables).Item2;
var row = ((System.Tuple <Row, Attribute>)variables).Item1;
#region algorithm body
Condition decisionAttributeInResult = new Condition(decAttr);
IList <Condition> conditions = new List <Condition>();
IList <Row> separatedRows;
separatedRows =
InformationSystem.Rows.
GetRowsSeparatedByAttribute
(row,
decAttr);
IList <Row> separatedRowsCopy = separatedRows;
int alreadyCovered = 0;
List <int> deltas = new List <int>();
int minimumNumberOfRowsToSeparate
= System.Convert.ToInt32(System.Math
.Ceiling((1 - InformationSystem.Alpha) * separatedRows.Count));
AlgorithmProgressExecution progress = new AlgorithmProgressExecution()
{
DecisionAttribute = decAttr
};
while (alreadyCovered < minimumNumberOfRowsToSeparate)
{
AlgorithmIteration iteration = new AlgorithmIteration()
{
IterationNumber = progress.Iterations.Count() + 1,
ObjectsToCover = separatedRowsCopy.Count
};
IList <Subset> subsets = separatedRowsCopy.CreateSubsets(row, decAttr, true);
string subsetWithMaxElements = subsets
.OrderByDescending(x => x.Quotient)
.Select(x => x.Name)
.First();
//alreadyCovered += subsets.Where(
// x => x.Name == subsetWithMaxElements)
// .Select(x => x.Count)
// .First();
int elementsQuantityInSelectedSubset = subsets.Where(
x => x.Name == subsetWithMaxElements)
.Select(x => x.Count)
.First();
iteration.ObjectsCovered = elementsQuantityInSelectedSubset;
deltas.Add(elementsQuantityInSelectedSubset);
alreadyCovered += elementsQuantityInSelectedSubset;
conditions.Add(new Condition(
row.Attributes.Where(x => x.Name == subsetWithMaxElements).First()));
separatedRowsCopy = separatedRowsCopy
.RemoveElementsFromAlreadyCoveredSubsets
(subsets, subsetWithMaxElements);
progress.Iterations.Add(iteration);
}
var rule = new AssociationRule(conditions, decisionAttributeInResult);
var supportAndConfidence = rule.CalculateSupportAndConfidence(InformationSystem.Rows);
rule.Support = supportAndConfidence.Item1.Round();
rule.Confidence = supportAndConfidence.Item2.Round();
var upperLowerBound = rule.CalculateUpperAndLowerBound(minimumNumberOfRowsToSeparate, deltas);
rule.UpperBound = upperLowerBound.Item1;
rule.LowerBound = upperLowerBound.Item2;
algExecution.Add(progress);
#endregion
return(rule);
}, localCopy, CancellationToken.None, TaskCreationOptions.AttachedToParent, TaskScheduler.Default);
task.ContinueWith(x =>
{
if (x.Status == TaskStatus.RanToCompletion)
{
lock (locker)
{
result.Add(((Task <AssociationRule>)x).Result);
Notify(++index);
}
}
}, CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, guiScheduler);
tasks.Add(task);
}
}
var finish = Task.Factory.ContinueWhenAll(tasks.ToArray(), x =>
{
SeparatedRows(algExecution);
Rules(result);
}, CancellationToken.None, TaskContinuationOptions.None, guiScheduler);
}
public void Generate()
{
ConcurrentBag <AssociationRule> result = new ConcurrentBag <AssociationRule>();
ConcurrentBag <AlgorithmProgressExecution> algExecution = new ConcurrentBag <AlgorithmProgressExecution>();
ConcurrentBag <Task> tasks = new ConcurrentBag <Task>();
int index = 0;
foreach (Row singleRow in InformationSystem.Rows)
{
decimal gamma = InformationSystem.Gamma;
decimal alpha = InformationSystem.Alpha;
List <Attribute> attrs = singleRow.Attributes.Where(x =>
InformationSystem.DecisionAttributes[x.Name] == true).Select(x => x).ToList();
foreach (Attribute decisionAttribute in attrs)
{
var localCopy = System.Tuple.Create <Row, Attribute>(singleRow, decisionAttribute);
Task <AssociationRule> task = Task.Factory.StartNew <AssociationRule>((variables) =>
{
var decAttr = ((System.Tuple <Row, Attribute>)variables).Item2;
var row = ((System.Tuple <Row, Attribute>)variables).Item1;
#region algorithm body
IList <Row> separatedRows;
Condition decisionAttributeInResult = new Condition(decAttr);
//List<int> deltas = new List<int>();
IList <Condition> conditions = new List <Condition>();
separatedRows = InformationSystem.Rows.GetRowsSeparatedByAttribute(row, decAttr);
decimal M = System.Math.Ceiling(separatedRows.Count() * (1 - alpha));
decimal N = System.Math.Ceiling(separatedRows.Count() * (1 - gamma));
IList <Row> separatedRowsCopy = separatedRows;
int alreadyCovered = 0;
AlgorithmProgressExecution progress = new AlgorithmProgressExecution()
{
DecisionAttribute = decAttr
};
while (alreadyCovered < M)
{
AlgorithmIteration iteration = new AlgorithmIteration()
{
IterationNumber = progress.Iterations.Count() + 1,
ObjectsToCover = separatedRowsCopy.Count
};
IList <Subset> subsets = separatedRowsCopy.CreateSubsets(row, decAttr, false);
//here we must calculate for each subset its quotient: w(fj)/min(|U(T,r,d,fj)\D|,N-|D|)
//where D is output set, empty at the beginning
Dictionary <Subset, decimal> quotients = new Dictionary <Subset, decimal>();
subsets.Where(x => x.Count > 0).ToList().ForEach(subset =>
{
quotients[subset] =
System.Convert.ToDecimal(Weights.Where(x => x.Key == subset.Name)
.Select(x => x.Value).First()) /
System.Math.Min(subset.Rows.Count, N - alreadyCovered);
});
string subsetWithMinimumQuotient = quotients
.OrderBy(x => x.Value)
.Select(x => x.Key)
.First()
.Name;
var elementsQuantityInSelectedSubset = subsets.Where(x => x.Name == subsetWithMinimumQuotient)
.Select(x => x.Count).First();
alreadyCovered += elementsQuantityInSelectedSubset;
//int elementsQuantityInSelectedSubset = subsets.Where(
// x => x.Name == subsetWithMinimumQuotient)
// .Select(x => x.Count)
// .First();
iteration.ObjectsCovered = elementsQuantityInSelectedSubset;
//deltas.Add(elementsQuantityInSelectedSubset);
//alreadyCovered += elementsQuantityInSelectedSubset;
conditions.Add(new Condition(
row.Attributes.Where(x => x.Name == subsetWithMinimumQuotient).First()));
separatedRowsCopy = separatedRowsCopy
.RemoveElementsFromAlreadyCoveredSubsets(subsets, subsetWithMinimumQuotient);
progress.Iterations.Add(iteration);
}
var rule = new AssociationRule(conditions, decisionAttributeInResult);
var supportAndConfidence = rule.CalculateSupportAndConfidence(InformationSystem.Rows);
rule.Support = supportAndConfidence.Item1.Round();
rule.Confidence = supportAndConfidence.Item2.Round();
//var upperLowerBound = rule.CalculateUpperAndLowerBound(System.Convert.ToInt32(M), deltas);
rule.UpperBound = -1; // upperLowerBound.Item1;
rule.LowerBound = -1; //upperLowerBound.Item2;
algExecution.Add(progress);
#endregion
return(rule);
}, localCopy, CancellationToken.None, TaskCreationOptions.AttachedToParent, TaskScheduler.Default);
task.ContinueWith(x =>
{
if (x.Status == TaskStatus.RanToCompletion)
{
lock (locker)
{
result.Add(((Task <AssociationRule>)x).Result);
Notify(++index);
}
}
}, CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, guiScheduler);
tasks.Add(task);
}
}
var finish = Task.Factory.ContinueWhenAll(tasks.ToArray(), x =>
{
SeparatedRows(algExecution);
Rules(result);
}, CancellationToken.None, TaskContinuationOptions.None, guiScheduler);
}
public string GetChartText(AssociationRule rule)
{
return($"Association rule: {rule.Text}");
}
