Hi,
I have been trying to configure Mahout for using hibernate. I haven't
been able to find any examples of such a configuration. Its probably
the wrong way to do it but I cant even get this simple model to work.
It would be great if you could tell me what I'm doing wrong here, and
maybe some pointers on how it should be done.
Items are Arrangements, Users are Accounts and Preferences are Reviews
So I have made this DataModel. Recommendations should only be made
from the arrangements that I supply to the datamodel in the
constructor
-------------------
public class WorkDataModel implements DataModel {
DataModel delegate;
public WorkDataModel(AccountDAO accountDAO, ArrangementDAO
arrangementDAO, ReviewDAO reviewDAO, List<Arrangement> arrangements) {
super();
this.accountDAO = accountDAO;
this.arrangementDAO = arrangementDAO;
this.reviewDAO = reviewDAO;
this.arrangements = arrangements;
refresh();
FastByIDMap<PreferenceArray> users = readUsers();
delegate = new GenericDataModel(users);
}
private FastByIDMap<PreferenceArray> readUsers() {
FastByIDMap<Collection<Preference>> userIDPrefMap = new
FastByIDMap<Collection<Preference>>();
for (Review r : reviews) {
Collection<Preference> userPrefs =
userIDPrefMap.get(r.getReviewer().getId());
if (userPrefs == null) {
userPrefs = new ArrayList<Preference>(2);
userIDPrefMap.put(r.getReviewer().getId(), userPrefs);
}
userPrefs.add(new GenericPreference(
r.getReviewer().getId(),
r.getArrangement().getId(),
r.getValue()));
}
return GenericDataModel.toDataMap(userIDPrefMap, true);
}
@Override
public LongPrimitiveIterator getUserIDs() throws TasteException {
LongPrimitiveIterator userIDs = delegate.getUserIDs();
return userIDs;
}
@Override
public PreferenceArray getPreferencesFromUser(long id)
throws TasteException {
PreferenceArray preferencesFromUser =
delegate.getPreferencesFromUser(id);
return preferencesFromUser;
}
@Override
public FastIDSet getItemIDsFromUser(long userID) throws TasteException {
FastIDSet itemIDsFromUser = delegate.getItemIDsFromUser(userID);
return itemIDsFromUser;
}
@Override
public LongPrimitiveIterator getItemIDs() throws TasteException {
LongPrimitiveIterator itemIDs = delegate.getItemIDs();
return itemIDs;
}
@Override
public PreferenceArray getPreferencesForItem(long itemID)
throws TasteException {
PreferenceArray preferencesForItem =
delegate.getPreferencesForItem(itemID);
return preferencesForItem;
}
@Override
public Float getPreferenceValue(long userID, long itemID)
throws TasteException {
Float preferenceValue = delegate.getPreferenceValue(userID, itemID);
return preferenceValue;
}
@Override
public int getNumItems() throws TasteException {
int numItems = delegate.getNumItems();
return numItems;
}
@Override
public int getNumUsers() throws TasteException {
int numUsers = delegate.getNumUsers();
return numUsers;
}
@Override
public int getNumUsersWithPreferenceFor(long... itemIDs)
throws TasteException {
int numUsersWithPreferenceFor =
delegate.getNumUsersWithPreferenceFor(itemIDs);
return numUsersWithPreferenceFor;
}
@Override
public void setPreference(long userID, long itemID, float value) {
throw new UnsupportedOperationException();
}
@Override
public void removePreference(long userID, long itemID) {
throw new UnsupportedOperationException();
}
@Override
public void refresh(Collection<Refreshable> alreadyRefreshed) {
// do nothing
}
private AccountDAO accountDAO;
private ReviewDAO reviewDAO;
private ArrangementDAO arrangementDAO;
private List<Arrangement> arrangements;
private List<Account> accounts;
private List<Review> reviews;
public void refresh() {
if (arrangements == null) {
arrangements = arrangementDAO.getAll();
}
accounts = accountDAO.getAll();
reviews = reviewDAO.getAll();
}
}
-------------------
and I use this to get recommendations from user:
-------------------
List<Arrangement> arrangements = arrangementDAO.getArrangements();
DataModel model = new WorkDataModel(accountDAO, arrangementDAO,
reviewDAO, arrangements);
UserSimilarity userSimilarity = new PearsonCorrelationSimilarity(model);
UserNeighborhood neighborhood = new NearestNUserNeighborhood(3,
userSimilarity, model);
Recommender recommender = new GenericUserBasedRecommender(model,
neighborhood, userSimilarity);
Recommender cachingRecommender = new CachingRecommender(recommender);
List<RecommendedItem> recommendations =
cachingRecommender.recommend(account.getId(), amount);
-------------------
and this to get recommendations from arrangements:
-------------------
DataModel model = new WorkDataModel(accountDAO, arrangementDAO,
reviewDAO, arrangements);
ItemSimilarity correlations = new PearsonCorrelationSimilarity(model);
Recommender cachingRecommender = new CachingRecommender(new
GenericItemBasedRecommender(model, correlations));
List<RecommendedItem> recommendations =
cachingRecommender.recommend(arrangement.getId(), 10);
-------------------
When running recommendations from arrangement I get a
"org.apache.mahout.cf.taste.common.NoSuchUserException" in
GenericDataModel.getPreferencesFromUser. It seems that it gets a Item
ID instead of a User ID, so probably a stupid mistake, but I cant find
out what.
Running recommendations from Account (User) doesnt return any
recommendations at all.
I think my testdate should be ok, probably something is fishy in my
DataModel implementation.
If you could also give me some pointers on how I could do this faster
I would be thankfull..
Thanks!
Johan
