public virtual IPreferenceArray GetPreferencesForItem(long itemID)
{
if (tempPrefs == null)
{
return(_delegate.GetPreferencesForItem(itemID));
}
IPreferenceArray delegatePrefs = null;
try {
delegatePrefs = _delegate.GetPreferencesForItem(itemID);
} catch (NoSuchItemException nsie) {
// OK. Probably an item that only the anonymous user has
//if (log.isDebugEnabled()) {
log.Debug("Item {} unknown", itemID);
//}
}
for (int i = 0; i < tempPrefs.Length(); i++)
{
if (tempPrefs.GetItemID(i) == itemID)
{
return(cloneAndMergeInto(delegatePrefs, itemID, tempPrefs.GetUserID(i), tempPrefs.GetValue(i)));
}
}
if (delegatePrefs == null)
{
// No, didn't find it among the anonymous user prefs
throw new NoSuchItemException(itemID);
}
return(delegatePrefs);
}
public static double[] ratingVector(IPreferenceArray prefs)
{
double[] ratings = new double[prefs.Length()];
for (int n = 0; n < prefs.Length(); n++)
{
ratings[n] = prefs.Get(n).GetValue();
}
return(ratings); //, true); new DenseVector(
}
public void testTranspose()
{
FileDataModel tModel = new FileDataModel(testFileName, true, FileDataModel.DEFAULT_MIN_RELOAD_INTERVAL_MS);
IPreferenceArray userPrefs = tModel.GetPreferencesFromUser(456);
Assert.NotNull(userPrefs, "user prefs are null and it shouldn't be");
IPreferenceArray pref = tModel.GetPreferencesForItem(123);
Assert.NotNull(pref, "pref is null and it shouldn't be");
Assert.AreEqual(3, pref.Length(), "pref Size: " + pref.Length().ToString() + " is not: " + 3);
}
private static IPreferenceArray cloneAndMergeInto(IPreferenceArray delegatePrefs,
long itemID,
long newUserID,
float value)
{
int length = delegatePrefs == null ? 0 : delegatePrefs.Length();
int newLength = length + 1;
IPreferenceArray newPreferenceArray = new GenericItemPreferenceArray(newLength);
// Set item ID once
newPreferenceArray.SetItemID(0, itemID);
int positionToInsert = 0;
while (positionToInsert < length && newUserID > delegatePrefs.GetUserID(positionToInsert))
{
positionToInsert++;
}
for (int i = 0; i < positionToInsert; i++)
{
newPreferenceArray.SetUserID(i, delegatePrefs.GetUserID(i));
newPreferenceArray.SetValue(i, delegatePrefs.GetValue(i));
}
newPreferenceArray.SetUserID(positionToInsert, newUserID);
newPreferenceArray.SetValue(positionToInsert, value);
for (int i = positionToInsert + 1; i < newLength; i++)
{
newPreferenceArray.SetUserID(i, delegatePrefs.GetUserID(i - 1));
newPreferenceArray.SetValue(i, delegatePrefs.GetValue(i - 1));
}
return(newPreferenceArray);
}
private void buildAverageDiffs()
{
lock (this) {
//buildAveragesLock.writeLock().lock();
IDataModel dataModel = GetDataModel();
var it = dataModel.GetUserIDs();
while (it.MoveNext())
{
IPreferenceArray prefs = dataModel.GetPreferencesFromUser(it.Current);
int size = prefs.Length();
for (int i = 0; i < size; i++)
{
long itemID = prefs.GetItemID(i);
IRunningAverage average = itemAverages.Get(itemID);
if (average == null)
{
average = new FullRunningAverage();
itemAverages.Put(itemID, average);
}
average.AddDatum(prefs.GetValue(i));
}
}
}
//finally {
//buildAveragesLock.writeLock().unlock();
//}
}
private static double computeThreshold(IPreferenceArray prefs)
{
if (prefs.Length() < 2)
{
// Not enough data points -- return a threshold that allows everything
return(Double.NegativeInfinity);
}
IRunningAverageAndStdDev stdDev = new FullRunningAverageAndStdDev();
int size = prefs.Length();
for (int i = 0; i < size; i++)
{
stdDev.AddDatum(prefs.GetValue(i));
}
return(stdDev.GetAverage() + stdDev.GetStandardDeviation());
}
public void ProcessOtherUser(long userID,
FastIDSet relevantItemIDs,
FastByIDMap <IPreferenceArray> trainingUsers,
long otherUserID,
IDataModel dataModel)
{
IPreferenceArray prefs2Array = dataModel.GetPreferencesFromUser(otherUserID);
// If we're dealing with the very user that we're evaluating for precision/recall,
if (userID == otherUserID)
{
// then must remove all the test IDs, the "relevant" item IDs
List <IPreference> prefs2 = new List <IPreference>(prefs2Array.Length());
foreach (IPreference pref in prefs2Array)
{
if (!relevantItemIDs.Contains(pref.GetItemID()))
{
prefs2.Add(pref);
}
}
if (prefs2.Count > 0)
{
trainingUsers.Put(otherUserID, new GenericUserPreferenceArray(prefs2));
}
}
else
{
// otherwise just add all those other user's prefs
trainingUsers.Put(otherUserID, prefs2Array);
}
}
public RandomRecommender(IDataModel dataModel) : base(dataModel)
{
float maxPref = float.NegativeInfinity;
float minPref = float.PositiveInfinity;
var userIterator = dataModel.GetUserIDs();
while (userIterator.MoveNext())
{
long userID = userIterator.Current;
IPreferenceArray prefs = dataModel.GetPreferencesFromUser(userID);
for (int i = 0; i < prefs.Length(); i++)
{
float prefValue = prefs.GetValue(i);
if (prefValue < minPref)
{
minPref = prefValue;
}
if (prefValue > maxPref)
{
maxPref = prefValue;
}
}
}
this.minPref = minPref;
this.maxPref = maxPref;
}
public override IPreferenceArray GetPreferencesForItem(long itemID)
{
if (tempPrefs.Count == 0)
{
return(getDelegate().GetPreferencesForItem(itemID));
}
IPreferenceArray delegatePrefs = null;
try {
delegatePrefs = getDelegate().GetPreferencesForItem(itemID);
} catch (NoSuchItemException nsie) {
// OK. Probably an item that only the anonymous user has
//if (log.isDebugEnabled()) {
// log.debug("Item {} unknown", itemID);
//}
}
List <IPreference> anonymousPreferences = new List <IPreference>();
foreach (var prefsMap in tempPrefs)
{
IPreferenceArray singleUserTempPrefs = prefsMap.Value;
for (int i = 0; i < singleUserTempPrefs.Length(); i++)
{
if (singleUserTempPrefs.GetItemID(i) == itemID)
{
anonymousPreferences.Add(singleUserTempPrefs.Get(i));
}
}
}
int delegateLength = delegatePrefs == null ? 0 : delegatePrefs.Length();
int anonymousPrefsLength = anonymousPreferences.Count;
int prefsCounter = 0;
// Merge the delegate and anonymous preferences into a single array
IPreferenceArray newPreferenceArray = new GenericItemPreferenceArray(delegateLength + anonymousPrefsLength);
for (int i = 0; i < delegateLength; i++)
{
newPreferenceArray.Set(prefsCounter++, delegatePrefs.Get(i));
}
foreach (IPreference anonymousPreference in anonymousPreferences)
{
newPreferenceArray.Set(prefsCounter++, anonymousPreference);
}
if (newPreferenceArray.Length() == 0)
{
// No, didn't find it among the anonymous user prefs
throw new NoSuchItemException(itemID);
}
return(newPreferenceArray);
}
protected IList <Tuple <int, double> > sparseUserRatingVector(IPreferenceArray prefs)
{
var ratings = new List <Tuple <int, double> >(prefs.Length());
foreach (IPreference preference in prefs)
{
ratings.Add(new Tuple <int, double>((int)preference.GetItemID(), preference.GetValue()));
}
return(ratings);
}
public void SetTempPrefs(IPreferenceArray prefs)
{
//Preconditions.checkArgument(prefs != null && prefs.Length() > 0, "prefs is null or empty");
this.tempPrefs = prefs;
this.prefItemIDs.Clear();
for (int i = 0; i < prefs.Length(); i++)
{
this.prefItemIDs.Add(prefs.GetItemID(i));
}
}
public void ratingVector()
{
IPreferenceArray prefs = dataModel.GetPreferencesFromUser(1);
double[] ratingVector = ALSWRFactorizer.ratingVector(prefs);
Assert.AreEqual(prefs.Length(), ratingVector.Length);
Assert.AreEqual(prefs.Get(0).GetValue(), ratingVector[0], EPSILON);
Assert.AreEqual(prefs.Get(1).GetValue(), ratingVector[1], EPSILON);
Assert.AreEqual(prefs.Get(2).GetValue(), ratingVector[2], EPSILON);
}
public override int GetNumUsersWithPreferenceFor(long itemID1, long itemID2)
{
IPreferenceArray prefs1 = preferenceForItems.Get(itemID1);
if (prefs1 == null)
{
return(0);
}
IPreferenceArray prefs2 = preferenceForItems.Get(itemID2);
if (prefs2 == null)
{
return(0);
}
int size1 = prefs1.Length();
int size2 = prefs2.Length();
int count = 0;
int i = 0;
int j = 0;
long userID1 = prefs1.GetUserID(0);
long userID2 = prefs2.GetUserID(0);
while (true)
{
if (userID1 < userID2)
{
if (++i == size1)
{
break;
}
userID1 = prefs1.GetUserID(i);
}
else if (userID1 > userID2)
{
if (++j == size2)
{
break;
}
userID2 = prefs2.GetUserID(j);
}
else
{
count++;
if (++i == size1 || ++j == size2)
{
break;
}
userID1 = prefs1.GetUserID(i);
userID2 = prefs2.GetUserID(j);
}
}
return(count);
}
public override FastIDSet GetItemIDsFromUser(long userID)
{
IPreferenceArray prefs = GetPreferencesFromUser(userID);
int size = prefs.Length();
FastIDSet result = new FastIDSet(size);
for (int i = 0; i < size; i++)
{
result.Add(prefs.GetItemID(i));
}
return(result);
}
private int countPreferences()
{
int numPreferences = 0;
var userIDs = dataModel.GetUserIDs();
while (userIDs.MoveNext())
{
IPreferenceArray preferencesFromUser = dataModel.GetPreferencesFromUser(userIDs.Current);
numPreferences += preferencesFromUser.Length();
}
return(numPreferences);
}
private static float?getPreferenceForItem(IPreferenceArray preferencesFromUser, long itemID)
{
int size = preferencesFromUser.Length();
for (int i = 0; i < size; i++)
{
if (preferencesFromUser.GetItemID(i) == itemID)
{
return(preferencesFromUser.GetValue(i));
}
}
return(null);
}
public override float?GetPreferenceValue(long userID, long itemID)
{
IPreferenceArray prefs = GetPreferencesFromUser(userID);
int size = prefs.Length();
for (int i = 0; i < size; i++)
{
if (prefs.GetItemID(i) == itemID)
{
return(prefs.GetValue(i));
}
}
return(null);
}
/// Sets temporary preferences for a given anonymous user.
public void SetTempPrefs(IPreferenceArray prefs, long anonymousUserID)
{
//Preconditions.checkArgument(prefs != null && prefs.Length() > 0, "prefs is null or empty");
this.tempPrefs[anonymousUserID] = prefs;
FastIDSet userPrefItemIDs = new FastIDSet();
for (int i = 0; i < prefs.Length(); i++)
{
userPrefItemIDs.Add(prefs.GetItemID(i));
}
this.prefItemIDs[anonymousUserID] = userPrefItemIDs;
}
private static long setBits(FastIDSet modelSet, IPreferenceArray prefs, int max)
{
long maxItem = -1;
for (int i = 0; i < prefs.Length() && i < max; i++)
{
long itemID = prefs.GetItemID(i);
modelSet.Add(itemID);
if (itemID > maxItem)
{
maxItem = itemID;
}
}
return(maxItem);
}
public void testPreferencesForItem()
{
IPreferenceArray prefs = model.GetPreferencesForItem(456);
Assert.NotNull(prefs);
IPreference pref1 = prefs.Get(0);
Assert.AreEqual(123, pref1.GetUserID());
Assert.AreEqual(456, pref1.GetItemID());
IPreference pref2 = prefs.Get(1);
Assert.AreEqual(456, pref2.GetUserID());
Assert.AreEqual(456, pref2.GetItemID());
Assert.AreEqual(2, prefs.Length());
}
protected override FastIDSet doGetCandidateItems(long[] preferredItemIDs, IDataModel dataModel)
{
FastIDSet possibleItemsIDs = new FastIDSet();
foreach (long itemID in preferredItemIDs)
{
IPreferenceArray itemPreferences = dataModel.GetPreferencesForItem(itemID);
int numUsersPreferringItem = itemPreferences.Length();
for (int index = 0; index < numUsersPreferringItem; index++)
{
possibleItemsIDs.AddAll(dataModel.GetItemIDsFromUser(itemPreferences.GetUserID(index)));
}
}
possibleItemsIDs.RemoveAll(preferredItemIDs);
return(possibleItemsIDs);
}
public override float?GetPreferenceValue(long userID, long itemID)
{
if (isAnonymousUser(userID))
{
IPreferenceArray singleUserTempPrefs = tempPrefs[userID];
for (int i = 0; i < singleUserTempPrefs.Length(); i++)
{
if (singleUserTempPrefs.GetItemID(i) == itemID)
{
return(singleUserTempPrefs.GetValue(i));
}
}
return(null);
}
return(getDelegate().GetPreferenceValue(userID, itemID));
}
public float Get(long key)
{
IPreferenceArray prefs = inf.dataModel.GetPreferencesFromUser(key);
int size = prefs.Length();
if (size == 0)
{
return(ZERO);
}
IRunningAverage average = new FullRunningAverage();
for (int i = 0; i < size; i++)
{
average.AddDatum(prefs.GetValue(i));
}
return((float)average.GetAverage());
}
public FastIDSet GetRelevantItemsIDs(long userID,
int at,
double relevanceThreshold,
IDataModel dataModel)
{
IPreferenceArray prefs = dataModel.GetPreferencesFromUser(userID);
FastIDSet relevantItemIDs = new FastIDSet(at);
prefs.SortByValueReversed();
for (int i = 0; i < prefs.Length() && relevantItemIDs.Count() < at; i++)
{
if (prefs.GetValue(i) >= relevanceThreshold)
{
relevantItemIDs.Add(prefs.GetItemID(i));
}
}
return(relevantItemIDs);
}
public static FastByIDMap <FastIDSet> toDataMap(FastByIDMap <IPreferenceArray> data)
{
var res = new FastByIDMap <FastIDSet>(data.Count());
foreach (var entry in data.EntrySet())
{
IPreferenceArray prefArray = entry.Value;
int size = prefArray.Length();
FastIDSet itemIDs = new FastIDSet(size);
for (int i = 0; i < size; i++)
{
itemIDs.Add(prefArray.GetItemID(i));
}
res.Put(entry.Key, itemIDs);
}
return(res);
}
private static long[] getCommonItems(FastIDSet commonSet, IPreferenceArray prefs1, int max)
{
long[] commonItems = new long[max];
int index = 0;
for (int i = 0; i < prefs1.Length(); i++)
{
long item = prefs1.GetItemID(i);
if (commonSet.Contains(item))
{
commonItems[index++] = item;
}
if (index == max)
{
break;
}
}
return(commonItems);
}
public List <IRecommendedItem> RecommendedBecause(long userID, long itemID, int howMany)
{
//Preconditions.checkArgument(howMany >= 1, "howMany must be at least 1");
IDataModel model = GetDataModel();
TopItems.IEstimator <long> estimator = new RecommendedBecauseEstimator(this, userID, itemID);
IPreferenceArray prefs = model.GetPreferencesFromUser(userID);
int size = prefs.Length();
FastIDSet allUserItems = new FastIDSet(size);
for (int i = 0; i < size; i++)
{
allUserItems.Add(prefs.GetItemID(i));
}
allUserItems.Remove(itemID);
return(TopItems.GetTopItems(howMany, allUserItems.GetEnumerator(), null, estimator));
}
private void splitOneUsersPrefs(double trainingPercentage,
FastByIDMap <IPreferenceArray> trainingPrefs,
FastByIDMap <IPreferenceArray> testPrefs,
long userID,
IDataModel dataModel)
{
List <IPreference> oneUserTrainingPrefs = null;
List <IPreference> oneUserTestPrefs = null;
IPreferenceArray prefs = dataModel.GetPreferencesFromUser(userID);
int size = prefs.Length();
for (int i = 0; i < size; i++)
{
IPreference newPref = new GenericPreference(userID, prefs.GetItemID(i), prefs.GetValue(i));
if (random.nextDouble() < trainingPercentage)
{
if (oneUserTrainingPrefs == null)
{
oneUserTrainingPrefs = new List <IPreference>(3);
}
oneUserTrainingPrefs.Add(newPref);
}
else
{
if (oneUserTestPrefs == null)
{
oneUserTestPrefs = new List <IPreference>(3);
}
oneUserTestPrefs.Add(newPref);
}
}
if (oneUserTrainingPrefs != null)
{
trainingPrefs.Put(userID, new GenericUserPreferenceArray(oneUserTrainingPrefs));
if (oneUserTestPrefs != null)
{
testPrefs.Put(userID, new GenericUserPreferenceArray(oneUserTestPrefs));
}
}
}
public override IList <IRecommendedItem> Recommend(long userID, int howMany, IDRescorer rescorer)
{
//Preconditions.checkArgument(howMany >= 1, "howMany must be at least 1");
log.Debug("Recommending items for user ID '{}'", userID);
IPreferenceArray preferencesFromUser = GetDataModel().GetPreferencesFromUser(userID);
if (preferencesFromUser.Length() == 0)
{
return(new List <IRecommendedItem>());
}
FastIDSet possibleItemIDs = GetAllOtherItems(userID, preferencesFromUser);
TopItems.IEstimator <long> estimator = new Estimator(this, userID, preferencesFromUser);
List <IRecommendedItem> topItems = TopItems.GetTopItems(howMany, possibleItemIDs.GetEnumerator(), rescorer,
estimator);
log.Debug("Recommendations are: {}", topItems);
return(topItems);
}
protected override FastIDSet doGetCandidateItems(long[] preferredItemIDs, IDataModel dataModel)
{
var preferredItemIDsIterator = ((IEnumerable <long>)preferredItemIDs).GetEnumerator();
if (preferredItemIDs.Length > maxItems)
{
double samplingRate = (double)maxItems / preferredItemIDs.Length;
log.Info("preferredItemIDs.Length {0}, samplingRate {1}", preferredItemIDs.Length, samplingRate);
preferredItemIDsIterator =
new SamplinglongPrimitiveIterator(preferredItemIDsIterator, samplingRate);
}
FastIDSet possibleItemsIDs = new FastIDSet();
while (preferredItemIDsIterator.MoveNext())
{
long itemID = preferredItemIDsIterator.Current;
IPreferenceArray prefs = dataModel.GetPreferencesForItem(itemID);
int prefsLength = prefs.Length();
if (prefsLength > maxUsersPerItem)
{
var sampledPrefs =
new FixedSizeSamplingIterator <IPreference>(maxUsersPerItem, prefs.GetEnumerator());
while (sampledPrefs.MoveNext())
{
addSomeOf(possibleItemsIDs, dataModel.GetItemIDsFromUser(sampledPrefs.Current.GetUserID()));
}
}
else
{
for (int i = 0; i < prefsLength; i++)
{
addSomeOf(possibleItemsIDs, dataModel.GetItemIDsFromUser(prefs.GetUserID(i)));
}
}
}
possibleItemsIDs.RemoveAll(preferredItemIDs);
return(possibleItemsIDs);
}
private static IPreferenceArray cloneAndMergeInto(IPreferenceArray delegatePrefs,
long itemID,
long newUserID,
float value) {
int length = delegatePrefs == null ? 0 : delegatePrefs.Length();
int newLength = length + 1;
IPreferenceArray newPreferenceArray = new GenericItemPreferenceArray(newLength);
// Set item ID once
newPreferenceArray.SetItemID(0, itemID);
int positionToInsert = 0;
while (positionToInsert < length && newUserID > delegatePrefs.GetUserID(positionToInsert)) {
positionToInsert++;
}
for (int i = 0; i < positionToInsert; i++) {
newPreferenceArray.SetUserID(i, delegatePrefs.GetUserID(i));
newPreferenceArray.SetValue(i, delegatePrefs.GetValue(i));
}
newPreferenceArray.SetUserID(positionToInsert, newUserID);
newPreferenceArray.SetValue(positionToInsert, value);
for (int i = positionToInsert + 1; i < newLength; i++) {
newPreferenceArray.SetUserID(i, delegatePrefs.GetUserID(i - 1));
newPreferenceArray.SetValue(i, delegatePrefs.GetValue(i - 1));
}
return newPreferenceArray;
}
private static long[] getCommonItems(FastIDSet commonSet, IPreferenceArray prefs1, int max) {
long[] commonItems = new long[max];
int index = 0;
for (int i = 0; i < prefs1.Length(); i++) {
long item = prefs1.GetItemID(i);
if (commonSet.Contains(item)) {
commonItems[index++] = item;
}
if (index == max) {
break;
}
}
return commonItems;
}
private static double computeThreshold(IPreferenceArray prefs) {
if (prefs.Length() < 2) {
// Not enough data points -- return a threshold that allows everything
return Double.NegativeInfinity;
}
IRunningAverageAndStdDev stdDev = new FullRunningAverageAndStdDev();
int size = prefs.Length();
for (int i = 0; i < size; i++) {
stdDev.AddDatum(prefs.GetValue(i));
}
return stdDev.GetAverage() + stdDev.GetStandardDeviation();
}
protected IList<Tuple<int,double>> sparseUserRatingVector(IPreferenceArray prefs) {
var ratings = new List<Tuple<int, double>>(prefs.Length());
foreach (IPreference preference in prefs) {
ratings.Add(new Tuple<int, double>((int)preference.GetItemID(), preference.GetValue()));
}
return ratings;
}
public static double[] ratingVector(IPreferenceArray prefs) {
double[] ratings = new double[prefs.Length()];
for (int n = 0; n < prefs.Length(); n++) {
ratings[n] = prefs.Get(n).GetValue();
}
return ratings; //, true); new DenseVector(
}
/// Sets temporary preferences for a given anonymous user.
public void SetTempPrefs(IPreferenceArray prefs, long anonymousUserID) {
//Preconditions.checkArgument(prefs != null && prefs.Length() > 0, "prefs is null or empty");
this.tempPrefs[anonymousUserID] = prefs;
FastIDSet userPrefItemIDs = new FastIDSet();
for (int i = 0; i < prefs.Length(); i++) {
userPrefItemIDs.Add(prefs.GetItemID(i));
}
this.prefItemIDs[anonymousUserID] = userPrefItemIDs;
}
public void SetTempPrefs(IPreferenceArray prefs) {
//Preconditions.checkArgument(prefs != null && prefs.Length() > 0, "prefs is null or empty");
this.tempPrefs = prefs;
this.prefItemIDs.Clear();
for (int i = 0; i < prefs.Length(); i++) {
this.prefItemIDs.Add(prefs.GetItemID(i));
}
}
private static long setBits(FastIDSet modelSet, IPreferenceArray prefs, int max) {
long maxItem = -1;
for (int i = 0; i < prefs.Length() && i < max; i++) {
long itemID = prefs.GetItemID(i);
modelSet.Add(itemID);
if (itemID > maxItem) {
maxItem = itemID;
}
}
return maxItem;
}
