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}"); }