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