How to use

LenskitBinding

in

org.lenskit

@SuppressWarnings("unchecked")
@Override
public void addComponent(@Nonnull Class<?> type) {
  bind((Class) type).to(type);
}

/**
 * Get extra LensKit configuration required by this data set.
 *
 * @return A LensKit configuration with additional configuration data for this data set.
 */
public LenskitConfiguration getExtraConfiguration() {
  LenskitConfiguration config = new LenskitConfiguration();
  PreferenceDomain pd = trainData.getPreferenceDomain();
  if (pd != null) {
    config.bind(PreferenceDomain.class).to(pd);
  }
  config.bind(TestUsers.class, LongSet.class)
     .toProvider(testUserProvider);
  return config;
}

@SuppressWarnings("unchecked")
@Override
public void addComponent(@Nonnull Object obj) {
  bind((Class) obj.getClass()).toInstance(obj);
}

protected LenskitConfiguration getDaoConfig() {
  LenskitConfiguration config = new LenskitConfiguration();
  config.bind(DataAccessObject.class)
     .toProvider(source);
  return config;
}

@Nonnull
public LenskitConfiguration getConfiguration() {
  StaticDataSource src = getSource();
  LenskitConfiguration config = new LenskitConfiguration();
  if (src != null) {
    config.bind(DataAccessObject.class).toProvider(src);
  }
  return config;
}

/**
 * Make and bind a preference domain.  With this method, this:
 * <pre>
 *     domain minimum: 1, maximum: 5
 * </pre>
 * <p>is equivalent to:
 * <pre>
 *     bind PreferenceDomain to prefDomain(minimum: 1, maximum: 5)
 * </pre>
 *
 * @param args The arguments.
 * @return The preference domain.
 * @see #prefDomain(java.util.Map)
 */
public PreferenceDomain domain(Map<String,Object> args) {
  PreferenceDomain dom = prefDomain(args);
  bind(PreferenceDomain.class).to(dom);
  return dom;
}

private LenskitConfiguration makeDataConfig(Context ctx) {
  LenskitConfiguration config = new LenskitConfiguration();
  config.bind(DataAccessObject.class).toProvider(new DAOProvider());
  String dspec = ctx.options.getString("domain");
  if (dspec != null) {
    PreferenceDomain domain = PreferenceDomain.fromString(dspec);
    config.bind(PreferenceDomain.class).to(domain);
  }
  return config;
}

@Test
public void testComputeUserMeans() {
  EntityFactory efac = new EntityFactory();
  EntityCollectionDAOBuilder daoBuilder = new EntityCollectionDAOBuilder();
  daoBuilder.addEntities(efac.rating(100, 200, 3.0),
              efac.rating(101, 200, 4.0),
              efac.rating(102, 201, 2.5),
              efac.rating(102, 203, 4.5),
              efac.rating(101, 203, 3.5));
  LenskitConfiguration config = new LenskitConfiguration();
  config.addRoot(BiasModel.class);
  config.bind(BiasModel.class).toProvider(UserAverageRatingBiasModelProvider.class);
  LenskitRecommender rec = LenskitRecommender.build(config, daoBuilder.build());
  BiasModel model = rec.get(BiasModel.class);
  assertThat(model.getIntercept(), closeTo(3.5, 1.0e-3));
  assertThat(model.getUserBias(100), closeTo(-0.5, 1.0e-3));
  assertThat(model.getUserBias(101), closeTo(0.25, 1.0e-3));
  assertThat(model.getUserBias(102), closeTo(0.0, 1.0e-3));
}

@SuppressWarnings("unchecked")
@Override
public void addComponent(@Nonnull Object obj) {
  bind((Class) obj.getClass()).toInstance(obj);
}

@SuppressWarnings("unchecked")
@Override
protected void configureAlgorithm(LenskitConfiguration config) {
  config.bind(ItemScorer.class)
     .to(FunkSVDItemScorer.class);
  config.bind(BaselineScorer.class, ItemScorer.class)
     .to(UserMeanItemScorer.class);
  config.bind(UserMeanBaseline.class, ItemScorer.class)
     .to(ItemMeanRatingItemScorer.class);
  config.within(BaselineScorer.class, ItemScorer.class)
     .set(MeanDamping.class)
     .to(10);
  config.set(FeatureCount.class).to(25);
  config.set(IterationCount.class).to(125);
  config.bind(RatingPredictor.class)
     .to(OrdRecRatingPredictor.class);
  config.bind(Quantizer.class)
     .to(PreferenceDomainQuantizer.class);
}

  @SuppressWarnings("deprecation")
  @Before
  public void setup() throws RecommenderBuildException {
    List<Rating> rs = new ArrayList<>();
    rs.add(Rating.create(1, 5, 2));
    rs.add(Rating.create(1, 7, 4));
    rs.add(Rating.create(8, 4, 5));
    rs.add(Rating.create(8, 5, 4));
    StaticDataSource source = StaticDataSource.fromList(rs);

    LenskitConfiguration config = new LenskitConfiguration();
    config.bind(DataAccessObject.class).toProvider(source);
    config.bind(ItemScorer.class).to(ItemItemScorer.class);
    config.bind(ItemBasedItemScorer.class).to(ItemItemItemBasedItemScorer.class);
    // this is the default
//        factory.setComponent(UserVectorNormalizer.class, VectorNormalizer.class,
//                             IdentityVectorNormalizer.class);

    engine = LenskitRecommenderEngine.build(config);
  }

  @Test
  public void testComputeMeans() {
    EntityFactory efac = new EntityFactory();
    EntityCollectionDAOBuilder daoBuilder = new EntityCollectionDAOBuilder();
    daoBuilder.addEntities(efac.rating(100, 200, 3.0),
                efac.rating(101, 200, 4.0),
                efac.rating(101, 201, 2.5),
                efac.rating(102, 203, 4.5),
                efac.rating(103, 203, 3.5));
    LenskitConfiguration config = new LenskitConfiguration();
    config.addRoot(BiasModel.class);
    config.bind(BiasModel.class).toProvider(ItemAverageRatingBiasModelProvider.class);

    LenskitRecommender rec = LenskitRecommender.build(config, daoBuilder.build());
    BiasModel model = rec.get(BiasModel.class);

    assertThat(model.getIntercept(), closeTo(3.5, 1.0e-3));
    assertThat(model.getItemBias(200), closeTo(0.0, 1.0e-3));
    assertThat(model.getItemBias(201), closeTo(-1.0, 1.0e-3));
    assertThat(model.getItemBias(203), closeTo(0.5, 1.0e-3));
  }
}

@SuppressWarnings("deprecation")
@Before
public void setup() throws RecommenderBuildException {
  List<Rating> rs = new ArrayList<>();
  rs.add(Rating.create(1, 5, 2));
  rs.add(Rating.create(1, 7, 4));
  rs.add(Rating.create(8, 4, 5));
  rs.add(Rating.create(8, 5, 4));
  StaticDataSource source = StaticDataSource.fromList(rs);
  DataAccessObject dao = source.get();
  LenskitConfiguration config = new LenskitConfiguration();
  config.bind(DataAccessObject.class).to(dao);
  config.bind(ItemScorer.class).to(UserUserItemScorer.class);
  config.bind(NeighborFinder.class).to(LiveNeighborFinder.class);
  engine = LenskitRecommenderEngine.build(config);
}

  @SuppressWarnings("deprecation")
  @Before
  public void setup() throws RecommenderBuildException {
    List<Rating> rs = new ArrayList<>();
    rs.add(Rating.create(1, 5, 2));
    rs.add(Rating.create(1, 7, 4));
    rs.add(Rating.create(8, 4, 5));
    rs.add(Rating.create(8, 5, 4));
    StaticDataSource source = StaticDataSource.fromList(rs);
    dao = source.get();

    LenskitConfiguration config = new LenskitConfiguration();
    config.bind(ItemItemModel.class).toProvider(NormalizingItemItemModelProvider.class);
    config.bind(ItemScorer.class).to(ItemItemScorer.class);
    config.bind(ItemBasedItemScorer.class).to(ItemItemItemBasedItemScorer.class);
    // this is the default
//        factory.setComponent(UserVectorNormalizer.class, VectorNormalizer.class,
//                             IdentityVectorNormalizer.class);

    engine = LenskitRecommenderEngine.build(config, dao);
  }

@Test
public void testComputeItemMeans() {
  EntityFactory efac = new EntityFactory();
  EntityCollectionDAOBuilder daoBuilder = new EntityCollectionDAOBuilder();
  daoBuilder.addEntities(efac.rating(100, 200, 3.0),
              efac.rating(101, 200, 4.0),
              efac.rating(101, 201, 2.5),
              efac.rating(102, 203, 4.5),
              efac.rating(103, 203, 3.5));
  LenskitConfiguration config = new LenskitConfiguration();
  config.addRoot(BiasModel.class);
  config.bind(BiasModel.class).toProvider(ItemAverageRatingBiasModelProvider.class);
  LenskitRecommender rec = LenskitRecommender.build(config, daoBuilder.build());
  BiasModel model = rec.get(BiasModel.class);
  assertThat(model.getIntercept(), closeTo(3.5, 1.0e-3));
  assertThat(model.getItemBias(200), closeTo(0.0, 1.0e-3));
  assertThat(model.getItemBias(201), closeTo(-1.0, 1.0e-3));
  assertThat(model.getItemBias(203), closeTo(0.5, 1.0e-3));
}

@SuppressWarnings({"deprecation", "unchecked"})
private LenskitRecommenderEngine makeEngine() throws RecommenderBuildException {
  LenskitConfiguration config = new LenskitConfiguration();
  config.bind(RatingMatrix.class)
     .to(PackedRatingMatrix.class);
  config.bind(ItemScorer.class)
     .to(FunkSVDItemScorer.class);
  config.bind(BiasModel.class).to(UserItemBiasModel.class);
  config.set(IterationCount.class)
     .to(10);
  config.set(FeatureCount.class)
     .to(20);
  return LenskitRecommenderEngine.build(config, dao);
}

  private LenskitRecommenderEngine makeEngine() throws RecommenderBuildException {
    LenskitConfiguration config = new LenskitConfiguration();
    config.bind(RatingMatrix.class)
        .to(PackedRatingMatrix.class);
    config.bind(ItemScorer.class)
        .to(HPFItemScorer.class);
    config.bind(HPFModel.class)
        .toProvider(HPFModelProvider.class);
    config.set(ConvergenceCheckFrequency.class)
        .to(2);
    config.set(StoppingThreshold.class)
        .to(0.000001);
    config.set(FeatureCount.class)
        .to(5);
    config.set(SplitProportion.class)
        .to(0.1);
//        config.set(RandomSeed.class)
//                .to(System.currentTimeMillis());
    config.set(IterationCount.class)
        .to(1000);
    config.set(IsProbabilityPrediction.class)
        .to(false);

    return LenskitRecommenderEngine.build(config, dao);
  }

  @Test
  public void testComputeAllMeans() {
    EntityFactory efac = new EntityFactory();
    EntityCollectionDAOBuilder daoBuilder = new EntityCollectionDAOBuilder();
    daoBuilder.addEntities(efac.rating(100, 200, 3.0),
                efac.rating(101, 200, 4.0),
                efac.rating(102, 201, 2.5),
                efac.rating(102, 203, 4.5),
                efac.rating(101, 203, 3.5));
    LenskitConfiguration config = new LenskitConfiguration();
    config.addRoot(BiasModel.class);
    config.bind(BiasModel.class).toProvider(UserItemAverageRatingBiasModelProvider.class);

    LenskitRecommender rec = LenskitRecommender.build(config, daoBuilder.build());
    BiasModel model = rec.get(BiasModel.class);

    assertThat(model.getIntercept(), closeTo(3.5, 1.0e-3));
    assertThat(model.getItemBias(200), closeTo(0.0, 1.0e-3));
    assertThat(model.getItemBias(201), closeTo(-1.0, 1.0e-3));
    assertThat(model.getItemBias(203), closeTo(0.5, 1.0e-3));
    assertThat(model.getUserBias(100), closeTo(-0.5, 1.0e-3));
    assertThat(model.getUserBias(101), closeTo(0, 1.0e-3));
    assertThat(model.getUserBias(102), closeTo(0.25, 1.0e-3));
  }
}

@SuppressWarnings("deprecation")
@Before
public void setup() throws RecommenderBuildException {
  List<Rating> rs = new ArrayList<>();
  rs.add(Rating.create(1, 5, 2));
  rs.add(Rating.create(1, 7, 4));
  rs.add(Rating.create(8, 4, 5));
  rs.add(Rating.create(8, 5, 4));
  StaticDataSource source = StaticDataSource.fromList(rs);
  dao = source.get();
  LenskitConfiguration config = new LenskitConfiguration();
  config.bind(ItemScorer.class).to(SlopeOneItemScorer.class);
  config.bind(PreferenceDomain.class).to(new PreferenceDomain(1, 5));
  // factory.setComponent(UserVectorNormalizer.class, IdentityVectorNormalizer.class);
  config.bind(BaselineScorer.class, ItemScorer.class)
     .to(UserMeanItemScorer.class);
  config.bind(UserMeanBaseline.class, ItemScorer.class)
     .to(ItemMeanRatingItemScorer.class);
  engine = LenskitRecommenderEngine.build(config, dao);
}

@Before
public void createRatingSource() {
  EntityFactory efac = new EntityFactory();
  List<Rating> rs = new ArrayList<>();
  rs.add(efac.rating(1, 5, 2));
  rs.add(efac.rating(1, 7, 4));
  rs.add(efac.rating(8, 4, 5));
  rs.add(efac.rating(8, 5, 4));
  source = new StaticDataSource();
  source.addSource(rs);
  dao = source.get();
  config = new LenskitConfiguration();
  config.bind(ItemScorer.class).to(BiasItemScorer.class);
}