public class GenericItemBasedRecommender extends AbstractRecommender implements ItemBasedRecommender
A simple Recommender
which uses a given
DataModel
and
ItemSimilarity
to produce recommendations. This class
represents Taste's support for item-based recommenders.
The ItemSimilarity
is the most important point to discuss
here. Item-based recommenders are useful because they can take advantage of something to be very fast: they
base their computations on item similarity, not user similarity, and item similarity is relatively static.
It can be precomputed, instead of re-computed in real time.
Thus it's strongly recommended that you use
GenericItemSimilarity
with pre-computed similarities if
you're going to use this class. You can use
PearsonCorrelationSimilarity
too, which computes
similarities in real-time, but will probably find this painfully slow for large amounts of data.
Modifier and Type | Class and Description |
---|---|
static class |
GenericItemBasedRecommender.MostSimilarEstimator |
Constructor and Description |
---|
GenericItemBasedRecommender(DataModel dataModel,
ItemSimilarity similarity) |
GenericItemBasedRecommender(DataModel dataModel,
ItemSimilarity similarity,
CandidateItemsStrategy candidateItemsStrategy,
MostSimilarItemsCandidateItemsStrategy mostSimilarItemsCandidateItemsStrategy) |
Modifier and Type | Method and Description |
---|---|
protected float |
doEstimatePreference(long userID,
PreferenceArray preferencesFromUser,
long itemID) |
float |
estimatePreference(long userID,
long itemID) |
protected static MostSimilarItemsCandidateItemsStrategy |
getDefaultMostSimilarItemsCandidateItemsStrategy() |
ItemSimilarity |
getSimilarity() |
List<RecommendedItem> |
mostSimilarItems(long[] itemIDs,
int howMany) |
List<RecommendedItem> |
mostSimilarItems(long[] itemIDs,
int howMany,
boolean excludeItemIfNotSimilarToAll) |
List<RecommendedItem> |
mostSimilarItems(long[] itemIDs,
int howMany,
Rescorer<LongPair> rescorer) |
List<RecommendedItem> |
mostSimilarItems(long[] itemIDs,
int howMany,
Rescorer<LongPair> rescorer,
boolean excludeItemIfNotSimilarToAll) |
List<RecommendedItem> |
mostSimilarItems(long itemID,
int howMany) |
List<RecommendedItem> |
mostSimilarItems(long itemID,
int howMany,
Rescorer<LongPair> rescorer) |
List<RecommendedItem> |
recommend(long userID,
int howMany,
IDRescorer rescorer,
boolean includeKnownItems) |
List<RecommendedItem> |
recommendedBecause(long userID,
long itemID,
int howMany)
Lists the items that were most influential in recommending a given item to a given user.
|
void |
refresh(Collection<Refreshable> alreadyRefreshed)
Triggers "refresh" -- whatever that means -- of the implementation.
|
String |
toString() |
getAllOtherItems, getDataModel, getDefaultCandidateItemsStrategy, recommend, recommend, recommend, removePreference, setPreference
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
getDataModel, recommend, recommend, recommend, removePreference, setPreference
public GenericItemBasedRecommender(DataModel dataModel, ItemSimilarity similarity, CandidateItemsStrategy candidateItemsStrategy, MostSimilarItemsCandidateItemsStrategy mostSimilarItemsCandidateItemsStrategy)
public GenericItemBasedRecommender(DataModel dataModel, ItemSimilarity similarity)
protected static MostSimilarItemsCandidateItemsStrategy getDefaultMostSimilarItemsCandidateItemsStrategy()
public ItemSimilarity getSimilarity()
public List<RecommendedItem> recommend(long userID, int howMany, IDRescorer rescorer, boolean includeKnownItems) throws TasteException
recommend
in interface Recommender
userID
- user for which recommendations are to be computedhowMany
- desired number of recommendationsrescorer
- rescoring function to apply before final list of recommendations is determinedincludeKnownItems
- whether to include items already known by the user in recommendationsList
of recommended RecommendedItem
s, ordered from most strongly recommend to
leastTasteException
- if an error occurs while accessing the DataModel
public float estimatePreference(long userID, long itemID) throws TasteException
estimatePreference
in interface Recommender
userID
- user ID whose preference is to be estimateditemID
- item ID to estimate preference forDouble.NaN
TasteException
- if an error occurs while accessing the DataModel
public List<RecommendedItem> mostSimilarItems(long itemID, int howMany) throws TasteException
mostSimilarItems
in interface ItemBasedRecommender
itemID
- ID of item for which to find most similar other itemshowMany
- desired number of most similar items to findTasteException
- if an error occurs while accessing the DataModel
public List<RecommendedItem> mostSimilarItems(long itemID, int howMany, Rescorer<LongPair> rescorer) throws TasteException
mostSimilarItems
in interface ItemBasedRecommender
itemID
- ID of item for which to find most similar other itemshowMany
- desired number of most similar items to findrescorer
- Rescorer
which can adjust item-item similarity estimates used to determine most similar
itemsTasteException
- if an error occurs while accessing the DataModel
public List<RecommendedItem> mostSimilarItems(long[] itemIDs, int howMany) throws TasteException
mostSimilarItems
in interface ItemBasedRecommender
itemIDs
- IDs of item for which to find most similar other itemshowMany
- desired number of most similar items to find estimates used to determine most similar itemsTasteException
- if an error occurs while accessing the DataModel
public List<RecommendedItem> mostSimilarItems(long[] itemIDs, int howMany, Rescorer<LongPair> rescorer) throws TasteException
mostSimilarItems
in interface ItemBasedRecommender
itemIDs
- IDs of item for which to find most similar other itemshowMany
- desired number of most similar items to findrescorer
- Rescorer
which can adjust item-item similarity estimates used to determine most similar
itemsTasteException
- if an error occurs while accessing the DataModel
public List<RecommendedItem> mostSimilarItems(long[] itemIDs, int howMany, boolean excludeItemIfNotSimilarToAll) throws TasteException
mostSimilarItems
in interface ItemBasedRecommender
itemIDs
- IDs of item for which to find most similar other itemshowMany
- desired number of most similar items to findexcludeItemIfNotSimilarToAll
- exclude an item if it is not similar to each of the input itemsTasteException
- if an error occurs while accessing the DataModel
public List<RecommendedItem> mostSimilarItems(long[] itemIDs, int howMany, Rescorer<LongPair> rescorer, boolean excludeItemIfNotSimilarToAll) throws TasteException
mostSimilarItems
in interface ItemBasedRecommender
itemIDs
- IDs of item for which to find most similar other itemshowMany
- desired number of most similar items to findrescorer
- Rescorer
which can adjust item-item similarity estimates used to determine most similar
itemsexcludeItemIfNotSimilarToAll
- exclude an item if it is not similar to each of the input itemsTasteException
- if an error occurs while accessing the DataModel
public List<RecommendedItem> recommendedBecause(long userID, long itemID, int howMany) throws TasteException
ItemBasedRecommender
Lists the items that were most influential in recommending a given item to a given user. Exactly how this is determined is left to the implementation, but, generally this will return items that the user prefers and that are similar to the given item.
This returns a List
of RecommendedItem
which is a little misleading since it's returning
recommending items, but, I thought it more natural to just reuse this class since it
encapsulates an item and value. The value here does not necessarily have a consistent interpretation or
expected range; it will be higher the more influential the item was in the recommendation.
recommendedBecause
in interface ItemBasedRecommender
userID
- ID of user who was recommended the itemitemID
- ID of item that was recommendedhowMany
- maximum number of items to returnList
of RecommendedItem
, ordered from most influential in recommended the given
item to leastTasteException
- if an error occurs while accessing the DataModel
protected float doEstimatePreference(long userID, PreferenceArray preferencesFromUser, long itemID) throws TasteException
TasteException
public void refresh(Collection<Refreshable> alreadyRefreshed)
Refreshable
Triggers "refresh" -- whatever that means -- of the implementation. The general contract is that any
Refreshable
should always leave itself in a consistent, operational state, and that the refresh
atomically updates internal state from old to new.
refresh
in interface Refreshable
alreadyRefreshed
- Refreshable
s that are known to have already been
refreshed as a result of an initial call to a {#refresh(Collection)} method on some
object. This ensure that objects in a refresh dependency graph aren't refreshed twice
needlessly.Copyright © 2008–2017 The Apache Software Foundation. All rights reserved.