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