Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package net.ufida.info.mahout.common; import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.concurrent.Callable; import org.apache.mahout.cf.taste.common.Refreshable; import org.apache.mahout.cf.taste.common.TasteException; import org.apache.mahout.cf.taste.impl.common.Cache; import org.apache.mahout.cf.taste.impl.common.RefreshHelper; import org.apache.mahout.cf.taste.impl.common.Retriever; import org.apache.mahout.cf.taste.impl.model.PlusAnonymousUserDataModel; import org.apache.mahout.cf.taste.model.DataModel; import org.apache.mahout.cf.taste.recommender.IDRescorer; import org.apache.mahout.cf.taste.recommender.RecommendedItem; import org.apache.mahout.cf.taste.recommender.Recommender; import org.apache.mahout.common.LongPair; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.base.Preconditions; /** * <p> * A {@link Recommender} which caches the results from another {@link Recommender} in memory. * </p> */ public final class CachingRecommender implements Recommender { private static final Logger log = LoggerFactory.getLogger(CachingRecommender.class); private final Recommender recommender; private final int[] maxHowMany; private final Retriever<Long, Recommendations> recommendationsRetriever; private final Cache<Long, Recommendations> recommendationCache; private final Cache<LongPair, Float> estimatedPrefCache; private final RefreshHelper refreshHelper; private IDRescorer currentRescorer; public CachingRecommender(Recommender recommender) throws TasteException { 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(); recommendationCache = new Cache<Long, Recommendations>(recommendationsRetriever, numUsers); estimatedPrefCache = new Cache<LongPair, Float>(new EstimatedPrefRetriever(), numUsers); refreshHelper = new RefreshHelper(new Callable<Object>() { @Override public Object call() { clear(); return null; } }); refreshHelper.addDependency(recommender); } private void setCurrentRescorer(IDRescorer rescorer) { if (rescorer == null) { if (currentRescorer != null) { currentRescorer = null; clear(); } } else { if (!rescorer.equals(currentRescorer)) { currentRescorer = rescorer; clear(); } } } @Override public List<RecommendedItem> recommend(long userID, int howMany) throws TasteException { return recommend(userID, howMany, null); } @Override public List<RecommendedItem> recommend(long userID, int howMany, IDRescorer rescorer) throws TasteException { Preconditions.checkArgument(howMany >= 1, "howMany must be at least 1"); synchronized (maxHowMany) { if (howMany > maxHowMany[0]) { maxHowMany[0] = howMany; } } // Special case, avoid caching an anonymous user if (userID == PlusAnonymousUserDataModel.TEMP_USER_ID) { return recommendationsRetriever.get(PlusAnonymousUserDataModel.TEMP_USER_ID).getItems(); } setCurrentRescorer(rescorer); Recommendations recommendations = recommendationCache.get(userID); if (recommendations.getItems().size() < howMany && !recommendations.isNoMoreRecommendableItems()) { clear(userID); recommendations = recommendationCache.get(userID); if (recommendations.getItems().size() < howMany) { recommendations.setNoMoreRecommendableItems(true); } } List<RecommendedItem> recommendedItems = recommendations.getItems(); return recommendedItems.size() > howMany ? recommendedItems.subList(0, howMany) : recommendedItems; } @Override public float estimatePreference(long userID, long itemID) throws TasteException { return estimatedPrefCache.get(new LongPair(userID, itemID)); } @Override public void setPreference(long userID, long itemID, float value) throws TasteException { recommender.setPreference(userID, itemID, value); clear(userID); } @Override public void removePreference(long userID, long itemID) throws TasteException { recommender.removePreference(userID, itemID); clear(userID); } @Override public DataModel getDataModel() { return recommender.getDataModel(); } @Override public void refresh(Collection<Refreshable> alreadyRefreshed) { refreshHelper.refresh(alreadyRefreshed); } /** * <p> * Clears cached recommendations for the given user. * </p> * * @param userID * clear cached data associated with this user ID */ public void clear(final long userID) { log.debug("Clearing recommendations for user ID '{}'", userID); recommendationCache.remove(userID); estimatedPrefCache.removeKeysMatching(new Cache.MatchPredicate<LongPair>() { @Override public boolean matches(LongPair userItemPair) { return userItemPair.getFirst() == userID; } }); } /** * <p> * Clears all cached recommendations. * </p> */ public void clear() { log.debug("Clearing all recommendations..."); recommendationCache.clear(); estimatedPrefCache.clear(); } @Override public String toString() { return "CachingRecommender[recommender:" + recommender + ']'; } private final class RecommendationRetriever implements Retriever<Long, Recommendations> { @Override public Recommendations get(Long key) throws TasteException { log.debug("Retrieving new recommendations for user ID '{}'", key); int howMany = maxHowMany[0]; IDRescorer rescorer = currentRescorer; List<RecommendedItem> recommendations = rescorer == null ? recommender.recommend(key, howMany) : recommender.recommend(key, howMany, rescorer); return new Recommendations(Collections.unmodifiableList(recommendations)); } } private final class EstimatedPrefRetriever implements Retriever<LongPair, Float> { @Override public Float get(LongPair key) throws TasteException { long userID = key.getFirst(); long itemID = key.getSecond(); log.debug("Retrieving estimated preference for user ID '{}' and item ID '{}'", userID, itemID); return recommender.estimatePreference(userID, itemID); } } private static final class Recommendations { private final List<RecommendedItem> items; private boolean noMoreRecommendableItems; private Recommendations(List<RecommendedItem> items) { this.items = items; } List<RecommendedItem> getItems() { return items; } boolean isNoMoreRecommendableItems() { return noMoreRecommendableItems; } void setNoMoreRecommendableItems(boolean noMoreRecommendableItems) { this.noMoreRecommendableItems = noMoreRecommendableItems; } } }