private static void DoTestRunningAverage(RunningAverage runningAverage) { Assert.AreEqual(0, runningAverage.Count); Assert.IsTrue(Double.IsNaN(runningAverage.Average)); runningAverage.AddDatum(1.0); Assert.AreEqual(1, runningAverage.Count); Assert.AreEqual(1.0, runningAverage.Average); runningAverage.AddDatum(1.0); Assert.AreEqual(2, runningAverage.Count); Assert.AreEqual(1.0, runningAverage.Average); runningAverage.AddDatum(4.0); Assert.AreEqual(3, runningAverage.Count); Assert.AreEqual(2.0, runningAverage.Average); runningAverage.AddDatum(-4.0); Assert.AreEqual(4, runningAverage.Count); Assert.AreEqual(0.5, runningAverage.Average); runningAverage.RemoveDatum(-4.0); Assert.AreEqual(3, runningAverage.Count); Assert.AreEqual(2.0, runningAverage.Average); runningAverage.RemoveDatum(4.0); Assert.AreEqual(2, runningAverage.Count); Assert.AreEqual(1.0, runningAverage.Average); runningAverage.ChangeDatum(0.0); Assert.AreEqual(2, runningAverage.Count); Assert.AreEqual(1.0, runningAverage.Average); runningAverage.ChangeDatum(2.0); Assert.AreEqual(2, runningAverage.Count); Assert.AreEqual(2.0, runningAverage.Average); }
private double DoEstimatePreference(Object itemID) { buildAveragesLock.AcquireReaderLock(Constants.INFINITE_TIMEOUT); try { RunningAverage average = null; if (itemAverages.TryGetValue(itemID, out average)) { return(average.Average); } return(Double.NaN); } finally { buildAveragesLock.ReleaseReaderLock(); } }
public common.RunningAverage[] getDiffs(long userID, long itemID, taste.model.PreferenceArray prefs) { try { buildAverageDiffsLock.EnterReadLock(); int size = prefs.length(); RunningAverage[] result = new RunningAverage[size]; for (int i = 0; i < size; i++) { result[i] = getDiff(prefs.getItemID(i), itemID); } return(result); } finally { buildAverageDiffsLock.ExitReadLock(); } }
private float doEstimatePreference(long userID, long itemID) { lock (this) { RunningAverage average = this.itemAverages.get(itemID); if (average == null) { return(float.NaN); } RunningAverage average2 = this.userAverages.get(userID); if (average2 == null) { return(float.NaN); } double num = average2.getAverage() - this.overallAveragePrefValue.getAverage(); return((float)(average.getAverage() + num)); } }
public override void removePreference(long userID, long itemID) { float?nullable = this.getDataModel().getPreferenceValue(userID, itemID); base.removePreference(userID, itemID); if (nullable.HasValue) { lock (this) { RunningAverage average = this.itemAverages.get(itemID); if (average == null) { throw new InvalidOperationException("No preferences exist for item ID: " + itemID); } average.removeDatum((double)nullable.Value); } } }
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); }
public override void setPreference(long userID, long itemID, float value) { double num; DataModel model = this.getDataModel(); try { float?nullable = model.getPreferenceValue(userID, itemID); num = !nullable.HasValue ? ((double)value) : ((double)(value - nullable.Value)); } catch (NoSuchUserException) { num = value; } base.setPreference(userID, itemID, value); lock (this) { RunningAverage average = this.itemAverages.get(itemID); if (average == null) { RunningAverage average2 = new FullRunningAverage(); average2.addDatum(num); this.itemAverages.put(itemID, average2); } else { average.changeDatum(num); } RunningAverage average3 = this.userAverages.get(userID); if (average3 == null) { RunningAverage average4 = new FullRunningAverage(); average4.addDatum(num); this.userAverages.put(userID, average4); } else { average3.changeDatum(num); } this.overallAveragePrefValue.changeDatum(num); } }
public RunningAverage[] GetDiffs(Object userID, Object itemID, IList <Preference> prefs) { buildAverageDiffsLock.AcquireReaderLock(Constants.INFINITE_TIMEOUT); try { int size = prefs.Count; RunningAverage[] result = new RunningAverage[size]; int i = 0; foreach (Preference pref in prefs) { Object prefItemID = pref.Item.ID; result[i++] = GetDiff(prefItemID, itemID); } return(result); } finally { buildAverageDiffsLock.ReleaseReaderLock(); } }
public common.RunningAverage getDiff(long itemID1, long itemID2) { bool inverted = false; if (itemID1 > itemID2) { inverted = true; long temp = itemID1; itemID1 = itemID2; itemID2 = temp; } FastByIDMap <RunningAverage> level2Map; try { buildAverageDiffsLock.EnterReadLock(); level2Map = averageDiffs.get(itemID1); } finally { buildAverageDiffsLock.ExitReadLock(); } RunningAverage average = null; if (level2Map != null) { average = level2Map.get(itemID2); } if (inverted) { return(average == null ? null : average.inverse()); } else { return(average); } }
public RunningAverage GetDiff(Object itemID1, Object itemID2) { RunningAverage average = null; Dictionary <Object, RunningAverage> level2Map; averageDiffs.TryGetValue(itemID1, out level2Map); if (level2Map != null) { level2Map.TryGetValue(itemID2, out average); } bool inverted = false; if (average == null) { averageDiffs.TryGetValue(itemID2, out level2Map); if (level2Map != null) { level2Map.TryGetValue(itemID1, out average); inverted = true; } } if (inverted) { if (average == null) { return(null); } if (stdDevWeighted) { return(new InvertedRunningAverageAndStdDev((RunningAverageAndStdDev)average)); } return(new InvertedRunningAverage(average)); } else { return(average); } }
public override void SetPreference(Object userID, Object itemID, double value) { double prefDelta; try { User theUser = this.DataModel.GetUser(userID); Preference oldPref = theUser.GetPreferenceFor(itemID); prefDelta = oldPref == null ? value : value - oldPref.Value; } catch { prefDelta = value; } base.SetPreference(userID, itemID, value); buildAveragesLock.AcquireWriterLock(Constants.INFINITE_TIMEOUT); try { RunningAverage average = null; if (!itemAverages.TryGetValue(itemID, out average)) { RunningAverage newAverage = new FullRunningAverage(); newAverage.AddDatum(prefDelta); itemAverages.Add(itemID, newAverage); } else { average.ChangeDatum(prefDelta); } } finally { buildAveragesLock.ReleaseWriterLock(); } }
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)); } } } }
public void updateItemPref(long itemID, float prefDelta) { if (stdDevWeighted) { throw new Exception("Can't update only when stdDevWeighted is set"); } try { buildAverageDiffsLock.EnterReadLock(); foreach (var entry in averageDiffs.entrySet()) { bool matchesItemID1 = itemID == entry.Key; foreach (var entry2 in entry.Value.entrySet()) { RunningAverage average = entry2.Value; if (matchesItemID1) { average.changeDatum(-prefDelta); } else if (itemID == entry2.Key) { average.changeDatum(prefDelta); } } } RunningAverage itemAverage = averageItemPref.get(itemID); if (itemAverage != null) { itemAverage.changeDatum(prefDelta); } } finally { buildAverageDiffsLock.ExitReadLock(); } }
public static void evaluate(Recommender recommender, DataModel model, int samples, RunningAverage tracker, string tag) { printHeader(); IEnumerator <long> enumerator = recommender.getDataModel().getUserIDs(); while (enumerator.MoveNext()) { long current = enumerator.Current; List <RecommendedItem> items = recommender.recommend(current, model.getNumItems()); PreferenceArray prefs = model.getPreferencesFromUser(current); prefs.sortByValueReversed(); FastIDSet modelSet = new FastIDSet(); long num2 = setBits(modelSet, items, samples); FastIDSet set2 = new FastIDSet(); num2 = Math.Max(num2, setBits(set2, prefs, samples)); int max = Math.Min(mask(modelSet, set2, num2), samples); if (max >= 2) { long[] itemsL = getCommonItems(modelSet, items, max); long[] itemsR = getCommonItems(modelSet, prefs, max); double datum = scoreCommonSubset(tag, current, samples, max, itemsL, itemsR); tracker.addDatum(datum); } } }
protected override void reset() { this.average = new FullRunningAverage(); }
public LoadStatistics(RunningAverage timing) { this.timing = timing; }
private void BuildAverageDiffs() { log.Info("Building average diffs..."); buildAverageDiffsLock.AcquireWriterLock(Constants.INFINITE_TIMEOUT); try { long averageCount = 0L; foreach (User user in dataModel.GetUsers()) { if (log.IsDebugEnabled) { log.Debug("Processing prefs for user " + user + "..."); } // Save off prefs for the life of this loop iteration Preference[] userPreferences = user.GetPreferencesAsArray(); int length = userPreferences.Length; for (int i = 0; i < length; i++) { Preference prefA = userPreferences[i]; double prefAValue = prefA.Value; Object itemIDA = prefA.Item.ID; Dictionary <Object, RunningAverage> aMap; if (!averageDiffs.TryGetValue(itemIDA, out aMap)) { aMap = new Dictionary <Object, RunningAverage>(); averageDiffs.Add(itemIDA, aMap); } for (int j = i + 1; j < length; j++) { // This is a performance-critical block Preference prefB = userPreferences[j]; Object itemIDB = prefB.Item.ID; RunningAverage average; if (!aMap.TryGetValue(itemIDB, out average)) { average = null; } if (average == null && averageCount < maxEntries) { average = BuildRunningAverage(); aMap.Add(itemIDB, average); averageCount++; } if (average != null) { average.AddDatum(prefB.Value - prefAValue); } } RunningAverage itemAverage; if (!averageItemPref.TryGetValue(itemIDA, out itemAverage)) { itemAverage = BuildRunningAverage(); averageItemPref.Add(itemIDA, itemAverage); } itemAverage.AddDatum(prefAValue); } } // Go back and prune inconsequential diffs. "Inconsequential" means, here, an average // so small (< 1 / numItems^3) that it contributes very little to computations double numItems = (double)dataModel.GetNumItems(); double threshold = 1.0 / numItems / numItems / numItems; List <object> toRemove = new List <object>(); ICollection <Dictionary <Object, RunningAverage> > items = averageDiffs.Values; foreach (Dictionary <Object, RunningAverage> map in items) { foreach (KeyValuePair <object, RunningAverage> it2 in map) { RunningAverage average = it2.Value; if (Math.Abs(average.Average) < threshold) { // we cant delete an iterated item, so collect and delete later toRemove.Add(it2.Key); } } if (toRemove.Count > 0) { foreach (object obj in toRemove) { map.Remove(obj); } toRemove.Clear(); } if (map.Count == 0) { // averageDiffs.Remove -- we have to find the key of the map } } } finally { buildAverageDiffsLock.ReleaseWriterLock(); } }
public InvertedRunningAverage(RunningAverage _delegate) { this._delegate = _delegate; }
public RunningAverage[] GetDiffs(Object userID, Object itemID, IList<Preference> prefs) { buildAverageDiffsLock.AcquireReaderLock(Constants.INFINITE_TIMEOUT); try { int size = prefs.Count; RunningAverage[] result = new RunningAverage[size]; int i = 0; foreach (Preference pref in prefs) { Object prefItemID = pref.Item.ID; result[i++] = GetDiff(prefItemID, itemID); } return result; } finally { buildAverageDiffsLock.ReleaseReaderLock(); } }
public InvertedRunningAverage(RunningAverage _delegate) { this._delegate = _delegate; }
public RunningAverage[] GetDiffs(Object userID, Object itemID, IList<Preference> prefs) { int size = prefs.Count; RunningAverage[] result = new RunningAverage[size]; try { using (IDbCommand cmd = dataModel.CreateCommand(getDiffsSQL)) { ConfigureGetDiffsCommand(cmd, itemID, userID); if (log.IsDebugEnabled) { log.DebugFormat("Executing SQL query: {0}", getDiffsSQL); } int i = 0; using (IDataReader rs = cmd.ExecuteReader()) { while (rs.Read()) { result[i++] = new FixedRunningAverage(rs.GetInt32(1), rs.GetDouble(2)); } } if (i != size) { throw new TasteException("Wrong number of prefs read from database"); } } } catch (Exception sqle) { log.Warn("Exception while retrieving diff", sqle); throw new TasteException(sqle); } return result; }
public InvertedRunningAverage(RunningAverage deleg) { this._Delegate = deleg; }
public static void evaluate(Recommender recommender1, Recommender recommender2, int samples, RunningAverage tracker, string tag) { printHeader(); IEnumerator <long> enumerator = recommender1.getDataModel().getUserIDs(); while (enumerator.MoveNext()) { long current = enumerator.Current; List <RecommendedItem> items = recommender1.recommend(current, samples); List <RecommendedItem> list2 = recommender2.recommend(current, samples); FastIDSet modelSet = new FastIDSet(); long num2 = setBits(modelSet, items, samples); FastIDSet set2 = new FastIDSet(); num2 = Math.Max(num2, setBits(set2, list2, samples)); int max = Math.Min(mask(modelSet, set2, num2), samples); if (max >= 2) { long[] itemsL = getCommonItems(modelSet, items, max); long[] itemsR = getCommonItems(modelSet, list2, max); double datum = scoreCommonSubset(tag, current, samples, max, itemsL, itemsR); tracker.addDatum(datum); } } }