@Override public ItemScorer get() { if (fallback == null) { return primary; } else { return new FallbackItemScorer(primary, fallback); } } }
/** * {@inheritDoc} * * This implementation delegates to {@link #recommendRelatedItems(Set, int, Set, Set)} with default sets. */ @Override public List<Long> recommendRelatedItems(Set<Long> basket, int n) { return recommendRelatedItems(basket, n, null, null); }
/** * {@inheritDoc} * * This implementation delegates to {@link #recommend(long, int)} with a length of -1. */ @Override public List<Long> recommend(long user) { return recommend(user, -1); }
@Before public void setupScorer() { primary = PrecomputedItemScorer.newBuilder() .addScore(42, 39, 3.5) .build(); baseline = PrecomputedItemScorer.newBuilder() .addScore(42, 39, 2.0) .addScore(42, 30, 4.0) .addScore(15, 30, 5.0) .build(); scorer = new FallbackItemScorer(primary, baseline); }
@Before public void Setup() { mockScorer = PrecomputedItemScorer.newBuilder() .addScore(1, 3, 3.5) .addScore(2, 4, 5) .addScore(2, 6, 3) .addScore(3, 1, 5) .addScore(3, 2, 4.5) .addScore(3, 3, 2.5) .addScore(3, 4, 1) .build(); cachedScorer = new SimpleCachingItemScorer(mockScorer); }
@Before public void setUp() throws Exception { ItemScorer scorer = PrecomputedItemScorer.newBuilder() .addScore(40, 1, 4.0) .addScore(40, 2, 5.5) .addScore(40, 3, -1) .build(); PreferenceDomain domain = new PreferenceDomain(1, 5, 1); pred = new SimpleRatingPredictor(scorer, domain); unclamped = new SimpleRatingPredictor(scorer, null); }
@Test public void testFallbackUser() { // score for user only known by secondary FallbackResult r = scorer.score(15, 30); assertThat(r, notNullValue()); assertThat(r.getScore(), equalTo(5.0)); assertThat(r.isFromPrimary(), equalTo(false)); }
/** * Construct a new quantized predictor. * @param scorer The item scorer to use. * @param q The quantizer. */ @Inject public QuantizedRatingPredictor(@PredictionScorer ItemScorer scorer, Quantizer q) { itemScorer = scorer; quantizer = q; }
@Override public List<Long> recommendRelatedItems(Set<Long> basket) { return recommendRelatedItems(basket, -1); }
@Override public List<Long> recommendRelatedItems(long reference, int n) { return recommendWithPredicate(n, i -> i != reference); }
/** * Construct a new builder for precomputed item scorers. This is useful for building item * scorers for mocks. * * @return A new builder for item scorers. */ public static Builder newBuilder() { return new Builder(); } }
/** * Create a new constant item scorer. * @param score The score to return. */ @Inject public ConstantItemScorer(@Value double score) { fixedScore = score; }
/** * Add a score. When the item is scored for the user, the mock scorer will return this score. * * @param user The user ID. * @param item The item ID. * @param score The score to return. * @return The builder (for chaining). */ public Builder addScore(long user, long item, double score) { return addResults(user, Results.create(item, score)); }
@Test public void testFallbackItem() { // score for item only known by secondary FallbackResult r = scorer.score(42, 30); assertThat(r, notNullValue()); assertThat(r.getScore(), equalTo(4.0)); assertThat(r.isFromPrimary(), equalTo(false)); }
@Override public List<Long> recommendRelatedItems(long reference) { return recommendRelatedItems(reference, -1); }
/** * {@inheritDoc} * * This implementation delegates to {@link #recommendRelatedItems(long, int)} with a size of -1. */ @Override public List<Long> recommendRelatedItems(long reference) { return recommendRelatedItems(reference, -1); }
/** * {@inheritDoc} * * This implementation delegates to {@link #recommend(long, int, Set, Set)} with a length of -1 and null sets. */ @Override public List<Long> recommend(long user, int n) { return recommend(user, n, null, null); }
@Test public void testScoreItemPrimary() { // score known by the primary FallbackResult r = scorer.score(42, 39); assertThat(r, notNullValue()); assertThat(r.getScore(), equalTo(3.5)); assertThat(r.isFromPrimary(), equalTo(true)); }
/** * {@inheritDoc} * * This implementation delegates to {@link #recommendRelatedItems(Set, int)} with a length of -1. */ @Override public List<Long> recommendRelatedItems(Set<Long> basket) { return recommendRelatedItems(basket, -1); } }
/** * {@inheritDoc} * * This implementation delegates to {@link #recommendRelatedItems(Set, int)}. */ @Override public List<Long> recommendRelatedItems(long reference, int n) { return recommendRelatedItems(LongSets.singleton(reference), n); }