static void Main(string[] args) { var events = File.ReadAllLines(@"C:\Users\leosm\Documents\Projects\TCC\DataSetByCNPJ\cartelFull.csv"); var list = events.Select(x => { var split = x.Split(';'); return(new Participante { CodItemCompra = split[0], CnpjParticipante = split[1] }); }); var groups = list.GroupBy(x => x.CodItemCompra).ToDictionary(x => x.Key, x => x.Select(e => e.CnpjParticipante).ToArray()).ToArray(); var dataset = groups.Select(x => x.Value.ToArray()).ToArray(); // Create a new A-priori learning algorithm with the requirements var apriori = new Apriori <string>(threshold: 3, confidence: 0.7); // Use apriori to generate a n-itemset generation frequent pattern AssociationRuleMatcher <string> classifier = apriori.Learn(dataset); // Generate association rules from the itemsets: AssociationRule <string>[] rules = classifier.Rules; }
public void UpdateRecommendedProducts() { var orders1 = _context.OrderClient.Include(order => order.ProductOrders).ThenInclude(po => po.Product); var orders = _context.ApplicationUser.Include(user => user.Orders).ThenInclude(order => order.ProductOrders) .ThenInclude(po => po.Product).Select(delegate(ApplicationUser user) { List <int> orderList = new List <int>(); foreach (ClientOrder co in user.Orders) { foreach (ProductOrder po in co.ProductOrders) { orderList.Add(po.Product.ProductID); } } return(orderList); }).ToArray(); SortedSet <int>[] dataset = ToSortedSet(orders); // We will use Apriori to determine the frequent item sets of this database. // To do this, we will say that an item set is frequent if it appears in at // least 20% transactions of the database: the value _minSupport * dataset.Length is the support threshold. // Create a new a-priori learning algorithm with support 3 Apriori <int> apriori = new Apriori <int>(Convert.ToInt32(_minSupport * dataset.Length), _minConfidence); // Use the algorithm to learn a set matcher classifier = apriori.Learn(dataset); }
public string getRecommendedBook(string CustomerId) { if (CustomerId == null) { return("error - must have CustomerId"); } var allLoans = db.Loans.Include(l => l.Book).Include(l => l.Customer).ToList(); var customers = db.Customers.ToList(); List <int[]> tempDataset = new List <int[]>(); foreach (var c in customers) { var booksPerC = allLoans.Where(x => x.CustomerId == c.Id).Select(b => b.BookId).ToList(); tempDataset.Add(booksPerC.ToArray()); } int[][] dataset = tempDataset.ToArray(); Apriori apriori = new Apriori(threshold: 1, confidence: 0); AssociationRuleMatcher <int> classifier = apriori.Learn(dataset); var booksPerSpecC = allLoans.Where(x => x.Customer.PersonalID == (string)CustomerId).Select(b => b.BookId).ToArray(); int[][] matches = classifier.Decide(booksPerSpecC); if (matches.Length > 0) { int BestBookID = matches[0][0]; string BestBookName = db.Books.Single(x => x.Id == BestBookID).Name; return(BestBookName); } return("There is no recommended book for this customer."); }
public void Predict(string SaleID, string CustomerID) { Dictionary <string, int> mapActors = new Dictionary <string, int>(); SortedSet <int>[] dataset = SalesTransactionConverter(mapActors); Apriori apriori = new Apriori(threshold: 3, confidence: 0); AssociationRuleMatcher <int> classifier = apriori.Learn(dataset); var sale = _context.Sale.Include(s => s.Movies).Include("Movies.Movie").FirstOrDefault(s => s.SaleID == SaleID); HashSet <string> actorsSet = new HashSet <string>(); List <int> sample = new List <int>(); foreach (var movie in sale.Movies) { string[] actors = movie.Movie.Actors.Split(","); foreach (var actor in actors) { if (!actorsSet.Contains(actor)) { actorsSet.Add(actor); sample.Add(mapActors.GetValueOrDefault(actor)); } } } int[][] matches = classifier.Decide(sample.ToArray()); }
public List <Video> GetRelatedVideos([FromRoute] int[] videoIDS, [FromRoute] int limit = 5) { AssociationRuleMatcher <int> classifier = CreateAprioriClassifier(); // Get the videos that appear most with the video who's ID is the given argument videoID int[][] matches = classifier.Decide(videoIDS); List <Video> videos = new List <Video>(); HashSet <int> ids = new HashSet <int>(); // Merge all the video IDs into a single HashSet, this will remove duplicates. foreach (int[] e in matches) { foreach (int f in e) { ids.Add(f); } } // Take only the given amount of videos from the argument 'limit'. ids = ids.Take(limit).ToHashSet(); // Get the full video model for each of the IDs. foreach (int id in ids) { videos.Add(_context.Video.FirstOrDefault(video => video.ID == id)); } return(videos); }
public async Task <string> getRecommendedMovie(string customerId) { if (customerId == null) { throw new ArgumentException("customer id is required!"); } var loans = await _context.Loan .Include(l => l.Movie) .Include(l => l.Customer) .ToListAsync(); var customers = await _context.Customer.ToListAsync(); List <int[]> tempDatasset = new List <int[]>(); // Creating a unsymmetric matrix that each row contains the movies that a certain // customer has lent foreach (var customer in customers) { var moviesIdsPerCustomer = loans.Where(l => l.CustomerId == customer.CustomerId) .Select(m => m.MovieId).ToList(); tempDatasset.Add(moviesIdsPerCustomer.ToArray()); } int[][] dataset = tempDatasset.ToArray(); // threshold represents that only 1 movie that the specified customer has lent // needs to be found in the other loans of other customers in order to recommend it // for him Apriori apriori = new Apriori(threshold: 1, confidence: 0); // machine learning section AssociationRuleMatcher <int> classifier = apriori.Learn(dataset); // movies ids of the specified customer according to his loans var moviesPerSpecifiedCustomer = loans .Where(l => l.Customer.PersonalId == (string)customerId) .Select(b => b.MovieId).ToArray(); // make an intersection between his movies and try to find from the dataset // all rows that contains atleast 1 of his movies that he had lent int[][] matches = classifier.Decide(moviesPerSpecifiedCustomer); if (matches.Length > 0) { int bestMovieId = matches[0][0]; string bestMovieName = _context.Movie.Single(m => m.MovieId == bestMovieId).Name; return(bestMovieName); } return("There is no recommended movie for this customer."); }
public AssociationRuleMatcher <int> CreateAprioriClassifier() { // Create a new a-priori learning algorithm with support 3 Apriori apriori = new Apriori(threshold: 2, confidence: 0); int[][] histories = GetAllViewingHistories(); // Use the algorithm to learn a set matcher AssociationRuleMatcher <int> classifier = apriori.Learn(histories); return(classifier); }
public IList <ProductResult> RecommendProducts(int userId) { var salesByUser = this.GetAllSalesByUser(); List <int[]> tempDataset = new List <int[]>(); int[] currUserSales = null; foreach (var userSales in salesByUser) { if (userSales.UserID == userId) { currUserSales = userSales.Products.ToArray(); } tempDataset.Add(userSales.Products.ToArray()); } if (currUserSales == null || currUserSales.Length == 0) { return(new List <ProductResult>()); } int[][] dataset = tempDataset.ToArray(); // We will use Apriori to determine the frequent item sets of this database. // To do this, we will say that an item set is frequent if it appears in at // least 3 transactions of the database: the value 3 is the support threshold. // Create a new a-priori learning algorithm with support 3 Apriori apriori = new Apriori(threshold: 1, confidence: 0.5); //// Use the algorithm to learn a set matcher AssociationRuleMatcher <int> classifier = apriori.Learn(dataset); // Use the classifier to find orders that are similar to // orders where clients have bought items 1 and 2 together: int[][] matches = classifier.Decide(currUserSales); List <ProductResult> recommededProducts = new List <ProductResult>(); if (matches.Length > 0) { int[] tmpRecommendedProducts = matches[0]; foreach (var product in tmpRecommendedProducts) { recommededProducts.Add(this.GetProduct(product)); } } return(recommededProducts); }
public void GetSkillsSuggestion() { SortedSet <int>[] dataset = { // Each row represents a set of items that have been bought // together. Each number is a SKU identifier for a product. new SortedSet <int> { 1, 2, 3, 4 }, // bought 4 items new SortedSet <int> { 1, 2, 4 }, // bought 3 items new SortedSet <int> { 1, 2 }, // bought 2 items new SortedSet <int> { 2, 3, 4 }, // ... new SortedSet <int> { 2, 3 }, new SortedSet <int> { 3, 4 }, new SortedSet <int> { 2, 4 }, }; // We will use Apriori to determine the frequent item sets of this database. // To do this, we will say that an item set is frequent if it appears in at // least 3 transactions of the database: the value 3 is the support threshold. // Create a new a-priori learning algorithm with support 3 Apriori apriori = new Apriori(threshold: 3, confidence: 0); // Use the algorithm to learn a set matcher AssociationRuleMatcher <int> classifier = apriori.Learn(dataset); // Use the classifier to find orders that are similar to // orders where clients have bought items 1 and 2 together: int[][] matches = classifier.Decide(new[] { 1, 2 }); // The result should be: // // new int[][] // { // new int[] { 4 }, // new int[] { 3 } // }; }
public void Train(List <PlaylistModel> playlistModelList) { // getting the songs ready for the machine learning algorithm SortedSet <int>[] songIdSetArray = new SortedSet <int> [playlistModelList.Count]; for (int i = 0; i < songIdSetArray.Length; i++) { SortedSet <int> songSet = new SortedSet <int>(); foreach (PlaylistSongModel psm in playlistModelList[i].Songs) { songSet.Add(psm.SongId); } songIdSetArray[i] = songSet; } classifier = apriori.Learn(songIdSetArray); }
public async Task <object> LearnAprior() { var playlists = await _context.Playlists.ToListAsync(); // Each row represents a set of items that have been bought // together. Each number is a SKU identifier for a product. SortedSet <int>[] dataset = new SortedSet <int> [playlists.Count]; for (int i = 0; i < playlists.Count; i++) { dataset[i] = await ToSortesSetCollection(playlists[i]); } // Use the algorithm to learn a set matcher Classifier = AprioriAlg.Learn(dataset); return(1); }
public List <AssociationRule <int> > AI() { Trace.WriteLine("Starting AI:"); var allBuys = dal.getApprovedBuys().ToArray(); int[][] dataset = new int[allBuys.Count()][]; for (int i = 0; i < allBuys.Count(); i++) { dataset[i] = new int[] { (int)allBuys[i].date.DayOfWeek, (int)allBuys[i].productID }; } Apriori apriori = new Apriori(threshold: 3, confidence: 0.2); AssociationRuleMatcher <int> classifier = apriori.Learn(dataset); AssociationRule <int>[] rules = classifier.Rules; return(rules.ToList()); }
// GET: Projects/Details/5 public async Task <IActionResult> Details(int?id) { if (id == null) { return(NotFound()); } // Machine learning is awesome! List <IGrouping <int, int> > projectIdsPerUsersGroups = _context.Sale.Include("Project").Where(x => !x.Project.IsDeleted).GroupBy(x => x.BuyerId, y => y.ProjectId).ToList(); SortedSet <int>[] projectsPerUserDataset = new SortedSet <int> [projectIdsPerUsersGroups.Count]; int idx = 0; foreach (var group in projectIdsPerUsersGroups) { projectsPerUserDataset[idx++] = new SortedSet <int>(group); } Apriori apriori = new Apriori(threshold: 3, confidence: 0); AssociationRuleMatcher <int> classifier = apriori.Learn(projectsPerUserDataset); AssociationRule <int>[] rules = classifier.Rules; ViewData["suggested"] = rules.Where(x => x.Y.First() != id).Select(x => _context.Project.First(y => y.Id == x.Y.First())); var project = await _context.Project .Include(x => x.AcademicInstitute) .Include(x => x.FieldOfStudy) .Include(x => x.Owner) .FirstOrDefaultAsync(m => m.Id == id && ((!m.Owner.IsDeleted && !m.IsDeleted) || ClaimsExtension.IsAdmin(HttpContext))); if (project == null) { return(NotFound()); } return(View(project)); }
public void RecommendedSpots() { // First I bring the entire usrs from the DB List <GeneralUser> allUsers = _context.Users.ToList(); // Second I am listing whole spots shown in the entire system users history List <int[]> allHistorySpots = new List <int[]>(); allUsers.ForEach(user => { if (!string.IsNullOrEmpty(user.History)) { // we are inserting to the allHistory list chunks of the user history -- [ [spotID ,spotID ,spotID ,spotID ] , [spotID ,spotID ,spotID ,spotID ] , [spotID, spotID] ] allHistorySpots.Add(user.History.Split(",").Select(int.Parse).ToArray()); } }); int[][] dataSet = allHistorySpots.ToArray(); // Apriori Algorithm is used to determine the frequent spot in the entire transactions found in the DB. // Create a new a-priori learning algorithm with the properties we set at the C-TOR Apriori apriori = new Apriori(_threshold, _minConfidence); // And now we will create the learning on the array we prepared before classifier = apriori.Learn(dataSet); }
public void CreateAprioriRules() { var associationBookList = bookSessionInfoManager.List().GroupBy(x => x.SessionId).ToArray(); SortedSet <int>[] dataset = new SortedSet <int> [associationBookList.Count()]; for (int i = 0; i < associationBookList.Count(); i++) { SortedSet <int> sortedSet = new SortedSet <int>() { }; foreach (var item1 in associationBookList[i]) { sortedSet.Add(item1.BookId); } dataset[i] = sortedSet; } Apriori apriori = new Apriori(threshold: 3, confidence: 0.5); AssociationRuleMatcher <int> classifier = apriori.Learn(dataset); int[][] matches = classifier.Decide(new[] { 1 }); AssociationRule <int>[] rules = classifier.Rules; InsertSimilarBook(rules); //foreach (var item in rules) //{ // item.X.ToString(); // item.ToString(); //} //return rules; }
public string RecommendOnProduct(Dictionary <int, string> dictCurrentCart) { if (dictCurrentCart.Count == 0) { return(string.Empty); } // We will use Apriori to determine the frequent item sets of this database. // To do this, we will say that an item set is frequent if it appears in at // least 3 transactions of the database: the value 3 is the support threshold. // Create a new a-priori learning algorithm with support 3 Apriori apriori = new Apriori(threshold: 2, confidence: 0); // Use the algorithm to learn a set matcher AssociationRuleMatcher <int> classifier = apriori.Learn(dataset); // Use the classifier to find orders that are similar to // orders where clients have bought items 1 and 2 together: var products = new int[dictCurrentCart.Count]; int index = 0; foreach (var product in dictCurrentCart) { products[index] = product.Key; index++; } int[][] matches = classifier.Decide(products); if (matches.Length == 0) { return(string.Empty); } else if (!allProducts.Keys.Contains(matches[0][0])) // the first product recommended { return(string.Empty); } AssociationRule <int>[] rules = classifier.Rules; string recProduct; bool res = allProducts.TryGetValue(matches[0][0], out recProduct); if (res) { return(recProduct); } return(string.Empty); // The result should be: // // new int[][] // { // new int[] { 4 }, // new int[] { 3 } // }; // Meaning the most likely product to go alongside the products // being bought is item 4, and the second most likely is item 3. // We can also obtain the association rules from frequent itemsets: // The result will be: // { // [1] -> [2]; support: 3, confidence: 1, // [2] -> [1]; support: 3, confidence: 0.5, // [2] -> [3]; support: 3, confidence: 0.5, // [3] -> [2]; support: 3, confidence: 0.75, // [2] -> [4]; support: 4, confidence: 0.66, // [4] -> [2]; support: 4, confidence: 0.8, // [3] -> [4]; support: 3, confidence: 0.75, // [4] -> [3]; support: 3, confidence: 0.6 // }; }
public void ClassifierTest1() { #region doc_learn_2 // Example from http://www3.cs.stonybrook.edu/~cse634/lecture_notes/07apriori.pdf // For this example, we will consider a database consisting of 9 transactions: // - Minimum support count required will be 2 (i.e. min_sup = 2 / 9 = 22%); // - Minimum confidence required should be 70%; // The dataset of transactions can be as follows: string[][] dataset = { new string[] { "1", "2", "5" }, new string[] { "2", "4" }, new string[] { "2", "3" }, new string[] { "1", "2", "4" }, new string[] { "1", "3" }, new string[] { "2", "3" }, new string[] { "1", "3" }, new string[] { "1", "2", "3", "5"}, new string[] { "1", "2", "3" }, }; // Create a new A-priori learning algorithm with the requirements var apriori = new Apriori <string>(threshold: 2, confidence: 0.7); // Use apriori to generate a n-itemset generation frequent pattern AssociationRuleMatcher <string> classifier = apriori.Learn(dataset); // Generate association rules from the itemsets: AssociationRule <string>[] rules = classifier.Rules; // The result should be: // { // [5] -> [1]; support: 2, confidence: 1, // [5] -> [2]; support: 2, confidence: 1, // [4] -> [2]; support: 2, confidence: 1, // [5] -> [1 2]; support: 2, confidence: 1, // [1 5] -> [2]; support: 2, confidence: 1, // [2 5] -> [1]; support: 2, confidence: 1, // } #endregion Assert.AreEqual(6, rules.Length); Assert.AreEqual(rules[0].ToString(), "[5] -> [1]; support: 2, confidence: 1"); Assert.AreEqual(rules[1].ToString(), "[5] -> [2]; support: 2, confidence: 1"); Assert.AreEqual(rules[2].ToString(), "[4] -> [2]; support: 2, confidence: 1"); Assert.AreEqual(rules[3].ToString(), "[5] -> [1 2]; support: 2, confidence: 1"); Assert.AreEqual(rules[4].ToString(), "[1 5] -> [2]; support: 2, confidence: 1"); Assert.AreEqual(rules[5].ToString(), "[2 5] -> [1]; support: 2, confidence: 1"); string[][] actual; actual = classifier.Decide(new string[] { "1", "5" }); Assert.AreEqual("2", actual[0][0]); Assert.AreEqual("1", actual[1][0]); Assert.AreEqual("2", actual[1][1]); actual = classifier.Decide(new string[] { "2", "5" }); Assert.AreEqual("1", actual[0][0]); Assert.AreEqual("1", actual[1][0]); Assert.AreEqual("2", actual[1][1]); actual = classifier.Decide(new string[] { "0", "5" }); Assert.AreEqual("1", actual[0][0]); Assert.AreEqual("2", actual[0][1]); Assert.AreEqual("2", actual[1][0]); Assert.AreEqual("1", actual[2][0]); }
public void AprioriExampleTest1() { #region doc_learn_1 // Example from https://en.wikipedia.org/wiki/Apriori_algorithm // Assume that a large supermarket tracks sales data by stock-keeping unit // (SKU) for each item: each item, such as "butter" or "bread", is identified // by a numerical SKU. The supermarket has a database of transactions where each // transaction is a set of SKUs that were bought together. // Let the database of transactions consist of following itemsets: SortedSet <int>[] dataset = { // Each row represents a set of items that have been bought // together. Each number is a SKU identifier for a product. new SortedSet <int> { 1, 2, 3, 4 }, // bought 4 items new SortedSet <int> { 1, 2, 4 }, // bought 3 items new SortedSet <int> { 1, 2 }, // bought 2 items new SortedSet <int> { 2, 3, 4 }, // ... new SortedSet <int> { 2, 3 }, new SortedSet <int> { 3, 4 }, new SortedSet <int> { 2, 4 }, }; // We will use Apriori to determine the frequent item sets of this database. // To do this, we will say that an item set is frequent if it appears in at // least 3 transactions of the database: the value 3 is the support threshold. // Create a new a-priori learning algorithm with support 3 Apriori apriori = new Apriori(threshold: 3, confidence: 0); // Use the algorithm to learn a set matcher AssociationRuleMatcher <int> classifier = apriori.Learn(dataset); // Use the classifier to find orders that are similar to // orders where clients have bought items 1 and 2 together: int[][] matches = classifier.Decide(new[] { 1, 2 }); // The result should be: // // new int[][] // { // new int[] { 4 }, // new int[] { 3 } // }; // Meaning the most likely product to go alongside the products // being bought is item 4, and the second most likely is item 3. // We can also obtain the association rules from frequent itemsets: AssociationRule <int>[] rules = classifier.Rules; // The result will be: // { // [1] -> [2]; support: 3, confidence: 1, // [2] -> [1]; support: 3, confidence: 0.5, // [2] -> [3]; support: 3, confidence: 0.5, // [3] -> [2]; support: 3, confidence: 0.75, // [2] -> [4]; support: 4, confidence: 0.66, // [4] -> [2]; support: 4, confidence: 0.8, // [3] -> [4]; support: 3, confidence: 0.75, // [4] -> [3]; support: 3, confidence: 0.6 // }; #endregion Assert.AreEqual(8, rules.Length); Assert.AreEqual(rules[0].ToString(), "[1] -> [2]; support: 3, confidence: 1"); Assert.AreEqual(rules[1].ToString(), "[2] -> [1]; support: 3, confidence: 0.5"); Assert.AreEqual(rules[2].ToString(), "[2] -> [3]; support: 3, confidence: 0.5"); Assert.AreEqual(rules[3].ToString(), "[3] -> [2]; support: 3, confidence: 0.75"); Assert.AreEqual(rules[4].ToString(), "[2] -> [4]; support: 4, confidence: 0.666666666666667"); Assert.AreEqual(rules[5].ToString(), "[4] -> [2]; support: 4, confidence: 0.8"); Assert.AreEqual(rules[6].ToString(), "[3] -> [4]; support: 3, confidence: 0.75"); Assert.AreEqual(rules[7].ToString(), "[4] -> [3]; support: 3, confidence: 0.6"); var str = matches.ToCSharp(); int[][] expectedMatches = new int[][] { new int[] { 4 }, new int[] { 3 } }; var expected = new Tuple <int[], int>[] { Tuple.Create(new[] { 1 }, 3), Tuple.Create(new[] { 2 }, 6), Tuple.Create(new[] { 3 }, 4), Tuple.Create(new[] { 4 }, 5), Tuple.Create(new[] { 1, 2 }, 3), Tuple.Create(new[] { 2, 3 }, 3), Tuple.Create(new[] { 2, 4 }, 4), Tuple.Create(new[] { 3, 4 }, 3), }; var frequent = apriori.Frequent; foreach (var tuple in expected) { var a = frequent.Where(x => x.Key.SetEquals(tuple.Item1)).First(); Assert.AreEqual(tuple.Item2, a.Value); } }
public string[][] AprioriAI(string[] BreakFastDietplan, string[] LunchDietplan, string[] DinnerDietplan) { string path = Path.Combine(Environment.CurrentDirectory, "Data", "TeachPreferences.txt"); string _Path = Path.Combine(Environment.CurrentDirectory, "Data", "PreferencesDB.txt"); // Let the database of dietplan consist of following itemsets: //SortedSet<string>[] dataset = //{ //// Each row represents a set of foods that have been consumed //// together. Each number is a SKU identifier for a food. //new SortedSet<string> { "grilled chicken breast", "lettuce", "carrot", "3 oz of greek yogurt" }, //consumed 4 food as a meal //new SortedSet<string> { "grilled chicken breast", "lettuce", "3 oz of greek yogurt" }, // consumed 3 food as a meal //new SortedSet<string> { "grilled chicken breast", "lettuce" }, // .... //new SortedSet<string> { "lettuce", "carrot", "3 oz of greek yogurt" }, //new SortedSet<string> { "lettuce", "carrot" }, //new SortedSet<string> { "carrot", "3 oz of greek yogurt" }, //new SortedSet<string> { "lettuce", "3 oz of greek yogurt" }, //}; //TextWriter tw = new StreamWriter(_Path,true); //tw.Write(string.Join(",", BreakFastDietplan)); //tw.WriteLine(""); //tw.Write(string.Join(",", LunchDietplan)); //tw.WriteLine(""); //tw.Write(string.Join(",", DinnerDietplan)); //tw.Close(); //if (File.Exists(_Path)) //{ // string lines; // System.IO.StreamReader f = new System.IO.StreamReader(_Path); // while ((lines = f.ReadLine()) != null) // { // if (lines==string.Join(",",BreakFastDietplan)) // { // } // } //} SortedSet <string>[] resultingArray = new SortedSet <string> [3]; string line; int counter = 0; // Read the file and display it line by line. System.IO.StreamReader file = new System.IO.StreamReader(_Path); while ((line = file.ReadLine()) != null) { line = line.Replace(" ", string.Empty); //remove unnecessary spaces SortedSet <string> lineSet = new SortedSet <string>(line.Split(',')); resultingArray.SetValue(lineSet, counter); counter++; } // We will use Apriori to determine the frequent item sets of this database. // To do this, we will say that an item set is frequent if it appears in at // least 3 transactions of the database: the value 3 is the support threshold. // Create a new a-priori learning algorithm with support 3 var apriori = new Apriori <string>(threshold: 2, confidence: 0); // Use the algorithm to learn a set matcher AssociationRuleMatcher <string> classifier = apriori.Learn(resultingArray); // Use the classifier to find orders that are similar to // orders where clients have bought items 1 and 2 together: //string[][] matches = classifier.Decide(new[] { "2 oz. grilled chicken breast", "lettuce" });//this is a jagged array string[] foodtest = { "4", "9" }; string[][] matches = classifier.Decide(foodtest); // We can also obtain the association rules from frequent itemsets: AssociationRule <string>[] rules = classifier.Rules; var food = new List <Meal> { }; //foreach (string[] i in matches) //{ // foreach (string item in i) // { // System.Diagnostics.Debug.WriteLine("Results: " + item); // } //} return(matches); }