public static double[] ratingVector(PreferenceArray prefs) { double[] numArray = new double[prefs.length()]; for (int i = 0; i < prefs.length(); i++) { numArray[i] = prefs.get(i).getValue(); } return(numArray); }
private static double computeThreshold(PreferenceArray prefs) { if (prefs.length() < 2) { return(double.NegativeInfinity); } RunningAverageAndStdDev dev = new FullRunningAverageAndStdDev(); int num = prefs.length(); for (int i = 0; i < num; i++) { dev.addDatum((double)prefs.getValue(i)); } return(dev.getAverage() + dev.getStandardDeviation()); }
public void removeItemPref(long userID, long itemIDA, float prefValue) { PreferenceArray userPreferences = dataModel.getPreferencesFromUser(userID); try { buildAverageDiffsLock.EnterWriteLock(); FastByIDMap <RunningAverage> aMap = averageDiffs.get(itemIDA); int length = userPreferences.length(); for (int i = 0; i < length; i++) { long itemIDB = userPreferences.getItemID(i); float bValue = userPreferences.getValue(i); if (itemIDA < itemIDB) { if (aMap != null) { RunningAverage average = aMap.get(itemIDB); if (average != null) { if (average.getCount() <= 1) { aMap.remove(itemIDB); } else { average.removeDatum(bValue - prefValue); } } } } else if (itemIDA > itemIDB) { FastByIDMap <RunningAverage> bMap = averageDiffs.get(itemIDB); if (bMap != null) { RunningAverage average = bMap.get(itemIDA); if (average != null) { if (average.getCount() <= 1) { aMap.remove(itemIDA); } else { average.removeDatum(prefValue - bValue); } } } } } } finally { buildAverageDiffsLock.ExitWriteLock(); } }
private static PreferenceArray cloneAndMergeInto(PreferenceArray delegatePrefs, long itemID, long newUserID, float value) { int num4; int num = (delegatePrefs == null) ? 0 : delegatePrefs.length(); int size = num + 1; PreferenceArray array = new GenericItemPreferenceArray(size); array.setItemID(0, itemID); int i = 0; while ((i < num) && (newUserID > delegatePrefs.getUserID(i))) { i++; } for (num4 = 0; num4 < i; num4++) { array.setUserID(num4, delegatePrefs.getUserID(num4)); array.setValue(num4, delegatePrefs.getValue(num4)); } array.setUserID(i, newUserID); array.setValue(i, value); for (num4 = i + 1; num4 < size; num4++) { array.setUserID(num4, delegatePrefs.getUserID(num4 - 1)); array.setValue(num4, delegatePrefs.getValue(num4 - 1)); } return(array); }
public RandomRecommender(DataModel dataModel) : base(dataModel) { this.random = RandomUtils.getRandom(); float negativeInfinity = float.NegativeInfinity; float positiveInfinity = float.PositiveInfinity; IEnumerator <long> enumerator = dataModel.getUserIDs(); while (enumerator.MoveNext()) { long current = enumerator.Current; PreferenceArray array = dataModel.getPreferencesFromUser(current); for (int i = 0; i < array.length(); i++) { float num5 = array.getValue(i); if (num5 < positiveInfinity) { positiveInfinity = num5; } if (num5 > negativeInfinity) { negativeInfinity = num5; } } } this.minPref = positiveInfinity; this.maxPref = negativeInfinity; }
public void setTempPrefs(PreferenceArray prefs) { this.tempPrefs = prefs; this.prefItemIDs.clear(); for (int i = 0; i < prefs.length(); i++) { this.prefItemIDs.add(prefs.getItemID(i)); } }
private float doEstimatePreference(long userID, long itemID) { double count = 0.0; double totalPreference = 0.0; PreferenceArray prefs = getDataModel().getPreferencesFromUser(userID); RunningAverage[] averages = diffStorage.getDiffs(userID, itemID, prefs); int size = prefs.length(); for (int i = 0; i < size; i++) { RunningAverage averageDiff = averages[i]; if (averageDiff != null) { double averageDiffValue = averageDiff.getAverage(); if (weighted) { double weight = averageDiff.getCount(); if (stdDevWeighted) { var raaStdDev = averageDiff as RunningAverageAndStdDev; if (raaStdDev != null) { double stdev = raaStdDev.getStandardDeviation(); if (!Double.IsNaN(stdev)) { weight /= 1.0 + stdev; } } // If stdev is NaN, then it is because count is 1. Because we're weighting by count, // the weight is already relatively low. We effectively assume stdev is 0.0 here and // that is reasonable enough. Otherwise, dividing by NaN would yield a weight of NaN // and disqualify this pref entirely // (Thanks Daemmon) } totalPreference += weight * (prefs.getValue(i) + averageDiffValue); count += weight; } else { totalPreference += prefs.getValue(i) + averageDiffValue; count += 1.0; } } } if (count <= 0.0) { RunningAverage itemAverage = diffStorage.getAverageItemPref(itemID); return(itemAverage == null ? float.NaN : (float)itemAverage.getAverage()); } else { return((float)(totalPreference / count)); } }
protected IList <Tuple <int, double> > sparseUserRatingVector(PreferenceArray prefs) { List <Tuple <int, double> > list = new List <Tuple <int, double> >(prefs.length()); foreach (Preference preference in prefs) { list.Add(new Tuple <int, double>((int)preference.getItemID(), (double)preference.getValue())); } return(list); }
public void setTempPrefs(PreferenceArray prefs, long anonymousUserID) { this.tempPrefs[anonymousUserID] = prefs; FastIDSet set = new FastIDSet(); for (int i = 0; i < prefs.length(); i++) { set.add(prefs.getItemID(i)); } this.prefItemIDs[anonymousUserID] = set; }
public override FastIDSet getItemIDsFromUser(long userID) { PreferenceArray array = this.getPreferencesFromUser(userID); int size = array.length(); FastIDSet set = new FastIDSet(size); for (int i = 0; i < size; i++) { set.add(array.getItemID(i)); } return(set); }
private int countPreferences() { int num = 0; IEnumerator <long> enumerator = this.dataModel.getUserIDs(); while (enumerator.MoveNext()) { PreferenceArray array = this.dataModel.getPreferencesFromUser(enumerator.Current); num += array.length(); } return(num); }
public void addItemPref(long userID, long itemIDA, float prefValue) { PreferenceArray userPreferences = dataModel.getPreferencesFromUser(userID); try { buildAverageDiffsLock.EnterWriteLock(); FastByIDMap <RunningAverage> aMap = averageDiffs.get(itemIDA); if (aMap == null) { aMap = new FastByIDMap <RunningAverage>(); averageDiffs.put(itemIDA, aMap); } int length = userPreferences.length(); for (int i = 0; i < length; i++) { long itemIDB = userPreferences.getItemID(i); float bValue = userPreferences.getValue(i); if (itemIDA < itemIDB) { RunningAverage average = aMap.get(itemIDB); if (average == null) { average = buildRunningAverage(); aMap.put(itemIDB, average); } average.addDatum(bValue - prefValue); } else { FastByIDMap <RunningAverage> bMap = averageDiffs.get(itemIDB); if (bMap == null) { bMap = new FastByIDMap <RunningAverage>(); averageDiffs.put(itemIDB, bMap); } RunningAverage average = bMap.get(itemIDA); if (average == null) { average = buildRunningAverage(); bMap.put(itemIDA, average); } average.addDatum(prefValue - bValue); } } } finally { buildAverageDiffsLock.ExitWriteLock(); } }
public override int getNumUsersWithPreferenceFor(long itemID1, long itemID2) { PreferenceArray array = this.preferenceForItems.get(itemID1); if (array == null) { return(0); } PreferenceArray array2 = this.preferenceForItems.get(itemID2); if (array2 == null) { return(0); } int num = array.length(); int num2 = array2.length(); int num3 = 0; int i = 0; int num5 = 0; long num6 = array.getUserID(0); long num7 = array2.getUserID(0); while (true) { if (num6 < num7) { if (++i == num) { return(num3); } num6 = array.getUserID(i); } else if (num6 > num7) { if (++num5 == num2) { return(num3); } num7 = array2.getUserID(num5); } else { num3++; if ((++i == num) || (++num5 == num2)) { return(num3); } num6 = array.getUserID(i); num7 = array2.getUserID(num5); } } }
private static float?getPreferenceForItem(PreferenceArray preferencesFromUser, long itemID) { int num = preferencesFromUser.length(); for (int i = 0; i < num; i++) { if (preferencesFromUser.getItemID(i) == itemID) { return(new float?(preferencesFromUser.getValue(i))); } } return(null); }
public override PreferenceArray getPreferencesForItem(long itemID) { int num; if (this.tempPrefs.Count == 0) { return(base.getDelegate().getPreferencesForItem(itemID)); } PreferenceArray array = null; try { array = base.getDelegate().getPreferencesForItem(itemID); } catch (NoSuchItemException) { } List <Preference> list = new List <Preference>(); foreach (KeyValuePair <long, PreferenceArray> pair in this.tempPrefs) { PreferenceArray array2 = pair.Value; num = 0; while (num < array2.length()) { if (array2.getItemID(num) == itemID) { list.Add(array2.get(num)); } num++; } } int num2 = (array == null) ? 0 : array.length(); int count = list.Count; int num4 = 0; PreferenceArray array3 = new GenericItemPreferenceArray(num2 + count); for (num = 0; num < num2; num++) { array3.set(num4++, array.get(num)); } foreach (Preference preference in list) { array3.set(num4++, preference); } if (array3.length() == 0) { throw new NoSuchItemException(itemID); } return(array3); }
public override float?getPreferenceValue(long userID, long itemID) { PreferenceArray array = this.getPreferencesFromUser(userID); int num = array.length(); for (int i = 0; i < num; i++) { if (array.getItemID(i) == itemID) { return(new float?(array.getValue(i))); } } return(null); }
public FastIDSet getRelevantItemsIDs(long userID, int at, double relevanceThreshold, DataModel dataModel) { PreferenceArray array = dataModel.getPreferencesFromUser(userID); FastIDSet set = new FastIDSet(at); array.sortByValueReversed(); for (int i = 0; (i < array.length()) && (set.size() < at); i++) { if (array.getValue(i) >= relevanceThreshold) { set.add(array.getItemID(i)); } } return(set); }
private static long setBits(FastIDSet modelSet, PreferenceArray prefs, int max) { long num = -1L; for (int i = 0; (i < prefs.length()) && (i < max); i++) { long key = prefs.getItemID(i); modelSet.add(key); if (key > num) { num = key; } } return(num); }
public override float?getPreferenceValue(long userID, long itemID) { if (this.isAnonymousUser(userID)) { PreferenceArray array = this.tempPrefs[userID]; for (int i = 0; i < array.length(); i++) { if (array.getItemID(i) == itemID) { return(new float?(array.getValue(i))); } } return(null); } return(base.getDelegate().getPreferenceValue(userID, itemID)); }
protected override FastIDSet doGetCandidateItems(long[] preferredItemIDs, DataModel dataModel) { FastIDSet set = new FastIDSet(); foreach (long num in preferredItemIDs) { PreferenceArray array = dataModel.getPreferencesForItem(num); int num2 = array.length(); for (int i = 0; i < num2; i++) { set.addAll(dataModel.getItemIDsFromUser(array.getUserID(i))); } } set.removeAll(preferredItemIDs); return(set); }
public List <RecommendedItem> recommendedBecause(long userID, long itemID, int howMany) { DataModel model = this.getDataModel(); TopItems.Estimator <long> estimator = new RecommendedBecauseEstimator(this, userID, itemID); PreferenceArray array = model.getPreferencesFromUser(userID); int size = array.length(); FastIDSet set = new FastIDSet(size); for (int i = 0; i < size; i++) { set.add(array.getItemID(i)); } set.remove(itemID); return(TopItems.getTopItems(howMany, set.GetEnumerator(), null, estimator)); }
public float get(long key) { PreferenceArray array = this.inf.dataModel.getPreferencesFromUser(key); int num = array.length(); if (num == 0) { return(AveragingPreferenceInferrer.ZERO); } RunningAverage average = new FullRunningAverage(); for (int i = 0; i < num; i++) { average.addDatum((double)array.getValue(i)); } return((float)average.getAverage()); }
public static FastByIDMap <FastIDSet> toDataMap(FastByIDMap <PreferenceArray> data) { FastByIDMap <FastIDSet> map = new FastByIDMap <FastIDSet>(data.size()); foreach (KeyValuePair <long, PreferenceArray> pair in data.entrySet()) { PreferenceArray array = pair.Value; int size = array.length(); FastIDSet set = new FastIDSet(size); for (int i = 0; i < size; i++) { set.add(array.getItemID(i)); } map.put(pair.Key, set); } return(map); }
public override List <RecommendedItem> recommend(long userID, int howMany, IDRescorer rescorer) { log.debug("Recommending items for user ID '{}'", new object[] { userID }); PreferenceArray preferencesFromUser = this.getDataModel().getPreferencesFromUser(userID); if (preferencesFromUser.length() == 0) { return(new List <RecommendedItem>()); } FastIDSet set = this.getAllOtherItems(userID, preferencesFromUser); TopItems.Estimator <long> estimator = new Estimator(this, userID, preferencesFromUser); List <RecommendedItem> list = TopItems.getTopItems(howMany, set.GetEnumerator(), rescorer, estimator); log.debug("Recommendations are: {}", new object[] { list }); return(list); }
private static long[] getCommonItems(FastIDSet commonSet, PreferenceArray prefs1, int max) { long[] numArray = new long[max]; int num = 0; for (int i = 0; i < prefs1.length(); i++) { long key = prefs1.getItemID(i); if (commonSet.contains(key)) { numArray[num++] = key; } if (num == max) { return(numArray); } } return(numArray); }
private long processOneUser(long averageCount, long userID) { log.debug("Processing prefs for user {}", userID); // Save off prefs for the life of this loop iteration PreferenceArray userPreferences = dataModel.getPreferencesFromUser(userID); int length = userPreferences.length(); for (int i = 0; i < length - 1; i++) { float prefAValue = userPreferences.getValue(i); long itemIDA = userPreferences.getItemID(i); FastByIDMap <RunningAverage> aMap = averageDiffs.get(itemIDA); if (aMap == null) { aMap = new FastByIDMap <RunningAverage>(); averageDiffs.put(itemIDA, aMap); } for (int j = i + 1; j < length; j++) { // This is a performance-critical block long itemIDB = userPreferences.getItemID(j); RunningAverage average = aMap.get(itemIDB); if (average == null && averageCount < maxEntries) { average = buildRunningAverage(); aMap.put(itemIDB, average); averageCount++; } if (average != null) { average.addDatum(userPreferences.getValue(j) - prefAValue); } } RunningAverage itemAverage = averageItemPref.get(itemIDA); if (itemAverage == null) { itemAverage = buildRunningAverage(); averageItemPref.put(itemIDA, itemAverage); } itemAverage.addDatum(prefAValue); } return(averageCount); }
private void buildAverageDiffs() { lock (this) { DataModel model = this.getDataModel(); IEnumerator <long> enumerator = model.getUserIDs(); while (enumerator.MoveNext()) { long current = enumerator.Current; PreferenceArray array = model.getPreferencesFromUser(current); int num2 = array.length(); for (int i = 0; i < num2; i++) { long itemID = array.getItemID(i); float num5 = array.getValue(i); addDatumAndCreateIfNeeded(itemID, num5, this.itemAverages); addDatumAndCreateIfNeeded(current, num5, this.userAverages); this.overallAveragePrefValue.addDatum((double)num5); } } } }
protected override FastIDSet doGetCandidateItems(long[] preferredItemIDs, DataModel dataModel) { IEnumerator <long> enumerator = ((IEnumerable <long>)preferredItemIDs).GetEnumerator(); if (preferredItemIDs.Length > this.maxItems) { double samplingRate = ((double)this.maxItems) / ((double)preferredItemIDs.Length); log.info("preferredItemIDs.Length {0}, samplingRate {1}", new object[] { preferredItemIDs.Length, samplingRate }); enumerator = new SamplingLongPrimitiveIterator(enumerator, samplingRate); } FastIDSet possibleItemIDs = new FastIDSet(); while (enumerator.MoveNext()) { long current = enumerator.Current; PreferenceArray array = dataModel.getPreferencesForItem(current); int num3 = array.length(); if (num3 > this.maxUsersPerItem) { FixedSizeSamplingIterator <Preference> iterator = new FixedSizeSamplingIterator <Preference>(this.maxUsersPerItem, array.GetEnumerator()); while (iterator.MoveNext()) { this.addSomeOf(possibleItemIDs, dataModel.getItemIDsFromUser(iterator.Current.getUserID())); } } else { for (int i = 0; i < num3; i++) { this.addSomeOf(possibleItemIDs, dataModel.getItemIDsFromUser(array.getUserID(i))); } } } possibleItemIDs.removeAll(preferredItemIDs); return(possibleItemIDs); }
private void splitOneUsersPrefs(double trainingPercentage, FastByIDMap <PreferenceArray> trainingPrefs, FastByIDMap <PreferenceArray> testPrefs, long userID, DataModel dataModel) { List <Preference> prefs = null; List <Preference> list2 = null; PreferenceArray array = dataModel.getPreferencesFromUser(userID); int num = array.length(); for (int i = 0; i < num; i++) { Preference item = new GenericPreference(userID, array.getItemID(i), array.getValue(i)); if (this.random.nextDouble() < trainingPercentage) { if (prefs == null) { prefs = new List <Preference>(3); } prefs.Add(item); } else { if (list2 == null) { list2 = new List <Preference>(3); } list2.Add(item); } } if (prefs != null) { trainingPrefs.put(userID, new GenericUserPreferenceArray(prefs)); if (list2 != null) { testPrefs.put(userID, new GenericUserPreferenceArray(list2)); } } }
private void buildAverageDiffs() { lock (this) { DataModel model = this.getDataModel(); IEnumerator <long> enumerator = model.getUserIDs(); while (enumerator.MoveNext()) { PreferenceArray array = model.getPreferencesFromUser(enumerator.Current); int num = array.length(); for (int i = 0; i < num; i++) { long key = array.getItemID(i); RunningAverage average = this.itemAverages.get(key); if (average == null) { average = new FullRunningAverage(); this.itemAverages.put(key, average); } average.addDatum((double)array.getValue(i)); } } } }