public static void main(String[] args) throws Exception {
/*DataModel model = new FileDataModel(new File("data.csv"));
UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
UserNeighborhood neighborhood = new NearestNUserNeighborhood(2, similarity, model);
Recommender recommender = new GenericUserBasedRecommender(model, neighborhood, similarity);
List<RecommendedItem> recommendations = recommender.recommend(1, 1);
for(RecommendedItem recommendation : recommendations){
System.out.println(recommendation);
}*/
MysqlDataSource dataSource = new MysqlDataSource();
dataSource.setServerName("localhost");
dataSource.setPort(3306);
dataSource.setDatabaseName("YueYun");
dataSource.setUser("root");
dataSource.setPassword("root");
JDBCDataModel dataModel =
new MySQLJDBCDataModel(
dataSource, "tb_track_nopreference", "userId", "trackId", "nopreference", "");
/*UserSimilarity similarity = new PearsonCorrelationSimilarity(dataModel);
UserNeighborhood neighborhood = new NearestNUserNeighborhood(2, similarity, dataModel);
Recommender recommender = new GenericUserBasedRecommender(dataModel, neighborhood, similarity);
List<RecommendedItem> recommendations = recommender.recommend(1, 1);
for(RecommendedItem recommendation : recommendations){
System.out.println(recommendation);
}*/
DataModel model =
new GenericBooleanPrefDataModel(GenericBooleanPrefDataModel.toDataMap(dataModel));
UserSimilarity similarity = new LogLikelihoodSimilarity(model);
UserNeighborhood neighborhood = new NearestNUserNeighborhood(4, similarity, model);
Recommender recommender = new GenericUserBasedRecommender(model, neighborhood, similarity);
List<RecommendedItem> recommendations = recommender.recommend(1, 3);
for (RecommendedItem recommendation : recommendations) {
System.out.println(recommendation);
}
}
public static void main(String[] args)
throws TasteException, UnknownHostException, MongoException {
model =
new MongoDBDataModel(
"127.0.0.1",
27017,
"right-channel",
"ratings",
false,
false,
null,
"user_id",
"movie_id",
"rating",
MongoDBDataModel.DEFAULT_MONGO_MAP_COLLECTION);
ItemSimilarity similarity = new PearsonCorrelationSimilarity(model);
Recommender recommender = new BiasedItemBasedRecommender(model, similarity);
IDRescorer rescorer = new OverallRescorer();
List<RecommendedItem> recommendations =
recommender.recommend(
Long.parseLong(
model.fromIdToLong(
new ObjectId("518ce9df4597b5adead4b61d").toStringMongod(), false)),
1000,
rescorer);
Mongo mongoDB = new Mongo("127.0.0.1", 27017);
DB db = mongoDB.getDB("right-channel");
DBCollection recommendationCollection = db.getCollection("recommendations");
BasicDBObject document = new BasicDBObject();
document.put("user_id", new ObjectId("518ce9df4597b5adead4b61d"));
recommendationCollection.remove(document);
for (RecommendedItem recommendation : recommendations) {
long movieIdLong = recommendation.getItemID();
String movieIdString = model.fromLongToId(movieIdLong);
ObjectId movieIdObject = new ObjectId(movieIdString);
double rating = recommendation.getValue();
BasicDBObject prediction = new BasicDBObject();
Object userIdObject = new ObjectId("518ce9df4597b5adead4b61d");
prediction.put("user_id", userIdObject);
prediction.put("movie_id", movieIdObject);
prediction.put("rating", rating);
recommendationCollection.insert(prediction);
System.out.println(rating);
}
}
public static void main(String[] args) throws IOException, Exception {
DataModel dataModel =
new FileDataModel(
new File(UserBaseCF.class.getClassLoader().getResource("mydata.txt").getFile()));
UserSimilarity userSimilarity = new PearsonCorrelationSimilarity(dataModel);
userSimilarity.setPreferenceInferrer(new AveragingPreferenceInferrer(dataModel));
UserNeighborhood neighborhood = new NearestNUserNeighborhood(3, userSimilarity, dataModel);
Recommender recommender =
new GenericUserBasedRecommender(dataModel, neighborhood, userSimilarity);
Recommender cachingRecommender = new CachingRecommender(recommender);
List<RecommendedItem> recommendations = cachingRecommender.recommend(5, 5);
for (RecommendedItem recommendedItem : recommendations) {
System.out.println(recommendedItem);
}
}
public static void main(String[] args) throws IOException, TasteException {
String file = "datafile/item.csv";
DataModel model = new FileDataModel(new File(file));
UserSimilarity user = new EuclideanDistanceSimilarity(model);
NearestNUserNeighborhood neighbor = new NearestNUserNeighborhood(NEIGHBORHOOD_NUM, user, model);
Recommender r = new GenericUserBasedRecommender(model, neighbor, user);
LongPrimitiveIterator iter = model.getUserIDs();
while (iter.hasNext()) {
long uid = iter.nextLong();
List<RecommendedItem> list = r.recommend(uid, RECOMMENDER_NUM);
System.out.printf("uid:%s", uid);
for (RecommendedItem ritem : list) {
System.out.printf("(%s,%f)", ritem.getItemID(), ritem.getValue());
}
System.out.println();
}
}
public static String userbasecrec(String files)
throws FileNotFoundException, TasteException, IOException, OptionException {
// DataModel model = new FileDataModel(new File("datasets/movieRatings.dat"));
File ratingsFile = new File(files);
DataModel model = new FileDataModel(ratingsFile);
UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
UserNeighborhood neighborhood = new NearestNUserNeighborhood(3, similarity, model);
Recommender recommender = new GenericUserBasedRecommender(model, neighborhood, similarity);
List<RecommendedItem> recommendations = recommender.recommend(1, 1);
String ls = "";
for (RecommendedItem recommendation : recommendations) {
System.out.println(recommendation);
ls = recommendation + "";
}
return ls;
}
public static void main(String[] args) throws TasteException, MongoException, IOException {
String ml10mFolder = "/home/yapianyu/Desktop/movielens/ml-10M100K/refinement/";
String ratingFilePath = ml10mFolder + "ratings.dat";
String movieFilePath = ml10mFolder + "movies.dat";
for (String line : new FileLineIterable(new File(movieFilePath), false)) {
String[] fields = line.split("::");
long id = Long.parseLong(fields[0]);
long year =
Long.parseLong(fields[1].substring(fields[1].length() - 5, fields[1].length() - 1));
String title = fields[3];
try {
double rating = Double.parseDouble(fields[4]);
mid2rating.put(id, rating);
} catch (Exception e) {
mid2rating.put(id, Double.NaN);
}
mid2year.put(id, year);
mid2title.put(id, title);
}
DataModel model = new FileDataModel(new File(ratingFilePath));
ItemSimilarity similarity = new PearsonCorrelationSimilarity(model);
Recommender recommender = new BiasedItemBasedRecommender(model, similarity);
IDRescorer rescorer = new OverallRescorer();
List<RecommendedItem> recommendations = recommender.recommend(72000, 1000, rescorer);
for (RecommendedItem recommendation : recommendations) {
long mid = recommendation.getItemID();
System.out.println(
String.format(
"%.3f\t%d\t%.1f\t%s(%d)",
recommendation.getValue(),
mid2year.get(mid),
mid2rating.get(mid),
mid2title.get(mid),
mid));
}
}
public static void main(String[] args)
throws FileNotFoundException, TasteException, IOException, OptionException {
DataModel model;
model = new FileDataModel(new File("datasets/ratingsForMahout.dat"));
File movieMapFile = new File("datasets/moviesForMahout.dat");
HashMap<Long, String> movieMap = new HashMap<Long, String>();
Scanner scan = new Scanner(movieMapFile);
while (scan.hasNextLine()) {
String[] line = scan.nextLine().split("\\|");
movieMap.put(Long.parseLong(line[0]), line[1]);
}
scan.close();
UserSimilarity userSimilarity = new PearsonCorrelationSimilarity(model);
UserNeighborhood neighborhood = new NearestNUserNeighborhood(3, userSimilarity, model);
Recommender recommender = new GenericUserBasedRecommender(model, neighborhood, userSimilarity);
Recommender cachingRecommender = new CachingRecommender(recommender);
for (LongPrimitiveIterator it = model.getUserIDs(); it.hasNext(); ) {
long userId = it.nextLong();
List<RecommendedItem> recommendations = cachingRecommender.recommend(userId, 10);
if (recommendations.size() == 0) {
System.out.println("User " + userId + ": no recommendations");
}
for (RecommendedItem recommendedItem : recommendations) {
System.out.println(
"User "
+ userId
+ ": "
+ movieMap.get(recommendedItem.getItemID())
+ "; value="
+ recommendedItem.getValue());
}
}
}
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<>(recommendationsRetriever, numUsers);
estimatedPrefCache = new Cache<>(new EstimatedPrefRetriever(), numUsers);
refreshHelper =
new RefreshHelper(
new Callable<Object>() {
@Override
public Object call() {
clear();
return null;
}
});
refreshHelper.addDependency(recommender);
}
@Override
public Void call() throws TasteException {
for (Preference realPref : prefs) {
float estimatedPreference = Float.NaN;
try {
estimatedPreference = recommender.estimatePreference(testUserID, realPref.getItemID());
} catch (NoSuchUserException nsue) {
// It's possible that an item exists in the test data but
// not training data in which case
// NSEE will be thrown. Just ignore it and move on.
log.info("User exists in test data but not training data: {}", testUserID);
} catch (NoSuchItemException nsie) {
log.info("Item exists in test data but not training data: {}", realPref.getItemID());
}
if (Float.isNaN(estimatedPreference)) {
noEstimateCounter.incrementAndGet();
} else {
estimatedPreference = capEstimatedPreference(estimatedPreference);
processOneEstimate(estimatedPreference, realPref);
}
}
return null;
}
@Test
public void testRecommender() throws Exception {
MutableInt recommendCount = new MutableInt();
Recommender mockRecommender = new MockRecommender(recommendCount);
Recommender cachingRecommender = new CachingRecommender(mockRecommender);
cachingRecommender.recommend(1, 1);
assertEquals(1, recommendCount.intValue());
cachingRecommender.recommend(2, 1);
assertEquals(2, recommendCount.intValue());
cachingRecommender.recommend(1, 1);
assertEquals(2, recommendCount.intValue());
cachingRecommender.recommend(2, 1);
assertEquals(2, recommendCount.intValue());
cachingRecommender.refresh(null);
cachingRecommender.recommend(1, 1);
assertEquals(3, recommendCount.intValue());
cachingRecommender.recommend(2, 1);
assertEquals(4, recommendCount.intValue());
cachingRecommender.recommend(3, 1);
assertEquals(5, recommendCount.intValue());
// Results from this recommend() method can be cached...
IDRescorer rescorer = NullRescorer.getItemInstance();
cachingRecommender.refresh(null);
cachingRecommender.recommend(1, 1, rescorer);
assertEquals(6, recommendCount.intValue());
cachingRecommender.recommend(2, 1, rescorer);
assertEquals(7, recommendCount.intValue());
cachingRecommender.recommend(1, 1, rescorer);
assertEquals(7, recommendCount.intValue());
cachingRecommender.recommend(2, 1, rescorer);
assertEquals(7, recommendCount.intValue());
// until you switch Rescorers
cachingRecommender.recommend(1, 1, null);
assertEquals(8, recommendCount.intValue());
cachingRecommender.recommend(2, 1, null);
assertEquals(9, recommendCount.intValue());
cachingRecommender.refresh(null);
cachingRecommender.estimatePreference(1, 1);
assertEquals(10, recommendCount.intValue());
cachingRecommender.estimatePreference(1, 2);
assertEquals(11, recommendCount.intValue());
cachingRecommender.estimatePreference(1, 2);
assertEquals(11, recommendCount.intValue());
}
@Override
public DataModel getDataModel() {
return recommender.getDataModel();
}
@Override
public void removePreference(long userID, long itemID) throws TasteException {
recommender.removePreference(userID, itemID);
clear(userID);
}
@Override
public void setPreference(long userID, long itemID, float value) throws TasteException {
recommender.setPreference(userID, itemID, value);
clear(userID);
}
@Override
public List<RecommendedItem> recommend(
long userID, int howMany, IDRescorer rescorer, boolean includeKnownItems)
throws TasteException {
Map<Long, Pair<Long, Float>> recommendedItemOccurrence = new HashMap<Long, Pair<Long, Float>>();
if (criteriaList != null && recommenderMap != null) {
for (RecommenderCriteriumEntity criterium : criteriaList) {
Recommender recommender = recommenderMap.get(criterium);
if (recommender != null) {
List<RecommendedItem> recommendedItems =
recommender.recommend(userID, howMany, rescorer, includeKnownItems);
if (recommendedItems != null) {
for (RecommendedItem recommendedItem : recommendedItems) {
Pair<Long, Float> pair = recommendedItemOccurrence.get(recommendedItem.getItemID());
if (pair == null) {
pair = new ImmutablePair<Long, Float>(1L, recommendedItem.getValue());
} else {
pair =
new ImmutablePair<Long, Float>(
pair.getLeft() + 1, (pair.getRight() + recommendedItem.getValue()) / 2);
}
recommendedItemOccurrence.put(recommendedItem.getItemID(), pair);
}
}
}
}
}
PriorityQueue<ImmutablePair<RecommendedItem, Long>> queue =
new PriorityQueue<ImmutablePair<RecommendedItem, Long>>(
10,
new Comparator<ImmutablePair<RecommendedItem, Long>>() {
@Override
public int compare(
ImmutablePair<RecommendedItem, Long> o1,
ImmutablePair<RecommendedItem, Long> o2) {
int result = -o1.getRight().compareTo(o2.getRight());
if (result == 0) {
Float v1 = o1.getLeft().getValue();
Float v2 = o2.getLeft().getValue();
result = v1.compareTo(v2);
}
return result;
}
});
for (Map.Entry<Long, Pair<Long, Float>> entry : recommendedItemOccurrence.entrySet()) {
RecommendedItem recommendedItem =
new GenericRecommendedItem(entry.getKey(), entry.getValue().getRight());
ImmutablePair<RecommendedItem, Long> pair =
new ImmutablePair<RecommendedItem, Long>(recommendedItem, entry.getValue().getLeft());
queue.add(pair);
}
List<RecommendedItem> recommendedItems = new ArrayList<RecommendedItem>();
do {
if (queue.peek() != null && queue.peek().getLeft() != null) {
recommendedItems.add(queue.poll().getLeft());
}
} while (recommendedItems.size() < howMany && !queue.isEmpty());
return recommendedItems;
}