import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
public void buildRecommend(String taskName) {
    String itemmodelsPath = RecommendConfig.class.getResource("/").getPath() + "itemmodels.csv";
    HadoopUtil.download(taskName, itemmodelsPath, true);
    try {
        DataModel dataModel = new FileDataModel(new File(itemmodelsPath));
        UserSimilarity similarity = new SpearmanCorrelationSimilarity(dataModel);
        UserNeighborhood userNeighborhood = new ThresholdUserNeighborhood(0.1, similarity, dataModel);
        LongPrimitiveIterator userIDs = dataModel.getUserIDs();
        while (userIDs.hasNext()) {
            Long userID = userIDs.nextLong();
            long[] neighborhoods = userNeighborhood.getUserNeighborhood(userID);
            for (long neighborhood : neighborhoods) {
                double userSimilarity = similarity.userSimilarity(userID, neighborhood);
                System.out.printf("(%s,%s,%f)", userID, neighborhood, userSimilarity);
                System.out.println();
            }
        }
    } catch (TasteException | IOException e) {
        log.error(e);
    }
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
public void IRState(String taskName) {
    String itemmodelsPath = RecommendConfig.class.getResource("/").getPath() + "itemmodels.csv";
    HadoopUtil.download(taskName, itemmodelsPath, false);
    try {
        DataModel fileDataModel = new FileDataModel(new File(itemmodelsPath));
        RecommenderIRStatsEvaluator irStatsEvaluator = new GenericRecommenderIRStatsEvaluator();
        IRStatistics irStatistics = irStatsEvaluator.evaluate(new RecommenderBuilder() {
            @Override
            public org.apache.mahout.cf.taste.recommender.Recommender buildRecommender(final DataModel dataModel) throws TasteException {
                UserSimilarity userSimilarity = new PearsonCorrelationSimilarity(dataModel);
                UserNeighborhood userNeighborhood = new NearestNUserNeighborhood(5, userSimilarity, dataModel);
                return new GenericUserBasedRecommender(dataModel, userNeighborhood, userSimilarity);
            }
        }, new DataModelBuilder() {
            @Override
            public DataModel buildDataModel(final FastByIDMap<PreferenceArray> fastByIDMap) {
                return new GenericDataModel(fastByIDMap);
            }
        }, fileDataModel, null, 5, GenericRecommenderIRStatsEvaluator.CHOOSE_THRESHOLD, 1.0);
        System.out.println("查准率:" + irStatistics.getPrecision());
        System.out.println("查全率:" + irStatistics.getRecall());
    } catch (TasteException | IOException e) {
        e.printStackTrace();
    }
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
public static void main(String[] args) throws IOException, TasteException {
	DataModel model  = 
			new FileDataModel(new File("data/ua.base"));
	
	UserSimilarity similarity = 
			new PearsonCorrelationSimilarity(model);
	
	UserNeighborhood neighborhood = 
			new NearestNUserNeighborhood(2, similarity, model);
	
	Recommender recommender = new GenericUserBasedRecommender(
			model, neighborhood, similarity);
	
	List<RecommendedItem> recommendations = recommender.recommend(2, 1);
	
	for (RecommendedItem recommendation : recommendations) {
		logger.info(recommendation.toString());
	}
	
	logger.info("over");
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
private static void recommend(String ratingsFile, int ... userIds)
    throws TasteException, IOException {
  DataModel model = new FileDataModel(new File(ratingsFile));

  UserSimilarity similarity = new PearsonCorrelationSimilarity(model);

  UserNeighborhood neighborhood =
      new NearestNUserNeighborhood(
          100, similarity, model);

  Recommender recommender =  new GenericUserBasedRecommender(
      model, neighborhood, similarity);

  Recommender cachingRecommender = new CachingRecommender(recommender);

  for(int userId: userIds) {
    System.out.println("UserID " + userId);
    List<RecommendedItem> recommendations =
        cachingRecommender.recommend(userId, 2);
    for(RecommendedItem item: recommendations) {
      System.out.println("  item " + item.getItemID() + " score " + item.getValue());
    }
  }
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
public static void main(String[] args) throws IOException, TasteException {
	RandomUtils.useTestSeed();
	
	final DataModel model = new FileDataModel(new File("data/intro.csv"));
	
	RecommenderIRStatsEvaluator evaluator = 
			new GenericRecommenderIRStatsEvaluator();
	
	RecommenderBuilder recommenderBuilder = new RecommenderBuilder() {
		
		public Recommender buildRecommender(DataModel dataModel) throws TasteException {
			UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
			UserNeighborhood neighborhood = 
					new NearestNUserNeighborhood(2, similarity, model);
			return new GenericUserBasedRecommender(model, neighborhood, similarity);
		}
	};
	
	IRStatistics stats = evaluator.evaluate(recommenderBuilder, null, model, null, 2, 
			GenericRecommenderIRStatsEvaluator.CHOOSE_THRESHOLD, 1.0);
	
	System.out.println(stats.getPrecision());
	System.out.println(stats.getRecall());
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
public static void main(String[] args) {
    try {
        MysqlDataSource dataSource = new MysqlDataSource();
        dataSource.setServerName("localhost");
        dataSource.setUser("root");
        dataSource.setPassword("root");
        dataSource.setDatabaseName("rec");
        JDBCDataModel dm = new MySQLJDBCDataModel(dataSource,"ratings","userid","itemid","rating","");
        UserSimilarity similarity = new PearsonCorrelationSimilarity(dm);
        UserNeighborhood neighbor = new NearestNUserNeighborhood(2,similarity, dm);
        Recommender recommender = new GenericUserBasedRecommender(dm, neighbor, similarity);
        List<RecommendedItem> list = recommender.recommend(1, 3);// recommend
                                                                 // one item
                                                                 // to user
                                                                 // 1
        for (RecommendedItem ri : list) {
            System.out.println(ri);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
public static void main( String[] args ) throws IOException, TasteException
{
	//user based recommender model
	DataModel model = new FileDataModel(new File("data/dataset.csv"));    	
	UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
	UserNeighborhood neighborhood = new ThresholdUserNeighborhood(0.1, similarity, model);
	UserBasedRecommender recommender = new GenericUserBasedRecommender(model, neighborhood, similarity);
	List<RecommendedItem> recommendations = recommender.recommend(2, 3);
	for (RecommendedItem recommendation : recommendations) {
	  System.out.println(recommendation);
	}
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
@Override
public List<Student> getSimilarStudents(Student student) {
    UserNeighborhood userNeighborhood = studentNeighborhoodStore.getStudentNeighborhood();
    long[] userIds;
    try {
        userIds = userNeighborhood.getUserNeighborhood(student.getId());
    } catch (TasteException e) {
        return Collections.emptyList();
    }

    ArrayList<Student> students = new ArrayList<>();
    Arrays.stream(userIds).forEach(id -> students.add(studentRepository.findOne(id)));

    return students;
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
@Override
@Cacheable(STUDENT_NEIGHBORHOOD_CACHE_NAME)
public UserNeighborhood getStudentNeighborhood() {
    DataModel model = buildDataModel();
    UserSimilarity similarity = buildSimilarityIndex(model);

    return new ThresholdUserNeighborhood(0.3, similarity, model);
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
public static void main(String[] args) throws IOException, TasteException {
	RandomUtils.useTestSeed();
	
	final DataModel model = new FileDataModel(new File("data/ua.base"));
	
	RecommenderEvaluator evaluator = new AverageAbsoluteDifferenceRecommenderEvaluator();
	
	RecommenderBuilder builder = new RecommenderBuilder() {
		
		public Recommender buildRecommender(DataModel dataModel) throws TasteException {
			UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
			UserNeighborhood neighborhood = 
					new NearestNUserNeighborhood(2, similarity, model);
			return new GenericUserBasedRecommender(model, neighborhood, similarity);
		}
	};
	
	double score = evaluator.evaluate(builder, null, model, 0.7, 1.0);
	
	System.out.println(score);
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
@Test
public void mahoutSlopeoneGeneratorTest_testBoolRecommender() throws TasteException {
    EasyrecDataModel easyrecDataModel = new EasyrecDataModel(TENANT_ID, BUY_ACTION_TYPE_ID, false, mahoutDataModelMappingDAO);
    /*TanimotoCoefficientSimilarity is intended for "binary" data sets  where a user either expresses a generic "yes" preference for an item or has no preference.*/
    UserSimilarity userSimilarity = new TanimotoCoefficientSimilarity(easyrecDataModel);

    /*ThresholdUserNeighborhood is preferred in situations where we go in for a  similarity measure between neighbors and not any number*/
    UserNeighborhood neighborhood = new ThresholdUserNeighborhood(0.1d, userSimilarity, easyrecDataModel);

    /*GenericBooleanPrefUserBasedRecommender is appropriate for use when no notion of preference value exists in the data. */
    Recommender recommender = new GenericBooleanPrefUserBasedRecommender(easyrecDataModel, neighborhood, userSimilarity);

    Assert.assertEquals(30, recommender.recommend(3, 1).get(0).getItemID());
    Assert.assertEquals(1,(int) recommender.recommend(3, 1).get(0).getValue());
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
@Override
public UserBasedRecommender buildRecommender(DataModel dataModel) throws TasteException {

    UserNeighborhood neighborhood =
            new ThresholdUserNeighborhood(
                    0.1, new PearsonCorrelationSimilarity(dataModel), dataModel);

    return new GenericBooleanPrefUserBasedRecommender(
            dataModel,
            neighborhood,
            similarity);
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
@Override
public Recommender buildRecommender(DataModel model)
    throws TasteException {
  UserSimilarity similarity =
      new PearsonCorrelationSimilarity(model);

  UserNeighborhood neighborhood =
      new NearestNUserNeighborhood(
          100,
          similarity, model);

  return new GenericUserBasedRecommender(
      model, neighborhood, similarity);
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
public static UserNeighborhood userNeighborhood(NEIGHBORHOOD type, UserSimilarity s, DataModel m, double num) throws TasteException {
    switch (type) {
        case NEAREST:
            /**
             * 根据数量构建最近的距离
             */
            return new NearestNUserNeighborhood((int) num, s, m);
        case THRESHOLD:
        default:
            /**
             * 根据百分比去构建
             */
            return new ThresholdUserNeighborhood(num, s, m);
    }
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
public static void userCF(DataModel dataModel) throws TasteException {
    UserSimilarity userSimilarity = RecommendFactory.userSimilarity(RecommendFactory.SIMILARITY.CITYBLOCK, dataModel);
    UserNeighborhood userNeighborhood = RecommendFactory.userNeighborhood(RecommendFactory.NEIGHBORHOOD.NEAREST, userSimilarity, dataModel, NEIGHBORHOOD_NUM);
    RecommenderBuilder recommenderBuilder = RecommendFactory.userRecommender(userSimilarity, userNeighborhood, true);

    RecommendFactory.evaluate(RecommendFactory.EVALUATOR.AVERAGE_ABSOLUTE_DIFFERENCE, recommenderBuilder, null, dataModel, 0.7);
    RecommendFactory.statsEvaluator(recommenderBuilder, null, dataModel, 2);

    LongPrimitiveIterator iter = dataModel.getUserIDs();
    while (iter.hasNext()) {
        long uid = iter.nextLong();
        List<RecommendedItem> list = recommenderBuilder.buildRecommender(dataModel).recommend(uid, RECOMMENDER_NUM);
        RecommendFactory.showItems(uid, list, true);
    }
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
/**
 * UserCF1
 * 1、首先我们需要传递数据模型,然后去构建用户的相似度
 * 2、找到用户的近邻
 * 3、构建推荐的Builder
 * 4、对结果进行评分
 * [其他的基本上也是一样]
 */
public static RecommenderBuilder userLoglikelihood(DataModel dataModel) throws TasteException, IOException {
    System.out.println("userLoglikelihood");
    UserSimilarity userSimilarity = RecommendFactory.userSimilarity(RecommendFactory.SIMILARITY.LOGLIKELIHOOD, dataModel);
    UserNeighborhood userNeighborhood = RecommendFactory.userNeighborhood(RecommendFactory.NEIGHBORHOOD.NEAREST, userSimilarity, dataModel, NEIGHBORHOOD_NUM);
    RecommenderBuilder recommenderBuilder = RecommendFactory.userRecommender(userSimilarity, userNeighborhood, false);

    RecommendFactory.evaluate(RecommendFactory.EVALUATOR.AVERAGE_ABSOLUTE_DIFFERENCE, recommenderBuilder, null, dataModel, 0.7);
    RecommendFactory.statsEvaluator(recommenderBuilder, null, dataModel, 2);
    return recommenderBuilder;
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
/**
 * Recommender IR Evaluator: [Precision:0.919580419580419,Recall:0.4371584699453552]
 */
public static RecommenderBuilder userCityBlock(DataModel dataModel) throws TasteException, IOException {
    System.out.println("userCityBlock");
    UserSimilarity userSimilarity = RecommendFactory.userSimilarity(RecommendFactory.SIMILARITY.CITYBLOCK, dataModel);
    UserNeighborhood userNeighborhood = RecommendFactory.userNeighborhood(RecommendFactory.NEIGHBORHOOD.NEAREST, userSimilarity, dataModel, NEIGHBORHOOD_NUM);
    RecommenderBuilder recommenderBuilder = RecommendFactory.userRecommender(userSimilarity, userNeighborhood, false);

    RecommendFactory.evaluate(RecommendFactory.EVALUATOR.AVERAGE_ABSOLUTE_DIFFERENCE, recommenderBuilder, null, dataModel, 0.7);
    RecommendFactory.statsEvaluator(recommenderBuilder, null, dataModel, 2);
    return recommenderBuilder;
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
public static RecommenderBuilder userTanimoto(DataModel dataModel) throws TasteException, IOException {
    System.out.println("userTanimoto");
    UserSimilarity userSimilarity = RecommendFactory.userSimilarity(RecommendFactory.SIMILARITY.TANIMOTO, dataModel);
    UserNeighborhood userNeighborhood = RecommendFactory.userNeighborhood(RecommendFactory.NEIGHBORHOOD.NEAREST, userSimilarity, dataModel, NEIGHBORHOOD_NUM);
    RecommenderBuilder recommenderBuilder = RecommendFactory.userRecommender(userSimilarity, userNeighborhood, false);

    RecommendFactory.evaluate(RecommendFactory.EVALUATOR.AVERAGE_ABSOLUTE_DIFFERENCE, recommenderBuilder, null, dataModel, 0.7);
    RecommendFactory.statsEvaluator(recommenderBuilder, null, dataModel, 2);
    return recommenderBuilder;
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
/**
 * Get the user neighborhood instance, with the correct neighborhood size and algorithm
 * as specified during the construction of this RecommendEntityServlet.
 * @param similarity The similarity to form the neighborhood
 * @param model The database model to get the neighborhood of
 * @return The UserNeighborhood instance
 * @throws Exception If an exception is thrown by Mahout it is forwarded upwards.
 */
private UserNeighborhood getNeighborhood(UserSimilarity similarity, DataModel model) throws TasteException {
    if(this.neighborhoodAlg.equalsIgnoreCase(N_THRESHOLD)){
        return new ThresholdUserNeighborhood(this.neighborhoodSize, similarity, model);
    } else if(this.neighborhoodAlg.equalsIgnoreCase(N_NUSER) || this.neighborhoodAlg == null){ // == null is the default case
        return new NearestNUserNeighborhood((int)this.neighborhoodSize, similarity, model);
    } else {
        throw new TasteException("Unknown neighborhood algorithm type: " + this.neighborhoodAlg);
    }
}
 

import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood; //导入依赖的package包/类
/**
 * レコメンデーションを生成して出力
 * @param datamodel
 * @param similarity
 * @param userId
 * @param howMany
 * @throws TasteException
 */
private void recommend(DataModel datamodel, UserSimilarity similarity, UserAffinityVO dto) throws TasteException {
    super.i("◆ " + similarity.getClass());
    similarity.setPreferenceInferrer(new AveragingPreferenceInferrer(datamodel));
    UserNeighborhood neighbor = new NearestNUserNeighborhood(dto.size, similarity, datamodel);
    Recommender recommender = new GenericUserBasedRecommender(datamodel, neighbor, similarity);
    List<RecommendedItem> items = recommender.recommend(dto.userId, dto.howMany);
    for (RecommendedItem item : items) {
        super.i("◆ " + item);
    }
}