public GenericDataModel GetUserBasedDataModel()
{
FastByIDMap <IPreferenceArray> data = new FastByIDMap <IPreferenceArray>();
IEnumerable <UserBookReview> allBookReviews = _userBookReviewRepository.GetListOf();
var everyReviewsUserId = allBookReviews.GroupBy(b => b.UserId).Select(x => x.Key).ToList();
foreach (int userId in everyReviewsUserId)
{
List <UserBookReview> bookReviewsForABook = (from userReviews in allBookReviews
where userReviews.UserId == userId
select userReviews).ToList();
List <IPreference> listOfPreferences = new List <IPreference>();
foreach (UserBookReview review in bookReviewsForABook)
{
int rating = review.Rating;
int bookId = review.BookId;
GenericPreference pref = new GenericPreference(userId, bookId, rating); /// userId, itemid, valueId
listOfPreferences.Add(pref);
}
GenericUserPreferenceArray dataArray = new GenericUserPreferenceArray(listOfPreferences);
data.Put(userId, dataArray);
}
return(new GenericDataModel(data));
}
public Preference[] GetPreferencesAsArray()
{
Preference[] sortedPrefs = delegateUser.GetPreferencesAsArray();
Array.Sort(sortedPrefs, ByValuePreferenceComparer.Instance);
for (int i = 0; i < sortedPrefs.Length; i++)
{
sortedPrefs[i] = new GenericPreference(this, sortedPrefs[i].Item, (double)(i + 1));
}
Array.Sort(sortedPrefs, ByItemPreferenceComparer.Instance);
return(sortedPrefs);
}
public void testNoCorrelation2()
{
Preference pref1 = new GenericPreference(null, new GenericItem <String>("1"), 1.0);
GenericUser <String> user1 = new GenericUser <String>("test1", ScalarToList <Preference>(pref1));
Preference pref2 = new GenericPreference(null, new GenericItem <String>("2"), 1.0);
GenericUser <String> user2 = new GenericUser <String>("test2", ScalarToList <Preference>(pref2));
DataModel dataModel = GetDataModel(user1, user2);
double correlation = new PearsonCorrelation(dataModel).GetUserCorrelation(user1, user2);
Assert.IsTrue(Double.IsNaN(correlation));
}
public IEnumerable <Preference> GetPreferences()
{
// todo: cache this
Preference[] source = delegateUser.GetPreferencesAsArray();
int length = source.Length;
Preference[] sortedPrefs = new Preference[length];
Array.Copy(source, sortedPrefs, length);
for (int i = 0; i < length; i++)
{
Item item = sortedPrefs[i].Item;
sortedPrefs[i] = new GenericPreference(this, item, (double)(i + 1));
}
Array.Sort <Preference>(sortedPrefs, ByValuePreferenceComparer.Instance);
return(sortedPrefs);
}
private void splitOneUsersPrefs(double trainingPercentage,
FastByIDMap <IPreferenceArray> trainingPrefs,
FastByIDMap <IPreferenceArray> testPrefs,
long userID,
IDataModel dataModel)
{
List <IPreference> oneUserTrainingPrefs = null;
List <IPreference> oneUserTestPrefs = null;
IPreferenceArray prefs = dataModel.GetPreferencesFromUser(userID);
int size = prefs.Length();
for (int i = 0; i < size; i++)
{
IPreference newPref = new GenericPreference(userID, prefs.GetItemID(i), prefs.GetValue(i));
if (random.nextDouble() < trainingPercentage)
{
if (oneUserTrainingPrefs == null)
{
oneUserTrainingPrefs = new List <IPreference>(3);
}
oneUserTrainingPrefs.Add(newPref);
}
else
{
if (oneUserTestPrefs == null)
{
oneUserTestPrefs = new List <IPreference>(3);
}
oneUserTestPrefs.Add(newPref);
}
}
if (oneUserTrainingPrefs != null)
{
trainingPrefs.Put(userID, new GenericUserPreferenceArray(oneUserTrainingPrefs));
if (oneUserTestPrefs != null)
{
testPrefs.Put(userID, new GenericUserPreferenceArray(oneUserTestPrefs));
}
}
}
private void splitOneUsersPrefs(double trainingPercentage, FastByIDMap <PreferenceArray> trainingPrefs, FastByIDMap <PreferenceArray> testPrefs, long userID, DataModel dataModel)
{
List <Preference> prefs = null;
List <Preference> list2 = null;
PreferenceArray array = dataModel.getPreferencesFromUser(userID);
int num = array.length();
for (int i = 0; i < num; i++)
{
Preference item = new GenericPreference(userID, array.getItemID(i), array.getValue(i));
if (this.random.nextDouble() < trainingPercentage)
{
if (prefs == null)
{
prefs = new List <Preference>(3);
}
prefs.Add(item);
}
else
{
if (list2 == null)
{
list2 = new List <Preference>(3);
}
list2.Add(item);
}
}
if (prefs != null)
{
trainingPrefs.put(userID, new GenericUserPreferenceArray(prefs));
if (list2 != null)
{
testPrefs.put(userID, new GenericUserPreferenceArray(list2));
}
}
}
/**
* {@inheritDoc}
*/
public double Evaluate(RecommenderBuilder recommenderBuilder,
DataModel dataModel,
double trainingPercentage,
double evaluationPercentage)
{
if (recommenderBuilder == null)
{
throw new ArgumentNullException("recommenderBuilder is null");
}
if (dataModel == null)
{
throw new ArgumentNullException("dataModel is null");
}
if (double.IsNaN(trainingPercentage) || trainingPercentage <= 0.0 || trainingPercentage >= 1.0)
{
throw new ArgumentException("Invalid trainingPercentage: " + trainingPercentage);
}
if (double.IsNaN(evaluationPercentage) || evaluationPercentage <= 0.0 || evaluationPercentage > 1.0)
{
throw new ArgumentException("Invalid evaluationPercentage: " + evaluationPercentage);
}
log.Info("Beginning evaluation using " + trainingPercentage + " of " + dataModel);
int numUsers = dataModel.GetNumUsers();
ICollection <User> trainingUsers = new List <User>(1 + (int)(trainingPercentage * (double)numUsers));
IDictionary <User, ICollection <Preference> > testUserPrefs =
new Dictionary <User, ICollection <Preference> >(1 + (int)((1.0 - trainingPercentage) * (double)numUsers));
foreach (User user in dataModel.GetUsers())
{
if (random.NextDouble() < evaluationPercentage)
{
ICollection <Preference> trainingPrefs = new List <Preference>();
ICollection <Preference> testPrefs = new List <Preference>();
Preference[] prefs = user.GetPreferencesAsArray();
foreach (Preference pref in prefs)
{
Item itemCopy = new GenericItem <String>(pref.Item.ID.ToString());
Preference newPref = new GenericPreference(null, itemCopy, pref.Value);
if (random.NextDouble() < trainingPercentage)
{
trainingPrefs.Add(newPref);
}
else
{
testPrefs.Add(newPref);
}
}
if (log.IsDebugEnabled)
{
log.Debug("Training against " + trainingPrefs.Count + " preferences");
log.Debug("Evaluating accuracy of " + testPrefs.Count + " preferences");
}
if (trainingPrefs.Count > 0)
{
User trainingUser = new GenericUser <String>(user.ID.ToString(), trainingPrefs);
trainingUsers.Add(trainingUser);
if (testPrefs.Count > 0)
{
testUserPrefs.Add(trainingUser, testPrefs);
}
}
}
}
DataModel trainingModel = new GenericDataModel(trainingUsers);
Recommender recommender = recommenderBuilder.BuildRecommender(trainingModel);
double result = GetEvaluation(testUserPrefs, recommender);
log.Info("Evaluation result: " + result);
return(result);
}
