public GenericUserBasedRecommender(IDataModel dataModel,
IUserNeighborhood neighborhood,
IUserSimilarity similarity) : base(dataModel)
{
//Preconditions.checkArgument(neighborhood != null, "neighborhood is null");
this.neighborhood = neighborhood;
this.similarity = similarity;
this.refreshHelper = new RefreshHelper(() => {
capper = buildCapper();
});
refreshHelper.AddDependency(dataModel);
refreshHelper.AddDependency(similarity);
refreshHelper.AddDependency(neighborhood);
capper = buildCapper();
}
public void SetPreferenceInferrer(IPreferenceInferrer inferrer)
{
//Preconditions.checkArgument(inferrer != null, "inferrer is null");
refreshHelper.AddDependency(inferrer);
refreshHelper.RemoveDependency(this.inferrer);
this.inferrer = inferrer;
}
protected AbstractItemSimilarity(IDataModel dataModel)
{
//Preconditions.checkArgument(dataModel != null, "dataModel is null");
this.dataModel = dataModel;
this.refreshHelper = new RefreshHelper(null);
refreshHelper.AddDependency(this.dataModel);
}
protected AbstractFactorizer(IDataModel dataModel)
{
this.dataModel = dataModel;
buildMappings();
refreshHelper = new RefreshHelper(() => {
buildMappings();
});
refreshHelper.AddDependency(dataModel);
}
public ItemAverageRecommender(IDataModel dataModel) : base(dataModel)
{
this.itemAverages = new FastByIDMap <IRunningAverage>();
this.refreshHelper = new RefreshHelper(() => {
buildAverageDiffs();
});
refreshHelper.AddDependency(dataModel);
buildAverageDiffs();
}
/// Creates this on top of the given {@link UserSimilarity}.
/// The cache size is capped by the given size.
public CachingUserSimilarity(IUserSimilarity similarity, int maxCacheSize)
{
//Preconditions.checkArgument(similarity != null, "similarity is null");
this.similarity = similarity;
this.similarityCache = new Cache <Tuple <long, long>, Double>(new SimilarityRetriever(similarity), maxCacheSize);
this.refreshHelper = new RefreshHelper(() => {
similarityCache.Clear();
});
refreshHelper.AddDependency(similarity);
}
public GenericItemBasedRecommender(IDataModel dataModel,
IItemSimilarity similarity,
ICandidateItemsStrategy candidateItemsStrategy,
IMostSimilarItemsCandidateItemsStrategy mostSimilarItemsCandidateItemsStrategy) :
base(dataModel, candidateItemsStrategy)
{
//Preconditions.checkArgument(similarity != null, "similarity is null");
this.similarity = similarity;
//Preconditions.checkArgument(mostSimilarItemsCandidateItemsStrategy != null,
// "mostSimilarItemsCandidateItemsStrategy is null");
this.mostSimilarItemsCandidateItemsStrategy = mostSimilarItemsCandidateItemsStrategy;
this.refreshHelper = new RefreshHelper(() => {
capper = buildCapper();
});
refreshHelper.AddDependency(dataModel);
refreshHelper.AddDependency(similarity);
refreshHelper.AddDependency(candidateItemsStrategy);
refreshHelper.AddDependency(mostSimilarItemsCandidateItemsStrategy);
capper = buildCapper();
}
public ItemUserAverageRecommender(IDataModel dataModel) : base(dataModel)
{
this.itemAverages = new FastByIDMap <IRunningAverage>();
this.userAverages = new FastByIDMap <IRunningAverage>();
this.overallAveragePrefValue = new FullRunningAverage();
//this.buildAveragesLock = new ReentrantReadWriteLock();
this.refreshHelper = new RefreshHelper(() => {
buildAverageDiffs();
});
refreshHelper.AddDependency(dataModel);
buildAverageDiffs();
}
/// Create an SVDRecommender using a persistent store to cache factorizations. A factorization is loaded from the
/// store if present, otherwise a new factorization is computed and saved in the store.
///
/// The {@link #refresh(java.util.Collection) refresh} method recomputes the factorization and overwrites the store.
///
/// @param dataModel
/// @param factorizer
/// @param candidateItemsStrategy
/// @param persistenceStrategy
///
/// @throws TasteException
public SVDRecommender(IDataModel dataModel, IFactorizer factorizer, ICandidateItemsStrategy candidateItemsStrategy,
IPersistenceStrategy persistenceStrategy) : base(dataModel, candidateItemsStrategy)
{
this.factorizer = factorizer; //Preconditions.checkNotNull(factorizer);
this.persistenceStrategy = persistenceStrategy; // Preconditions.checkNotNull(persistenceStrategy);
try {
factorization = persistenceStrategy.Load();
} catch (IOException e) {
throw new TasteException("Error loading factorization", e);
}
if (factorization == null)
{
train();
}
refreshHelper = new RefreshHelper(() => {
train();
});
refreshHelper.AddDependency(GetDataModel());
refreshHelper.AddDependency(factorizer);
refreshHelper.AddDependency(candidateItemsStrategy);
}
public CachingRecommender(IRecommender recommender)
{
//Preconditions.checkArgument(recommender != null, "recommender is null");
this.recommender = recommender;
maxHowMany = new int[] { 1 };
// Use "num users" as an upper limit on cache size. Rough guess.
int numUsers = recommender.GetDataModel().GetNumUsers();
recommendationsRetriever = new RecommendationRetriever(this);
recommendationCache = new Cache <long, Recommendations>(recommendationsRetriever, numUsers);
estimatedPrefCache = new Cache <Tuple <long, long>, float>(new EstimatedPrefRetriever(this), numUsers);
refreshHelper = new RefreshHelper(() => {
clear();
});
refreshHelper.AddDependency(recommender);
}