public double getSimilarity(FastIDSet cluster1, FastIDSet cluster2)
{
if (cluster1.isEmpty() || cluster2.isEmpty())
{
return(Double.NaN);
}
double leastSimilarity = Double.PositiveInfinity;
var someUsers = SamplingLongPrimitiveIterator.maybeWrapIterator(cluster1.GetEnumerator(), samplingRate);
while (someUsers.MoveNext())
{
long userID1 = someUsers.Current;
var it2 = cluster2.GetEnumerator();
while (it2.MoveNext())
{
double theSimilarity = similarity.userSimilarity(userID1, it2.Current);
if (theSimilarity < leastSimilarity)
{
leastSimilarity = theSimilarity;
}
}
}
// We skipped everything? well, at least try comparing the first Users to get some value
if (leastSimilarity == Double.PositiveInfinity)
{
return(similarity.userSimilarity(cluster1.GetEnumerator().Current, cluster2.GetEnumerator().Current));
}
return(leastSimilarity);
}
public void testStrategy()
{
FastIDSet allItemIDs = new FastIDSet();
allItemIDs.AddAll(new long[] { 1L, 2L, 3L });
FastIDSet preferredItemIDs = new FastIDSet(1);
preferredItemIDs.Add(2L);
var dataModelMock = new DynamicMock( typeof( IDataModel ));
dataModelMock.ExpectAndReturn("GetNumItems", 3);
dataModelMock.ExpectAndReturn("GetItemIDs", allItemIDs.GetEnumerator());
IPreferenceArray prefArrayOfUser123 = new GenericUserPreferenceArray( new List<IPreference>() {
new GenericPreference(123L, 2L, 1.0f) } );
ICandidateItemsStrategy strategy = new AllUnknownItemsCandidateItemsStrategy();
//EasyMock.replay(dataModel);
FastIDSet candidateItems = strategy.GetCandidateItems(123L, prefArrayOfUser123, (IDataModel)dataModelMock.MockInstance);
Assert.AreEqual(2, candidateItems.Count() );
Assert.True(candidateItems.Contains(1L));
Assert.True(candidateItems.Contains(3L));
dataModelMock.Verify();
//EasyMock.verify(dataModel);
}
public void testStrategy()
{
FastIDSet allItemIDs = new FastIDSet();
allItemIDs.AddAll(new long[] { 1L, 2L, 3L });
FastIDSet preferredItemIDs = new FastIDSet(1);
preferredItemIDs.Add(2L);
var dataModelMock = new DynamicMock(typeof(IDataModel));
dataModelMock.ExpectAndReturn("GetNumItems", 3);
dataModelMock.ExpectAndReturn("GetItemIDs", allItemIDs.GetEnumerator());
IPreferenceArray prefArrayOfUser123 = new GenericUserPreferenceArray(new List <IPreference>()
{
new GenericPreference(123L, 2L, 1.0f)
});
ICandidateItemsStrategy strategy = new AllUnknownItemsCandidateItemsStrategy();
//EasyMock.replay(dataModel);
FastIDSet candidateItems = strategy.GetCandidateItems(123L, prefArrayOfUser123, (IDataModel)dataModelMock.MockInstance);
Assert.AreEqual(2, candidateItems.Count());
Assert.True(candidateItems.Contains(1L));
Assert.True(candidateItems.Contains(3L));
dataModelMock.Verify();
//EasyMock.verify(dataModel);
}
private List <IRecommendedItem> doMostSimilarItems(long[] itemIDs,
int howMany,
TopItems.IEstimator <long> estimator)
{
FastIDSet possibleItemIDs = mostSimilarItemsCandidateItemsStrategy.GetCandidateItems(itemIDs, GetDataModel());
return(TopItems.GetTopItems(howMany, possibleItemIDs.GetEnumerator(), null, estimator));
}
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);
FastIDSet set = this.getAllOtherItems(userID, preferencesFromUser);
TopItems.Estimator <long> estimator = new Estimator(this);
List <RecommendedItem> list = TopItems.getTopItems(howMany, set.GetEnumerator(), rescorer, estimator);
log.debug("Recommendations are: {}", new object[] { list });
return(list);
}
public override List <RecommendedItem> recommend(long userID, int howMany, taste.recommender.IDRescorer rescorer)
{
//Preconditions.checkArgument(howMany >= 1, "howMany must be at least 1");
log.debug("Recommending items for user ID '{}'", userID);
FastIDSet possibleItemIDs = diffStorage.getRecommendableItemIDs(userID);
TopItems.Estimator <long> estimator = new Estimator(this, userID);
List <RecommendedItem> topItems = TopItems.getTopItems(howMany, possibleItemIDs.GetEnumerator(), rescorer, estimator);
log.debug("Recommendations are: {}", topItems);
return(topItems);
}
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);
FastIDSet possibleItemIDs = GetAllOtherItems(userID, preferencesFromUser);
List <IRecommendedItem> topItems = TopItems.GetTopItems(howMany, possibleItemIDs.GetEnumerator(), rescorer,
new Estimator(this, userID));
log.Debug("Recommendations are: {}", topItems);
return(topItems);
}
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 override List <RecommendedItem> recommend(long userID, int howMany, IDRescorer rescorer)
{
log.debug("Recommending items for user ID '{}'", new object[] { userID });
long[] theNeighborhood = this.neighborhood.getUserNeighborhood(userID);
if (theNeighborhood.Length == 0)
{
return(new List <RecommendedItem>());
}
FastIDSet set = this.getAllOtherItems(theNeighborhood, userID);
TopItems.Estimator <long> estimator = new Estimator(this, userID, theNeighborhood);
List <RecommendedItem> list = TopItems.getTopItems(howMany, set.GetEnumerator(), rescorer, estimator);
log.debug("Recommendations are: {}", new object[] { list });
return(list);
}
private void addSomeOf(FastIDSet possibleItemIDs, FastIDSet itemIDs)
{
if (itemIDs.Count() > maxItemsPerUser)
{
var it =
new SamplinglongPrimitiveIterator(itemIDs.GetEnumerator(), (double)maxItemsPerUser / itemIDs.Count());
while (it.MoveNext())
{
possibleItemIDs.Add(it.Current);
}
}
else
{
possibleItemIDs.AddAll(itemIDs);
}
}
public double estimate(long itemID)
{
DataModel dataModel = this.re.getDataModel();
RunningAverage average = new FullRunningAverage();
var it = cluster.GetEnumerator();
while (it.MoveNext())
{
float?pref = dataModel.getPreferenceValue(it.Current, itemID);
if (pref != null)
{
average.addDatum(pref.Value);
}
}
return(average.getAverage());
}
/// <p>
/// Creates a new {@link GenericDataModel} from the given users (and their preferences). This
/// {@link DataModel} retains all this information in memory and is effectively immutable.
/// </p>
///
/// @param userData users to include
/// @param timestamps optionally, provided timestamps of preferences as milliseconds since the epoch.
/// User IDs are mapped to maps of item IDs to long timestamps.
public GenericBooleanPrefDataModel(FastByIDMap <FastIDSet> userData, FastByIDMap <FastByIDMap <DateTime?> > timestamps)
{
//Preconditions.checkArgument(userData != null, "userData is null");
this.preferenceFromUsers = userData;
this.preferenceForItems = new FastByIDMap <FastIDSet>();
FastIDSet itemIDSet = new FastIDSet();
foreach (var entry in preferenceFromUsers.EntrySet())
{
long userID = entry.Key;
FastIDSet itemIDs1 = entry.Value;
itemIDSet.AddAll(itemIDs1);
var it = itemIDs1.GetEnumerator();
while (it.MoveNext())
{
long itemID = it.Current;
FastIDSet userIDs1 = preferenceForItems.Get(itemID);
if (userIDs1 == null)
{
userIDs1 = new FastIDSet(2);
preferenceForItems.Put(itemID, userIDs1);
}
userIDs1.Add(userID);
}
}
this.itemIDs = itemIDSet.ToArray();
itemIDSet = null; // Might help GC -- this is big
Array.Sort(itemIDs);
this.userIDs = new long[userData.Count()];
int i = 0;
var it1 = userData.Keys.GetEnumerator();
while (it1.MoveNext())
{
userIDs[i++] = it1.Current;
}
Array.Sort(userIDs);
this.timestamps = timestamps;
}
private List <RecommendedItem> computeTopRecsForCluster(FastIDSet cluster)
{
DataModel dataModel = getDataModel();
FastIDSet possibleItemIDs = new FastIDSet();
var it = cluster.GetEnumerator();
while (it.MoveNext())
{
possibleItemIDs.addAll(dataModel.getItemIDsFromUser(it.Current));
}
TopItems.Estimator <long> estimator = new Estimator(cluster, this);
List <RecommendedItem> topItems = TopItems.getTopItems(NUM_CLUSTER_RECS,
possibleItemIDs.GetEnumerator(), null, estimator);
log.debug("Recommendations are: {}", topItems);
return(topItems);
}
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));
}
public override PreferenceArray getPreferencesFromUser(long userID)
{
FastIDSet set = this.preferenceFromUsers.get(userID);
if (set == null)
{
throw new NoSuchUserException(userID);
}
PreferenceArray array = new BooleanUserPreferenceArray(set.size());
int i = 0;
IEnumerator <long> enumerator = set.GetEnumerator();
while (enumerator.MoveNext())
{
array.setUserID(i, userID);
array.setItemID(i, enumerator.Current);
i++;
}
return(array);
}
/// @throws NoSuchUserException
/// if there is no such user
public override IPreferenceArray GetPreferencesFromUser(long userID)
{
FastIDSet itemIDs = preferenceFromUsers.Get(userID);
if (itemIDs == null)
{
throw new NoSuchUserException(userID);
}
IPreferenceArray prefArray = new BooleanUserPreferenceArray(itemIDs.Count());
int i = 0;
var it = itemIDs.GetEnumerator();
while (it.MoveNext())
{
prefArray.SetUserID(i, userID);
prefArray.SetItemID(i, it.Current);
i++;
}
return(prefArray);
}
public override IPreferenceArray GetPreferencesForItem(long itemID)
{
FastIDSet userIDs = preferenceForItems.Get(itemID);
if (userIDs == null)
{
throw new NoSuchItemException(itemID);
}
IPreferenceArray prefArray = new BooleanItemPreferenceArray(userIDs.Count());
int i = 0;
var it = userIDs.GetEnumerator();
while (it.MoveNext())
{
prefArray.SetUserID(i, it.Current);
prefArray.SetItemID(i, itemID);
i++;
}
return(prefArray);
}
public GenericBooleanPrefDataModel(FastByIDMap <FastIDSet> userData, FastByIDMap <FastByIDMap <DateTime?> > timestamps)
{
this.preferenceFromUsers = userData;
this.preferenceForItems = new FastByIDMap <FastIDSet>();
FastIDSet set = new FastIDSet();
foreach (KeyValuePair <long, FastIDSet> pair in this.preferenceFromUsers.entrySet())
{
long key = pair.Key;
FastIDSet c = pair.Value;
set.addAll(c);
IEnumerator <long> enumerator = c.GetEnumerator();
while (enumerator.MoveNext())
{
long current = enumerator.Current;
FastIDSet set3 = this.preferenceForItems.get(current);
if (set3 == null)
{
set3 = new FastIDSet(2);
this.preferenceForItems.put(current, set3);
}
set3.add(key);
}
}
this.itemIDs = set.toArray();
set = null;
Array.Sort <long>(this.itemIDs);
this.userIDs = new long[userData.size()];
int num3 = 0;
IEnumerator <long> enumerator2 = userData.Keys.GetEnumerator();
while (enumerator2.MoveNext())
{
this.userIDs[num3++] = enumerator2.Current;
}
Array.Sort <long>(this.userIDs);
this.timestamps = timestamps;
}
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);
long[] theNeighborhood = neighborhood.GetUserNeighborhood(userID);
if (theNeighborhood.Length == 0)
{
return(new List <IRecommendedItem>());
}
FastIDSet allItemIDs = getAllOtherItems(theNeighborhood, userID);
TopItems.IEstimator <long> estimator = new Estimator(this, userID, theNeighborhood);
List <IRecommendedItem> topItems = TopItems
.GetTopItems(howMany, allItemIDs.GetEnumerator(), rescorer, estimator);
log.Debug("Recommendations are: {}", topItems);
return(topItems);
}
private void addSomeOf(FastIDSet possibleItemIDs, FastIDSet itemIDs)
{
if (itemIDs.size() > this.maxItemsPerUser)
{
SamplingLongPrimitiveIterator iterator = new SamplingLongPrimitiveIterator(itemIDs.GetEnumerator(), ((double)this.maxItemsPerUser) / ((double)itemIDs.size()));
while (iterator.MoveNext())
{
possibleItemIDs.add(iterator.Current);
}
}
else
{
possibleItemIDs.addAll(itemIDs);
}
}
private void addSomeOf(FastIDSet possibleItemIDs, FastIDSet itemIDs) {
if (itemIDs.Count() > maxItemsPerUser) {
var it =
new SamplinglongPrimitiveIterator(itemIDs.GetEnumerator(), (double) maxItemsPerUser / itemIDs.Count() );
while (it.MoveNext()) {
possibleItemIDs.Add(it.Current);
}
} else {
possibleItemIDs.AddAll(itemIDs);
}
}
protected override float doEstimatePreference(long theUserID, PreferenceArray preferencesFromUser, long itemID)
{
DataModel dataModel = getDataModel();
int size = preferencesFromUser.length();
FastIDSet possibleItemIDs = new FastIDSet(size);
for (int i = 0; i < size; i++)
{
possibleItemIDs.add(preferencesFromUser.getItemID(i));
}
possibleItemIDs.remove(itemID);
List <RecommendedItem> mostSimilar = mostSimilarItems(itemID, possibleItemIDs.GetEnumerator(), neighborhoodSize, null);
long[] theNeighborhood = new long[mostSimilar.Count() + 1];
theNeighborhood[0] = -1;
List <long> usersRatedNeighborhood = new List <long>();
int nOffset = 0;
foreach (RecommendedItem rec in mostSimilar)
{
theNeighborhood[nOffset++] = rec.getItemID();
}
if (mostSimilar.Count != 0)
{
theNeighborhood[mostSimilar.Count] = itemID;
for (int i = 0; i < theNeighborhood.Length; i++)
{
PreferenceArray usersNeighborhood = dataModel.getPreferencesForItem(theNeighborhood[i]);
int size1 = usersRatedNeighborhood.Count == 0 ? usersNeighborhood.length() : usersRatedNeighborhood.Count;
for (int j = 0; j < size1; j++)
{
if (i == 0)
{
usersRatedNeighborhood.Add(usersNeighborhood.getUserID(j));
}
else
{
if (j >= usersRatedNeighborhood.Count)
{
break;
}
long index = usersRatedNeighborhood[j];
if (!usersNeighborhood.hasPrefWithUserID(index) || index == theUserID)
{
usersRatedNeighborhood.Remove(index);
j--;
}
}
}
}
}
double[] weights = null;
if (mostSimilar.Count != 0)
{
weights = getInterpolations(itemID, theNeighborhood, usersRatedNeighborhood);
}
int n = 0;
double preference = 0.0;
double totalSimilarity = 0.0;
foreach (long jitem in theNeighborhood)
{
float?pref = dataModel.getPreferenceValue(theUserID, jitem);
if (pref != null)
{
double weight = weights[n];
preference += pref.Value * weight;
totalSimilarity += weight;
}
n++;
}
return(totalSimilarity == 0.0 ? float.NaN : (float)(preference / totalSimilarity));
}
private List <RecommendedItem> doMostSimilarItems(long[] itemIDs, int howMany, TopItems.Estimator <long> estimator)
{
FastIDSet set = this.mostSimilarItemsCandidateItemsStrategy.getCandidateItems(itemIDs, this.getDataModel());
return(TopItems.getTopItems(howMany, set.GetEnumerator(), null, estimator));
}