public static List <IRecommendedItem> GetTopItems(int howMany, IEnumerator <long> possibleItemIDs, IDRescorer rescorer, IEstimator <long> estimator) { //Preconditions.checkArgument(possibleItemIDs != null, "possibleItemIDs is null"); //Preconditions.checkArgument(estimator != null, "estimator is null"); var topItems = new SortedSet <IRecommendedItem>(ByValueRecommendedItemComparator.getReverseInstance()); bool full = false; double lowestTopValue = Double.NegativeInfinity; while (possibleItemIDs.MoveNext()) { long itemID = possibleItemIDs.Current; if (rescorer == null || !rescorer.isFiltered(itemID)) { double preference; try { preference = estimator.Estimate(itemID); } catch (NoSuchItemException nsie) { continue; } double rescoredPref = rescorer == null ? preference : rescorer.rescore(itemID, preference); if (!Double.IsNaN(rescoredPref) && (!full || rescoredPref > lowestTopValue)) { topItems.Add(new GenericRecommendedItem(itemID, (float)rescoredPref)); if (full) { topItems.Remove(topItems.Min); } else if (topItems.Count > howMany) { full = true; topItems.Remove(topItems.Min); // topItems.poll(); } lowestTopValue = topItems.Min.GetValue(); } } } int size = topItems.Count; if (size == 0) { return(new List <IRecommendedItem>()); } List <IRecommendedItem> result = new List <IRecommendedItem>(size); result.AddRange(topItems); result.Reverse(); //Collections.sort(result, ByValueRecommendedItemComparator.getInstance()); return(result); }
public static List <RecommendedItem> getTopItems(int howMany, IEnumerator <long> possibleItemIDs, IDRescorer rescorer, Estimator <long> estimator) { SortedSet <RecommendedItem> collection = new SortedSet <RecommendedItem>(ByValueRecommendedItemComparator.getReverseInstance()); bool flag = false; double negativeInfinity = double.NegativeInfinity; while (possibleItemIDs.MoveNext()) { long current = possibleItemIDs.Current; if ((rescorer == null) || !rescorer.isFiltered(current)) { double num3; try { num3 = estimator.estimate(current); } catch (NoSuchItemException) { continue; } double d = (rescorer == null) ? num3 : rescorer.rescore(current, num3); if (!double.IsNaN(d) && (!flag || (d > negativeInfinity))) { collection.Add(new GenericRecommendedItem(current, (float)d)); if (flag) { collection.Remove(collection.Min); } else if (collection.Count > howMany) { flag = true; collection.Remove(collection.Min); } negativeInfinity = collection.Min.getValue(); } } } int count = collection.Count; if (count == 0) { return(new List <RecommendedItem>()); } List <RecommendedItem> list = new List <RecommendedItem>(count); list.AddRange(collection); list.Reverse(); return(list); }
public static long[] GetTopUsers(int howMany, IEnumerator <long> allUserIDs, IDRescorer rescorer, IEstimator <long> estimator) { var topUsers = new SortedSet <SimilarUser>(); bool full = false; double lowestTopValue = Double.NegativeInfinity; while (allUserIDs.MoveNext()) { long userID = allUserIDs.Current; if (rescorer != null && rescorer.isFiltered(userID)) { continue; } double similarity; try { similarity = estimator.Estimate(userID); } catch (NoSuchUserException nsue) { continue; } double rescoredSimilarity = rescorer == null ? similarity : rescorer.rescore(userID, similarity); if (!Double.IsNaN(rescoredSimilarity) && (!full || rescoredSimilarity > lowestTopValue)) { topUsers.Add(new SimilarUser(userID, rescoredSimilarity)); if (full) { topUsers.Remove(topUsers.Max); // topUsers.poll(); } else if (topUsers.Count > howMany) { full = true; topUsers.Remove(topUsers.Max); // topUsers.poll(); } lowestTopValue = topUsers.Max.getSimilarity(); } } int size = topUsers.Count; if (size == 0) { return(NO_IDS); } List <SimilarUser> sorted = new List <SimilarUser>(size); return(topUsers.Select(s => s.getUserID()).ToArray()); }
public static long[] getTopUsers(int howMany, IEnumerator <long> allUserIDs, IDRescorer rescorer, Estimator <long> estimator) { SortedSet <SimilarUser> set = new SortedSet <SimilarUser>(); bool flag = false; double negativeInfinity = double.NegativeInfinity; while (allUserIDs.MoveNext()) { long current = allUserIDs.Current; if ((rescorer == null) || !rescorer.isFiltered(current)) { double num3; try { num3 = estimator.estimate(current); } catch (NoSuchUserException) { continue; } double d = (rescorer == null) ? num3 : rescorer.rescore(current, num3); if (!double.IsNaN(d) && (!flag || (d > negativeInfinity))) { set.Add(new SimilarUser(current, d)); if (flag) { set.Remove(set.Max); } else if (set.Count > howMany) { flag = true; set.Remove(set.Max); } negativeInfinity = set.Max.getSimilarity(); } } } int count = set.Count; if (count == 0) { return(NO_IDS); } List <SimilarUser> list = new List <SimilarUser>(count); return((from s in set select s.getUserID()).ToArray <long>()); }
public override List <RecommendedItem> recommend(long userID, int howMany, IDRescorer rescorer) { // Preconditions.checkArgument(howMany >= 1, "howMany must be at least 1"); if (howMany < 1) { throw new Exception("howMany must be at least 1"); } ; buildClusters(); log.debug("Recommending items for user ID '{}'", userID); List <RecommendedItem> recommended = topRecsByUserID.get(userID); if (recommended == null) { return(new List <RecommendedItem>()); } DataModel dataModel = getDataModel(); List <RecommendedItem> rescored = new List <RecommendedItem>(); //Lists.newArrayListWithCapacity(recommended.size()); // Only add items the user doesn't already have a preference for. // And that the rescorer doesn't "reject". foreach (RecommendedItem recommendedItem in recommended) { long itemID = recommendedItem.getItemID(); if (rescorer != null && rescorer.isFiltered(itemID)) { continue; } if (dataModel.getPreferenceValue(userID, itemID) == null && (rescorer == null || !Double.IsNaN(rescorer.rescore(itemID, recommendedItem.getValue())))) { rescored.Add(recommendedItem); } } rescored.Sort(new ByRescoreComparator(rescorer)); return(rescored); }