public List<RecommendedItem> recommend(long userId, PreferenceArray preferences) throws TasteException {

		if (userExistsInDataModel(userId)) {
			return recommender.recommend(userId, noItems);
		}
		else {
			PlusAnonymousConcurrentUserDataModel plusModel = (PlusAnonymousConcurrentUserDataModel) recommender.getDataModel();

			// Take an available anonymous user form the poll
			Long anonymousUserID = plusModel.takeAvailableUser();

			// Set temporary preferences
			PreferenceArray tempPrefs = preferences;
			tempPrefs.setUserID(0, anonymousUserID);
			// tempPrefs.setItemID(0, itemID);
			plusModel.setTempPrefs(tempPrefs, anonymousUserID);

			List<RecommendedItem> results = recommender.recommend(anonymousUserID, noItems);

			// Release the user back to the poll
			plusModel.releaseUser(anonymousUserID);

			return results;

		}
	}
 

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());
    }
  }
}
 

@Override
public RecommendedItem next() {
  FastByIDFloatMap.MapEntry entry = countsIterator.next();
  long id = entry.getKey();
  float value = entry.getValue();
  IDRescorer theRescorer = rescorer;
  if (theRescorer != null) {
    if (theRescorer.isFiltered(id)) {
      return null;
    }
    value = (float) theRescorer.rescore(id, value);
    if (!LangUtils.isFinite(value)) {
      return null;
    }
  }
  delegate.set(id, value);
  return delegate;
}
 

@Test
public void testAnonymous() throws Exception {

  ClientRecommender client = getClient();
  List<RecommendedItem> recs = client.recommendToAnonymous(new long[] {190L}, 3);

  assertNotNull(recs);
  assertEquals(3, recs.size());

  log.info("{}", recs);

  assertEquals(83L, recs.get(0).getItemID());
  assertEquals(213L, recs.get(1).getItemID());
  assertEquals(86L, recs.get(2).getItemID());

  try {
    client.recommendToAnonymous(new long[]{0L}, 3);
    fail();
  } catch (NoSuchItemException nsie) {
    // good
  }
}
 

@Test
public void testAnonymous2() throws Exception {

  ClientRecommender client = getClient();
  List<RecommendedItem> recs =
      client.recommendToAnonymous(new long[] {190L}, new float[] {1.0f}, 3);

  assertNotNull(recs);
  assertEquals(3, recs.size());

  log.info("{}", recs);

  assertEquals(83L, recs.get(0).getItemID());
  assertEquals(213L, recs.get(1).getItemID());
  assertEquals(86L, recs.get(2).getItemID());

  try {
    client.recommendToAnonymous(new long[]{0L}, 3);
    fail();
  } catch (NoSuchItemException nsie) {
    // good
  }
}
 

@Override
public EvaluationResult evaluate(MyrrixRecommender recommender,
                                 RescorerProvider provider, // ignored
                                 Multimap<Long,RecommendedItem> testData) throws TasteException {
  DoubleWeightedMean score = new DoubleWeightedMean();
  int count = 0;
  for (Map.Entry<Long,RecommendedItem> entry : testData.entries()) {
    long userID = entry.getKey();
    RecommendedItem itemPref = entry.getValue();
    try {
      float estimate = recommender.estimatePreference(userID, itemPref.getItemID());
      Preconditions.checkState(LangUtils.isFinite(estimate));
      score.increment(1.0 - estimate, itemPref.getValue());
    } catch (NoSuchItemException nsie) {
      // continue
    } catch (NoSuchUserException nsue) {
      // continue
    }
    if (++count % 100000 == 0) {
      log.info("Score: {}", score);
    }
  }
  log.info("Score: {}", score);
  return new EvaluationResultImpl(score.getResult());
}
 

@Override
public RecommendedItem next() {
  FastByIDMap.MapEntry<float[]> entry = toFeaturesIterator.next();
  long itemID = entry.getKey();
  if (userTagIDs.contains(itemID)) {
    return null;
  }
  float[] candidateFeatures = entry.getValue();
  double candidateFeaturesNorm = SimpleVectorMath.norm(candidateFeatures);
  double estimate = SimpleVectorMath.dot(candidateFeatures, features) / (candidateFeaturesNorm * featuresNorm);
  if (!LangUtils.isFinite(estimate)) {
    return null;
  }
  delegate.set(itemID, (float) estimate);
  return delegate;
}
 

@Override
public int compare(RecommendedItem a, RecommendedItem b) {
  float aValue = a.getValue();
  float bValue = b.getValue();
  if (aValue < bValue) {
    return -1;
  }
  if (aValue > bValue) {
    return 1;
  }
  // Break ties by item ID, *de*scending. It's rare but at least gives predictable ordering.
  long aItem = a.getItemID();
  long bItem = b.getItemID();
  if (aItem > bItem) {
    return -1;
  }
  if (aItem < bItem) {
    return 1;
  }
  return 0;
}
 

@Test
public void testMostPopular() throws Exception {

  ClientRecommender client = getClient();
  List<RecommendedItem> popular = client.mostPopularItems(3);

  assertNotNull(popular);
  assertEquals(3, popular.size());

  log.info("{}", popular);

  assertEquals(50L, popular.get(0).getItemID());
  assertEquals(258L, popular.get(1).getItemID());
  assertEquals(100L, popular.get(2).getItemID());
  assertEquals(583.0f, popular.get(0).getValue());
  assertEquals(509.0f, popular.get(1).getValue());
  assertEquals(508.0f, popular.get(2).getValue());
}
 

@Override
public List<TranslatedRecommendedItem> recommendToAnonymous(String[] itemIDs,
                                                            float[] values,
                                                            int howMany,
                                                            String[] rescorerParams,
                                                            String contextUserID)
    throws TasteException {
  long[] longItemIDs = translateItems(itemIDs);
  Collection<RecommendedItem> originals;
  if (contextUserID == null) {
    originals = delegate.recommendToAnonymous(longItemIDs, values, howMany, rescorerParams, null);
  } else {
    originals =
        delegate.recommendToAnonymous(longItemIDs, values, howMany, rescorerParams, translateUser(contextUserID));
  }
  return translate(originals);
}
 

private static List<RecommendedItem> consumeItems(URLConnection connection) throws IOException {
  List<RecommendedItem> result = Lists.newArrayList();
  BufferedReader reader = IOUtils.bufferStream(connection.getInputStream());
  try {
    CharSequence line;
    while ((line = reader.readLine()) != null) {
      Iterator<String> tokens = COMMA.split(line).iterator();
      long itemID = Long.parseLong(tokens.next());
      float value = LangUtils.parseFloat(tokens.next());
      result.add(new GenericRecommendedItem(itemID, value));
    }
  } finally {
    reader.close();
  }
  return result;
}
 

@Test
public void testSet() throws Exception {
  ClientRecommender client = getClient();

  client.setPreference(0L, 1L);
  List<RecommendedItem> recs = client.recommend(0L, 1);
  assertEquals(50L, recs.get(0).getItemID());

  client.setPreference(0L, 2L, 3.0f);
  recs = client.recommend(0L, 1);
  assertEquals(117L, recs.get(0).getItemID());

  client.setPreference(0L, 2L, -3.0f);
  recs = client.recommend(0L, 1);
  assertEquals(117L, recs.get(0).getItemID());

  client.setPreference(0L, 1L, -1.0f);
  // Don't really know/care what will be recommend at this point; the feature vec is nearly 0
  assertEquals(1, client.recommend(0L, 1).size());
}
 

@Test
public void testRecommendToAnonymous() throws Exception {

  ClientRecommender client = getClient();
  // Adding non-existent item to make sure it is ignored
  List<RecommendedItem> recs = client.recommendToAnonymous(new long[] {1L, 3L, Integer.MAX_VALUE}, 3);

  assertNotNull(recs);
  assertEquals(3, recs.size());

  log.info("{}", recs);

  assertEquals(151L, recs.get(0).getItemID());
  assertEquals(50L, recs.get(1).getItemID());
  assertEquals(181L, recs.get(2).getItemID());
}
 

@Test
public void testTag() throws Exception {
  ClientRecommender client = getClient();
  
  client.setUserTag(5, "bar", -10.0f);
  List<RecommendedItem> recs = client.recommend(5, 1);
  log.info("{}", recs);
  assertEquals(2, recs.get(0).getItemID());
  assertEquals(0.5184667f, recs.get(0).getValue());
  
  client.setItemTag("bing", 4);
  recs = client.recommend(5, 1);
  log.info("{}", recs);
  assertEquals(2, recs.get(0).getItemID());
  assertEquals(0.5184667f, recs.get(0).getValue());
}
 

@Test
public void testRecommendVersusToMany2() throws Exception {
  ClientRecommender client = getClient();
  List<RecommendedItem> recs =
      client.recommendToMany(new long[] {4L, 2L}, 3, true, (String[]) null);
  List<RecommendedItem> recs2 =
      client.recommendToMany(new long[] {2L, 4L}, 3, true, (String[]) null);
  assertEquals(recs, recs2);
}
 

public static void main(String[] args) throws TasteException, IOException {
	//MF recommender model
   	DataModel model = new FileDataModel(new File("data/recodataset.csv"));   
   	//ALSWRFactorizer factorizer = new ALSWRFactorizer(model, 50, 0.065, 15);
   	ParallelSGDFactorizer factorizer = new ParallelSGDFactorizer(model,10,0.1,1);
   	SVDRecommender recommender = new SVDRecommender(model, factorizer);    	
   	
   	List<RecommendedItem> recommendations = recommender.recommend(2, 3);
   	for (RecommendedItem recommendation : recommendations) {
   	  System.out.println(recommendation);
   	}

}
 

public static void main(String[] args) throws TasteException, IOException {
	DataModel model = new FileDataModel(new File("data/dataset.csv"));
   	ItemSimilarity similarity = new LogLikelihoodSimilarity(model);
   	//UserNeighborhood neighborhood = new ThresholdUserNeighborhood(0.1, similarity, model);
   	GenericItemBasedRecommender recommender = new GenericItemBasedRecommender(model, similarity);
   	List<RecommendedItem> recommendations = recommender.mostSimilarItems(18, 3);
   	for (RecommendedItem recommendation : recommendations) {
   	  System.out.println(recommendation);
   	}

}
 

public static ItemBasedRecommender itemBased() throws Exception {

		// Load the data
		StringItemIdFileDataModel dataModel = loadFromFile("data/BX-Book-Ratings.csv", ";");
		// Collection<GenericItemSimilarity.ItemItemSimilarity> correlations =
		// null;
		// ItemItemSimilarity iis = new ItemItemSimilarity(0, 0, 0);
		// ItemSimilarity itemSimilarity = new
		// GenericItemSimilarity(correlations);
		ItemSimilarity itemSimilarity = new PearsonCorrelationSimilarity(dataModel);

		ItemBasedRecommender recommender = new GenericItemBasedRecommender(
				dataModel, itemSimilarity);

		IDRescorer rescorer = new MyRescorer();

		// List recommendations = recommender.recommend(2, 3, rescorer);
		String itemISBN = "042513976X";
		long itemID = dataModel.readItemIDFromString(itemISBN);
		int noItems = 10;

		System.out.println("Recommendations for item: " + books.get(itemISBN));

		System.out.println("\nMost similar items:");
		List<RecommendedItem> recommendations = recommender.mostSimilarItems(
				itemID, noItems);
		for (RecommendedItem item : recommendations) {
			itemISBN = dataModel.getItemIDAsString(item.getItemID());
			System.out.println("Item: " + books.get(itemISBN) + " | Item id: "
					+ itemISBN + " | Value: " + item.getValue());
		}
		
		return recommender;
	}
 

public void reduce(VarLongWritable key, Iterable<VectorWritable> values,Context context) throws IOException, InterruptedException{  
  
    int userID=(int)key.get();  
    Vector rev=null;  
    for(VectorWritable vec:values){  
        rev=rev==null? vec.get():rev.plus(vec.get());  
    }  
    Queue<RecommendedItem>topItems=new PriorityQueue<RecommendedItem>( recommendationsPerUser+1,  Collections.reverseOrder(ByValueRecommendedItemComparator.getInstance())   );  
    Iterator<Vector.Element>recommendationVectorIterator=  rev.nonZeroes().iterator();  
    while(recommendationVectorIterator.hasNext()){  
        Vector.Element e=recommendationVectorIterator.next();  
        int index=e.index();  
        System.out.println("Vecotr.element.indxe:"+index);  //  test here  find the index is item id or not  ** test result : index is item  
        if(!hasItem(userID,String.valueOf(index))){  
            float value=(float) e.get();  
            if(topItems.size()<recommendationsPerUser){  
                //  here only set index  
                topItems.add(new GenericRecommendedItem(index,value));  
            }else if(value>topItems.peek().getValue()){  
                topItems.add(new GenericRecommendedItem(index,value));  
                topItems.poll();  
            }  
        }  
    }  
    List<RecommendedItem>recom=new ArrayList<RecommendedItem>(topItems.size());  
    recom.addAll(topItems);  
    Collections.sort(recom,ByValueRecommendedItemComparator.getInstance());  
    context.write(key, new RecommendedItemsWritable(recom));          
}
 

@Override
public List<RecommendedItem> recommendToAnonymous(long[] itemIDs,
                                                  float[] values,
                                                  int howMany,
                                                  IDRescorer rescorer)
    throws NotReadyException, NoSuchItemException {

  Preconditions.checkArgument(howMany > 0, "howMany must be positive");

  float[] anonymousUserFeatures = buildAnonymousUserFeatures(itemIDs, values);

  FastIDSet userKnownItemIDs = new FastIDSet(itemIDs.length);
  for (long itemID : itemIDs) {
    userKnownItemIDs.add(itemID);
  }

  float[][] anonymousFeaturesAsArray = { anonymousUserFeatures };

  Generation generation = getCurrentGeneration();    
  Lock yLock = generation.getYLock().readLock();    
  yLock.lock();
  try {
    return multithreadedTopN(anonymousFeaturesAsArray,
                             userKnownItemIDs,
                             generation.getUserTagIDs(),
                             rescorer,
                             howMany,
                             generation.getCandidateFilter());
  } finally {
    yLock.unlock();
  }
}
 

/**
 * One-argument version of {@link #mostSimilarItems(long[], int, Rescorer)}.
 */
@Override
public List<RecommendedItem> mostSimilarItems(long itemID, int howMany, Rescorer<LongPair> rescorer)
    throws NoSuchItemException, NotReadyException {

  Preconditions.checkArgument(howMany > 0, "howMany must be positive");

  Generation generation = getCurrentGeneration();
  FastByIDMap<float[]> Y = generation.getY();

  Lock yLock = generation.getYLock().readLock();
  yLock.lock();
  try {

    float[] itemFeatures = Y.get(itemID);
    if (itemFeatures == null) {
      throw new NoSuchItemException(itemID);
    }

    return TopN.selectTopN(new MostSimilarItemIterator(Y.entrySet().iterator(),
                                                       generation.getUserTagIDs(),
                                                       new long[] { itemID },
                                                       new float[][] { itemFeatures },
                                                       rescorer),
                           howMany);
  } finally {
    yLock.unlock();
  }

}
 

@Test
public void testTopPlusOne() {
  List<RecommendedItem> candidates = makeNCandidates(4);
  List<RecommendedItem> top3 = TopN.selectTopN(candidates.iterator(), 3);
  assertNotNull(top3);
  assertEquals(3, top3.size());
  assertEquals(4L, top3.get(0).getItemID());
  assertEquals(4.0f, top3.get(0).getValue());
  assertEquals(2L, top3.get(2).getItemID());
  assertEquals(2.0f, top3.get(2).getValue());
}
 

/**
 * Computes items most similar to an item or items. The returned items have the highest average similarity
 * to the given items.
 *
 * @param itemIDs items for which most similar items are required
 * @param howMany maximum number of similar items to return; fewer may be returned
 * @param rescorer rescoring function used to modify item-item similarities before ranking results
 * @return {@link RecommendedItem}s representing the top recommendations for the user, ordered by quality,
 *  descending. The score associated to it is an opaque value. Larger means more similar, but no further
 *  interpretation may necessarily be applied.
 * @throws NoSuchItemException if any of the items is not known in the model
 * @throws NotReadyException if the recommender has no model available yet
 */
@Override
public List<RecommendedItem> mostSimilarItems(long[] itemIDs, int howMany, Rescorer<LongPair> rescorer)
    throws NoSuchItemException, NotReadyException {

  Preconditions.checkArgument(howMany > 0, "howMany must be positive");

  Generation generation = getCurrentGeneration();
  FastByIDMap<float[]> Y = generation.getY();

  Lock yLock = generation.getYLock().readLock();
  yLock.lock();
  try {

    List<float[]> itemFeatures = Lists.newArrayListWithCapacity(itemIDs.length);
    for (long itemID : itemIDs) {
      float[] features = Y.get(itemID);
      if (features != null) {
        itemFeatures.add(features);
      }
    }
    if (itemFeatures.isEmpty()) {
      throw new NoSuchItemException(Arrays.toString(itemIDs));
    }
    float[][] itemFeaturesArray = itemFeatures.toArray(new float[itemFeatures.size()][]);

    return TopN.selectTopN(new MostSimilarItemIterator(Y.entrySet().iterator(), 
                                                       generation.getUserTagIDs(),
                                                       itemIDs, 
                                                       itemFeaturesArray, 
                                                       rescorer),
                           howMany);
  } finally {
    yLock.unlock();
  }
}
 

/**
 * {@code excludeItemIfNotSimilarToAll} is not applicable in this implementation.
 *
 * @return {@link #mostSimilarItems(long[], int)} if excludeItemIfNotSimilarToAll is false
 * @throws UnsupportedOperationException otherwise
 * @deprecated use {@link #mostSimilarItems(long[], int)} instead
 */
@Deprecated
@Override
public List<RecommendedItem> mostSimilarItems(long[] itemIDs,
                                              int howMany,
                                              boolean excludeItemIfNotSimilarToAll)
    throws NoSuchItemException, NotReadyException {
  if (excludeItemIfNotSimilarToAll) {
    throw new UnsupportedOperationException();
  }
  return mostSimilarItems(itemIDs, howMany);
}
 

/**
 * {@code excludeItemIfNotSimilarToAll} is not applicable in this implementation.
 *
 * @return {@link #mostSimilarItems(long[], int, Rescorer)} if excludeItemIfNotSimilarToAll is false
 * @throws UnsupportedOperationException otherwise
 * @deprecated use {@link #mostSimilarItems(long[], int, Rescorer)} instead
 */
@Deprecated
@Override
public List<RecommendedItem> mostSimilarItems(long[] itemIDs,
                                              int howMany,
                                              Rescorer<LongPair> rescorer,
                                              boolean excludeItemIfNotSimilarToAll)
    throws NoSuchItemException, NotReadyException {
  if (excludeItemIfNotSimilarToAll) {
    throw new UnsupportedOperationException();
  }
  return mostSimilarItems(itemIDs, howMany);
}
 

@Override
public EvaluationResult evaluate(MyrrixRecommender recommender,
                                 RescorerProvider provider, // ignored
                                 Multimap<Long,RecommendedItem> testData) throws TasteException {
  FastByIDMap<FastIDSet> converted = new FastByIDMap<FastIDSet>(testData.size());
  for (long userID : testData.keySet()) {
    Collection<RecommendedItem> userTestData = testData.get(userID);
    FastIDSet itemIDs = new FastIDSet(userTestData.size());
    converted.put(userID, itemIDs);
    for (RecommendedItem datum : userTestData) {
      itemIDs.add(datum.getItemID());
    }
  }
  return evaluate(recommender, converted);
}
 

@Test
public void testTopExactly() {
  List<RecommendedItem> candidates = makeNCandidates(3);
  List<RecommendedItem> top3 = TopN.selectTopN(candidates.iterator(), 3);
  assertNotNull(top3);
  assertEquals(3, top3.size());
  assertEquals(3L, top3.get(0).getItemID());
  assertEquals(3.0f, top3.get(0).getValue());
  assertEquals(1L, top3.get(2).getItemID());
  assertEquals(1.0f, top3.get(2).getValue());
}
 

public EvaluationResult evaluate(File originalDataDir) throws TasteException, IOException, InterruptedException {

    Preconditions.checkArgument(originalDataDir.exists() && originalDataDir.isDirectory(),
                                "%s is not a directory", originalDataDir);
    File tempDir = Files.createTempDir();

    ServerRecommender recommender = null;
    try {

      Multimap<Long,RecommendedItem> data;
      try {
        data = readAndCopyDataFiles(originalDataDir, tempDir);
      } catch (IOException ioe) {
        throw new TasteException(ioe);
      }

      recommender = new ServerRecommender(tempDir);
      recommender.await();

      Generation generation = recommender.getGenerationManager().getCurrentGeneration();
      FastByIDMap<float[]> X = generation.getX();
      FastByIDMap<float[]> Y = generation.getY();

      Mean averageError = new Mean();
      // Only compute average over existing entries...
      for (Map.Entry<Long,RecommendedItem> entry : data.entries()) {
        long userID = entry.getKey();
        long itemID = entry.getValue().getItemID();
        // Each of which was a "1" in the factor P matrix
        double value = SimpleVectorMath.dot(X.get(userID), Y.get(itemID));
        // So store abs(1-value), except, don't penalize for reconstructing > 1. Error is 0 in this case.
        averageError.increment(FastMath.max(0.0, 1.0 - value));
      }

      return new EvaluationResultImpl(averageError.getResult());
    } finally {
      recommender.close();
      IOUtils.deleteRecursively(tempDir);
    }
  }
 

private static Multimap<Long,RecommendedItem> readAndCopyDataFiles(File dataDir, File tempDir) throws IOException {
  Multimap<Long,RecommendedItem> data = ArrayListMultimap.create();
  for (File dataFile : dataDir.listFiles(new PatternFilenameFilter(".+\\.csv(\\.(zip|gz))?"))) {
    log.info("Reading {}", dataFile);
    int count = 0;
    for (CharSequence line : new FileLineIterable(dataFile)) {
      Iterator<String> parts = COMMA_TAB_SPLIT.split(line).iterator();
      long userID = Long.parseLong(parts.next());
      long itemID = Long.parseLong(parts.next());
      if (parts.hasNext()) {
        String token = parts.next().trim();
        if (!token.isEmpty()) {
          data.put(userID, new GenericRecommendedItem(itemID, LangUtils.parseFloat(token)));
        }
        // Ignore remove lines
      } else {
        data.put(userID, new GenericRecommendedItem(itemID, 1.0f));
      }
      if (++count % 1000000 == 0) {
        log.info("Finished {} lines", count);
      }
    }

    Files.copy(dataFile, new File(tempDir, dataFile.getName()));
  }
  return data;
}
 

DataFileContents(Multimap<Long,RecommendedItem> data, 
                 Multimap<String,RecommendedItem> itemTags, 
                 Multimap<String,RecommendedItem> userTags) {
  Preconditions.checkNotNull(data);
  Preconditions.checkNotNull(itemTags);
  Preconditions.checkNotNull(userTags);
  this.data = data;
  this.itemTags = itemTags;
  this.userTags = userTags;
}