예제 #1
0
            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);
            }
예제 #2
0
 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);
         }
     }
 }
예제 #3
0
파일: Apriori.cs 프로젝트: dmitrykudin/Demo
        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);
        }
예제 #5
0
            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);
        }
예제 #8
0
        //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);
        }
예제 #9
0
파일: Apriori.cs 프로젝트: dmitrykudin/Demo
        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);
        }
예제 #10
0
        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);
        }
예제 #11
0
        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));
        }
예제 #13
0
        /// <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++;
            }
        }
예제 #14
0
        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));
        }
예제 #15
0
        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);
        }
예제 #16
0
        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);
            });
        }
예제 #17
0
        /// <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);
        }
예제 #18
0
        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);
            });
        }
예제 #19
0
        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);
        }
예제 #20
0
        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}");
 }