Example usage for org.apache.mahout.cf.taste.model DataModel getPreferencesFromUser

List of usage examples for org.apache.mahout.cf.taste.model DataModel getPreferencesFromUser

Introduction

In this page you can find the example usage for org.apache.mahout.cf.taste.model DataModel getPreferencesFromUser.

Prototype

PreferenceArray getPreferencesFromUser(long userID) throws TasteException;

Source Link

Usage

From source file:com.msiiplab.recsys.rwr.GLRecommenderIRStatsEvaluator.java

License:Apache License

public GLIRStatisticsImpl evaluate(RecommenderBuilder recommenderBuilder, List<DataModel> trainingDataModels,
        List<DataModel> testingDataModels, IDRescorer rescorer, int at, double relevanceThreshold,
        double evaluationPercentage) throws TasteException {

    Preconditions.checkArgument(recommenderBuilder != null, "recommenderBuilder is null");
    Preconditions.checkArgument(trainingDataModels != null, "trainingDataModels is null");
    Preconditions.checkArgument(testingDataModels != null, "testingDataModels is null");
    Preconditions.checkArgument(testingDataModels.size() == trainingDataModels.size(),
            "trainingDataModels.size must equals testingDataModels.size");
    Preconditions.checkArgument(at >= 1, "at must be at least 1");
    Preconditions.checkArgument(evaluationPercentage > 0.0 && evaluationPercentage <= 1.0,
            "Invalid evaluationPercentage: %s", evaluationPercentage);

    // num of train/test pair: num of cross validation folds
    int numFolds = trainingDataModels.size();

    RunningAverage CrossValidationPrecision = new GLRunningAverage();
    RunningAverage CrossValidationRPrecision = new GLRunningAverage();
    RunningAverage CrossValidationRecall = new GLRunningAverage();
    RunningAverage CrossValidationFallOut = new GLRunningAverage();
    RunningAverage CrossValidationNDCG = new GLRunningAverage();
    RunningAverage CrossValidationRNDCG = new GLRunningAverage();//rating-nDCG
    RunningAverage CrossValidationReach = new GLRunningAverage();
    RunningAverage CrossValidationMacroDOA = new GLRunningAverage();
    RunningAverage CrossValidationMicroDOA = new GLRunningAverage();
    RunningAverage CrossValidationMacroInnerDOA = new GLRunningAverage();
    RunningAverage CrossValidationMicroInnerDOA = new GLRunningAverage();

    for (int i_folds = 0; i_folds < numFolds; i_folds++) {
        log.info("fold {}", i_folds);
        DataModel trainDataModel = trainingDataModels.get(i_folds);
        DataModel testDataModel = testingDataModels.get(i_folds);

        FastIDSet MovieIDs = new FastIDSet();
        LongPrimitiveIterator it_train_temp = trainDataModel.getItemIDs();
        LongPrimitiveIterator it_test_temp = testDataModel.getItemIDs();
        while (it_train_temp.hasNext()) {
            MovieIDs.add(it_train_temp.nextLong());
        }/*from ww w  .jav  a2  s  . co m*/
        while (it_test_temp.hasNext()) {
            MovieIDs.add(it_test_temp.nextLong());
        }

        int numTrainItems = trainDataModel.getNumItems();
        int numTestItems = testDataModel.getNumItems();
        int numItems = numTestItems + numTrainItems;

        RunningAverage precision = new GLRunningAverage();
        RunningAverage rPrecision = new GLRunningAverage();
        RunningAverage recall = new GLRunningAverage();
        RunningAverage fallOut = new GLRunningAverage();
        RunningAverage nDCG = new GLRunningAverage();
        RunningAverage rNDCG = new GLRunningAverage();
        RunningAverage macroDOA = new GLRunningAverage();
        RunningAverage microDOA1 = new GLRunningAverage();
        RunningAverage microDOA2 = new GLRunningAverage();
        RunningAverage macroInnerDOA = new GLRunningAverage();
        RunningAverage microInnerDOA1 = new GLRunningAverage();
        RunningAverage microInnerDOA2 = new GLRunningAverage();

        int numUsersRecommendedFor = 0;
        int numUsersWithRecommendations = 0;

        long start = System.currentTimeMillis();

        // Build recommender
        Recommender recommender = recommenderBuilder.buildRecommender(trainDataModel);

        LongPrimitiveIterator it_user = testDataModel.getUserIDs();
        while (it_user.hasNext()) {
            long userID = it_user.nextLong();
            log.info("user {}", userID);
            // Use all in testDataModel as relevant
            FastIDSet learnedItemIDs;
            FastIDSet relevantItemIDs;

            try {
                learnedItemIDs = trainDataModel.getItemIDsFromUser(userID);
                relevantItemIDs = testDataModel.getItemIDsFromUser(userID);
            } catch (NoSuchUserException e1) {
                continue;
            }

            // We excluded zero relevant items situation
            int numRelevantItems = relevantItemIDs.size();
            if (numRelevantItems <= 0) {
                continue;
            }

            // We excluded all prefs for the user that has no pref record in
            // training set
            try {
                trainDataModel.getPreferencesFromUser(userID);
            } catch (NoSuchUserException nsee) {
                continue; // Oops we excluded all prefs for the user -- just
                          // move on
            }

            // Recommend items
            List<RecommendedItem> recommendedItems = recommender.recommend(userID, at, rescorer);
            List<RecommendedItem> recommendedItemsAtRelNum = recommender.recommend(userID, numRelevantItems,
                    rescorer);

            PreferenceArray userPreferences = testDataModel.getPreferencesFromUser(userID);
            FastByIDMap<Preference> userPreferenceMap = getPrefereceMap(userPreferences);
            userPreferences.sortByValueReversed();

            // relevantItemIDsAtN only consider top N items as relevant items
            FastIDSet relevantItemIDsAtN = new FastIDSet();
            Iterator<Preference> it_pref = userPreferences.iterator();
            int num_pref = 0;
            while (it_pref.hasNext()) {
                relevantItemIDsAtN.add(it_pref.next().getItemID());
                num_pref++;
                if (num_pref >= at) {
                    break;
                }
            }

            // Compute intersection between recommended items and relevant
            // items
            int intersectionSize = 0;
            int numRecommendedItems = recommendedItems.size();
            for (RecommendedItem recommendedItem : recommendedItems) {
                if (relevantItemIDs.contains(recommendedItem.getItemID())) {
                    intersectionSize++;
                }
            }

            // Precision
            double prec = 0;
            if (numRecommendedItems > 0) {
                prec = (double) intersectionSize / (double) numRecommendedItems;
            }
            precision.addDatum(prec);
            log.info("Precision for user {} is {}", userID, prec);

            // Recall
            double rec = (double) intersectionSize / (double) numRelevantItems;
            recall.addDatum(rec);
            log.info("Recall for user {} is {}", userID, rec);

            // R-precision
            double rprec = 0;
            int intersectionSizeAtRelNum = 0;
            int numRecommendedItemsAtRelNum = recommendedItemsAtRelNum.size();
            for (RecommendedItem recommendedItem : recommendedItemsAtRelNum) {
                if (relevantItemIDs.contains(recommendedItem.getItemID())) {
                    intersectionSizeAtRelNum++;
                }
            }
            if (numRecommendedItemsAtRelNum > 0) {
                rprec = (double) intersectionSizeAtRelNum / (double) numRelevantItems;
            }
            rPrecision.addDatum(rprec);
            log.info("RPrecision for user {} is {}", userID, rprec);

            double F1 = 0;
            if (prec + rec > 0) {
                F1 = 2 * prec * rec / (prec + rec);
            }
            log.info("F1 for user {} is {}", userID, F1);

            // Fall-out
            double fall = 0;
            int size = numRelevantItems + trainDataModel.getItemIDsFromUser(userID).size();
            if (numRelevantItems < size) {
                fall = (double) (numRecommendedItems - intersectionSize)
                        / (double) (numItems - numRelevantItems);
            }
            fallOut.addDatum(fall);
            log.info("Fallout for user {} is {}", userID, fall);

            // nDCG
            // In computing, assume relevant IDs have relevance ${rating} and others
            // 0
            PreferenceArray userPredictions = getPreferenceArray(recommendedItems, userID);
            double userNDCG = computeNDCG(userPreferences, userPredictions, relevantItemIDs, userPreferenceMap,
                    at);
            double userRNDCG = computeRNDCG(userPreferences, userPredictions, relevantItemIDs,
                    userPreferenceMap, at);
            nDCG.addDatum(userNDCG);
            rNDCG.addDatum(userRNDCG);
            log.info("NDCG for user {} is {}", userID, userNDCG);
            log.info("RNDCG for user {} is {}", userID, userRNDCG);

            // Reach
            numUsersRecommendedFor++;
            if (numRecommendedItems > 0) {
                numUsersWithRecommendations++;
            }

            // DOA
            // [Siegel and Castellan, 1988] and [Gori and Pucci, 2007]
            // LongPrimitiveIterator it_movies = MovieIDs.iterator();
            LongPrimitiveIterator it_movies = trainDataModel.getItemIDs();
            long numNW = 0;
            long sumCheckOrder = 0;
            while (it_movies.hasNext()) {
                long itemID = it_movies.nextLong();
                if (!learnedItemIDs.contains(itemID) && !relevantItemIDs.contains(itemID)) {
                    // itemID is in NW_{u_i}
                    numNW++;

                    LongPrimitiveIterator it_test = relevantItemIDs.iterator();
                    while (it_test.hasNext()) {
                        long testItemID = it_test.nextLong();
                        float itemPref = 0;
                        float testItemPref = 0;
                        try {
                            itemPref = recommender.estimatePreference(userID, itemID);
                        } catch (NoSuchItemException e) {
                        }
                        try {
                            testItemPref = recommender.estimatePreference(userID, testItemID);
                        } catch (NoSuchItemException e) {
                        }
                        if (itemPref <= testItemPref) {
                            sumCheckOrder++;
                        }
                    }
                }
            }
            if (numNW > 0 && relevantItemIDs.size() > 0) {
                macroDOA.addDatum((double) sumCheckOrder / (double) (relevantItemIDs.size() * numNW));
                microDOA1.addDatum((double) sumCheckOrder);
                microDOA2.addDatum((double) (relevantItemIDs.size() * numNW));
            }
            //            log.info(
            //                  "sumCheckOrder / (numNW * numRelevant) = {} / ({} * {})",
            //                  sumCheckOrder, numNW, relevantItemIDs.size());

            // InnerDOA: only check the agreement of order in test set
            LongPrimitiveIterator it_test1 = relevantItemIDs.iterator();
            long sumCheckInnerOrder = 0;
            long sumAll = 0;
            while (it_test1.hasNext()) {
                long itemID1 = it_test1.nextLong();
                LongPrimitiveIterator it_test2 = relevantItemIDs.iterator();
                while (it_test2.hasNext()) {
                    long itemID2 = it_test2.nextLong();
                    if (itemID1 != itemID2) {
                        try {
                            float pref_v1 = testDataModel.getPreferenceValue(userID, itemID1);
                            float pref_v2 = testDataModel.getPreferenceValue(userID, itemID2);
                            float predict_v1 = recommender.estimatePreference(userID, itemID1);
                            float predict_v2 = recommender.estimatePreference(userID, itemID2);
                            if ((pref_v1 >= pref_v2 && predict_v1 >= predict_v2)
                                    || (pref_v1 <= pref_v2 && predict_v1 <= predict_v2)) {
                                sumCheckInnerOrder++;
                            }
                            sumAll++;
                        } catch (NoSuchItemException e) {
                            // do nothing, just ignore
                        }
                    }
                }
            }
            if (relevantItemIDs.size() > 1) {
                macroInnerDOA.addDatum((double) sumCheckInnerOrder / (double) sumAll);
                microInnerDOA1.addDatum((double) sumCheckInnerOrder);
                microInnerDOA2.addDatum((double) sumAll);
            }
            //            log.info(
            //                  "sumCheckInnerOrder / (|T| * (|T|-1) ) = {} / ({} * {}) = ",
            //                  sumCheckInnerOrder, relevantItemIDs.size(), relevantItemIDs.size()-1);
        }

        long end = System.currentTimeMillis();

        CrossValidationPrecision.addDatum(precision.getAverage());
        CrossValidationRPrecision.addDatum(rPrecision.getAverage());
        CrossValidationRecall.addDatum(recall.getAverage());
        CrossValidationFallOut.addDatum(fallOut.getAverage());
        CrossValidationNDCG.addDatum(nDCG.getAverage());
        CrossValidationRNDCG.addDatum(rNDCG.getAverage());
        CrossValidationReach.addDatum((double) numUsersWithRecommendations / (double) numUsersRecommendedFor);
        CrossValidationMacroDOA.addDatum(macroDOA.getAverage());
        CrossValidationMicroDOA.addDatum(microDOA1.getAverage() / microDOA2.getAverage());
        CrossValidationMacroInnerDOA.addDatum(macroInnerDOA.getAverage());
        CrossValidationMicroInnerDOA.addDatum(microInnerDOA1.getAverage() / microInnerDOA2.getAverage());

        log.info("Evaluated with training/testing set # {} in {}ms", i_folds, end - start);
        System.out.printf("Evaluated with training/testing set # %d in %d ms \n", i_folds, end - start);

        log.info(
                "Precision/R-Precision/recall/fall-out/nDCG/rNDCG/reach/macroDOA/microDOA/macroInnerDOA/microInnerDOA: {} / {} / {} / {} / {} / {} / {} / {} / {} / {} / {}",
                precision.getAverage(), rPrecision.getAverage(), recall.getAverage(), fallOut.getAverage(),
                nDCG.getAverage(), rNDCG.getAverage(),
                (double) numUsersWithRecommendations / (double) numUsersRecommendedFor, macroDOA.getAverage(),
                microDOA1.getAverage() / microDOA2.getAverage(), macroInnerDOA.getAverage(),
                microInnerDOA1.getAverage() / microInnerDOA2.getAverage());
        System.out.printf(
                "Precision/R-Precision/recall/fall-out/nDCG/rNDCG/reach/macroDOA/microDOA/macroInnerDOA/microInnerDOA: %f / %f / %f / %f / %f / %f / %f / %f / %f / %f / %f \n",
                precision.getAverage(), rPrecision.getAverage(), recall.getAverage(), fallOut.getAverage(),
                nDCG.getAverage(), rNDCG.getAverage(),
                (double) numUsersWithRecommendations / (double) numUsersRecommendedFor, macroDOA.getAverage(),
                microDOA1.getAverage() / microDOA2.getAverage(), macroInnerDOA.getAverage(),
                microInnerDOA1.getAverage() / microInnerDOA2.getAverage());

    }

    log.info(
            "Cross Validation Precision/R-Precision/recall/fall-out/nDCG/rNDCG/reach/macroDOA/microDOA: {} / {} / {} / {} / {} / {} / {} / {} / {} / {} / {}",
            CrossValidationPrecision.getAverage(), CrossValidationRPrecision.getAverage(),
            CrossValidationRecall.getAverage(), CrossValidationFallOut.getAverage(),
            CrossValidationNDCG.getAverage(), CrossValidationRNDCG.getAverage(),
            CrossValidationReach.getAverage(), CrossValidationMacroDOA.getAverage(),
            CrossValidationMicroDOA.getAverage(), CrossValidationMacroInnerDOA.getAverage(),
            CrossValidationMicroInnerDOA.getAverage());
    System.out.printf(
            "Cross Validation: \nPrecision/R-Precision/recall/fall-out/nDCG/rNDCG/reach/macroDOA/microDOA: %f / %f / %f / %f / %f / %f / %f / %f / %f / %f / %f\n",
            CrossValidationPrecision.getAverage(), CrossValidationRPrecision.getAverage(),
            CrossValidationRecall.getAverage(), CrossValidationFallOut.getAverage(),
            CrossValidationNDCG.getAverage(), CrossValidationRNDCG.getAverage(),
            CrossValidationReach.getAverage(), CrossValidationMacroDOA.getAverage(),
            CrossValidationMicroDOA.getAverage(), CrossValidationMacroInnerDOA.getAverage(),
            CrossValidationMicroInnerDOA.getAverage());

    return new GLIRStatisticsImpl(CrossValidationPrecision.getAverage(), CrossValidationRPrecision.getAverage(),
            CrossValidationRecall.getAverage(), CrossValidationFallOut.getAverage(),
            CrossValidationNDCG.getAverage(), CrossValidationRNDCG.getAverage(),
            CrossValidationReach.getAverage(), CrossValidationMacroDOA.getAverage(),
            CrossValidationMicroDOA.getAverage(), CrossValidationMacroInnerDOA.getAverage(),
            CrossValidationMicroInnerDOA.getAverage());
}

From source file:com.mykidscart.mahout_service.RecommenderServlet.java

License:Apache License

private void writeDebugRecommendations(long userID, Iterable<RecommendedItem> items, PrintWriter writer)
        throws TasteException {
    DataModel dataModel = recommender.getDataModel();
    writer.print("User:");
    writer.println(userID);// w  ww. java  2 s . co m
    writer.print("Recommender: ");
    writer.println(recommender);
    writer.println();
    writer.print("Top ");
    writer.print(NUM_TOP_PREFERENCES);
    writer.println(" Preferences:");
    PreferenceArray rawPrefs = dataModel.getPreferencesFromUser(userID);
    int length = rawPrefs.length();
    PreferenceArray sortedPrefs = rawPrefs.clone();
    sortedPrefs.sortByValueReversed();
    // Cap this at NUM_TOP_PREFERENCES just to be brief
    int max = Math.min(NUM_TOP_PREFERENCES, length);
    for (int i = 0; i < max; i++) {
        Preference pref = sortedPrefs.get(i);
        writer.print(pref.getValue());
        writer.print('\t');
        writer.println(pref.getItemID());
    }
    writer.println();
    writer.println("Recommendations:");
    for (RecommendedItem recommendedItem : items) {
        writer.print(recommendedItem.getValue());
        writer.print('\t');
        writer.println(recommendedItem.getItemID());
    }
}

From source file:de.unima.dws.webmining.rs.recommender.AvgUserPrefAdaptedUserBasedRecommender.java

License:Apache License

protected Float calculateAverageRating(long userID) throws TasteException {
    Float avgPref = null;// w  w w  . j a v  a2 s  .  c o m
    DataModel dataModel = getDataModel();
    PreferenceArray preferences = dataModel.getPreferencesFromUser(userID);
    float sum = 0;
    for (int i = 0; i < preferences.length(); i++) {
        Preference preference = preferences.get(i);
        sum += preference.getValue();
    }
    if (preferences.length() > 0) {
        avgPref = sum / preferences.length();
    } else {
        avgPref = 0.0f;
    }
    return avgPref;
}

From source file:lib.eval.AbstractRecommenderEvaluator.java

License:Apache License

@Override
public double evaluate(RecommenderBuilder recommenderBuilder, DataModelBuilder dataModelBuilder,
        DataModel dataModel, double trainingPercentage, double evaluationPercentage) throws TasteException {
    Preconditions.checkArgument(recommenderBuilder != null, "recommenderBuilder is null");
    Preconditions.checkArgument(dataModel != null, "dataModel is null");
    Preconditions.checkArgument(trainingPercentage >= 0.0 && trainingPercentage <= 1.0,
            "Invalid trainingPercentage: " + trainingPercentage);
    Preconditions.checkArgument(evaluationPercentage >= 0.0 && evaluationPercentage <= 1.0,
            "Invalid evaluationPercentage: " + evaluationPercentage);

    log.info("Beginning evaluation using {} of {}", trainingPercentage, dataModel);

    int numUsers = dataModel.getNumUsers();
    FastByIDMap<PreferenceArray> trainingUsers = new FastByIDMap<PreferenceArray>(
            1 + (int) (evaluationPercentage * numUsers));
    FastByIDMap<PreferenceArray> testUserPrefs = new FastByIDMap<PreferenceArray>(
            1 + (int) (evaluationPercentage * numUsers));

    LongPrimitiveIterator it = dataModel.getUserIDs();
    while (it.hasNext()) {
        long userID = it.nextLong();
        if (random.nextDouble() < evaluationPercentage) {
            processOneUser(trainingPercentage, trainingUsers, testUserPrefs, userID, dataModel);
        } else { //this user will not be used for evaluation so use all its preferences in training
            PreferenceArray trainingPrefs = dataModel.getPreferencesFromUser(userID);
            trainingUsers.put(userID, trainingPrefs);
        }//from   w ww . ja  va  2s .  c  o m
    }

    DataModel trainingModel = dataModelBuilder == null ? new GenericDataModel(trainingUsers)
            : dataModelBuilder.buildDataModel(trainingUsers);

    Recommender recommender = recommenderBuilder.buildRecommender(trainingModel);

    double result = getEvaluation(testUserPrefs, recommender);
    log.info("Evaluation result: {}", result);
    return result;
}

From source file:lib.eval.AbstractRecommenderEvaluator.java

License:Apache License

private void processOneUser(double trainingPercentage, FastByIDMap<PreferenceArray> trainingUsers,
        FastByIDMap<PreferenceArray> testUserPrefs, long userID, DataModel dataModel) throws TasteException {
    List<Preference> trainingPrefs = null;
    List<Preference> testPrefs = null;
    PreferenceArray prefs = dataModel.getPreferencesFromUser(userID);
    int size = prefs.length();
    for (int i = 0; i < size; i++) {
        Preference newPref = new GenericPreference(userID, prefs.getItemID(i), prefs.getValue(i));
        if (random.nextDouble() < trainingPercentage) {
            if (trainingPrefs == null) {
                trainingPrefs = new ArrayList<Preference>(3);
            }/* ww  w.  j av  a2  s. c  o  m*/
            trainingPrefs.add(newPref);
        } else {
            if (testPrefs == null) {
                testPrefs = new ArrayList<Preference>(3);
            }
            testPrefs.add(newPref);
        }
    }
    if (trainingPrefs != null) {
        trainingUsers.put(userID, new GenericUserPreferenceArray(trainingPrefs));
        if (testPrefs != null) {
            testUserPrefs.put(userID, new GenericUserPreferenceArray(testPrefs));
        }
    }
}

From source file:lib.similarity.AbstractUnboundedSimilarity.java

License:Apache License

@Override
public double userSimilarity(long userID1, long userID2) throws TasteException {
    DataModel dataModel = getDataModel();
    PreferenceArray xPrefs = dataModel.getPreferencesFromUser(userID1);
    PreferenceArray yPrefs = dataModel.getPreferencesFromUser(userID2);
    int xLength = xPrefs.length();
    int yLength = yPrefs.length();

    if (xLength == 0 || yLength == 0) {
        return Double.NaN;
    }//from w w  w  . j a va 2 s.c o m

    long xIndex = xPrefs.getItemID(0);
    long yIndex = yPrefs.getItemID(0);
    int xPrefIndex = 0;
    int yPrefIndex = 0;

    boolean hasInferrer = inferrer != null;
    boolean hasPrefTransform = prefTransform != null;

    SimilarityAccumulator accum = getSimilarityAccumulator();

    while (true) {
        int compare = xIndex < yIndex ? -1 : xIndex > yIndex ? 1 : 0;
        if (hasInferrer || compare == 0) {
            double x;
            double y;
            if (xIndex == yIndex) {
                // Both users expressed a preference for the item
                if (hasPrefTransform) {
                    x = prefTransform.getTransformedValue(xPrefs.get(xPrefIndex));
                    y = prefTransform.getTransformedValue(yPrefs.get(yPrefIndex));
                } else {
                    x = xPrefs.getValue(xPrefIndex);
                    y = yPrefs.getValue(yPrefIndex);
                }
            } else {
                // Only one user expressed a preference, but infer the other one's preference and tally
                // as if the other user expressed that preference
                if (compare < 0) {
                    // X has a value; infer Y's
                    x = hasPrefTransform ? prefTransform.getTransformedValue(xPrefs.get(xPrefIndex))
                            : xPrefs.getValue(xPrefIndex);
                    y = inferrer.inferPreference(userID2, xIndex);
                } else {
                    // compare > 0
                    // Y has a value; infer X's
                    x = inferrer.inferPreference(userID1, yIndex);
                    y = hasPrefTransform ? prefTransform.getTransformedValue(yPrefs.get(yPrefIndex))
                            : yPrefs.getValue(yPrefIndex);
                }
            }

            accum.processPrefPair(x, y);

        }
        if (compare <= 0) {
            if (++xPrefIndex >= xLength) {
                if (hasInferrer) {
                    // Must count other Ys; pretend next X is far away
                    if (yIndex == Long.MAX_VALUE) {
                        // ... but stop if both are done!
                        break;
                    }
                    xIndex = Long.MAX_VALUE;
                } else {
                    break;
                }
            } else {
                xIndex = xPrefs.getItemID(xPrefIndex);
            }
        }
        if (compare >= 0) {
            if (++yPrefIndex >= yLength) {
                if (hasInferrer) {
                    // Must count other Xs; pretend next Y is far away            
                    if (xIndex == Long.MAX_VALUE) {
                        // ... but stop if both are done!
                        break;
                    }
                    yIndex = Long.MAX_VALUE;
                } else {
                    break;
                }
            } else {
                yIndex = yPrefs.getItemID(yPrefIndex);
            }
        }
    }

    double result;
    result = accum.computeResult();

    if (similarityTransform != null) {
        result = similarityTransform.transformSimilarity(userID1, userID2, result);
    }

    return result;
}

From source file:norbert.mynemo.core.evaluation.PersonnalRecommenderEvaluator.java

License:Apache License

/**
 * Copies the preferences of the given user, from the given data model to the given map.
 *
 * @param dataModel source of the preferences
 * @param preferences destination of the preferences
 * @param user user id/*w w  w. ja  v  a 2s  .  c  o m*/
 */
private static void copyUserPreferences(DataModel dataModel, FastByIDMap<PreferenceArray> preferences,
        long user) throws TasteException {
    List<Preference> oneUserTrainingPrefs = null;

    for (Preference preference : dataModel.getPreferencesFromUser(user)) {
        Preference newPref = new GenericPreference(user, preference.getItemID(), preference.getValue());
        if (oneUserTrainingPrefs == null) {
            oneUserTrainingPrefs = Lists.newArrayListWithCapacity(3);
        }
        oneUserTrainingPrefs.add(newPref);

    }

    preferences.put(user, new GenericUserPreferenceArray(oneUserTrainingPrefs));
}

From source file:norbert.mynemo.core.evaluation.PersonnalRecommenderEvaluator.java

License:Apache License

/**
 * Copies the preferences of the target user to the given preference map, except the given ones.
 *///from w w w . j av  a  2 s . c o m
private void addUserPreferences(DataModel model, FastByIDMap<PreferenceArray> preferences,
        Collection<Preference> preferencesToExclude) throws TasteException {
    PreferenceArray targetUserPreferences = model.getPreferencesFromUser(targetUser);
    List<Preference> preferencesToAdd = new ArrayList<>(
            targetUserPreferences.length() - preferencesToExclude.size());

    // hash set to speed the method
    Set<Long> itemToExclude = new HashSet<>(preferencesToExclude.size());
    for (Preference preference : preferencesToExclude) {
        itemToExclude.add(preference.getItemID());
    }

    for (Preference currentPreference : targetUserPreferences) {
        // the equals method of Preference do not behave as expected, thus
        // preferencesToExclude.contains(currentPreference) can't be used
        if (!itemToExclude.contains(currentPreference.getItemID())) {
            preferencesToAdd.add(currentPreference);
        }
    }

    preferences.put(targetUser, new GenericUserPreferenceArray(preferencesToAdd));
}

From source file:norbert.mynemo.core.evaluation.PersonnalRecommenderEvaluator.java

License:Apache License

/**
 * Builds all test sets. The test sets are a random partition of the preferences of the target
 * user. The number of partition is derived from the given percentage.
 *
 * <p>/*from w  w  w. j  av a2 s.co  m*/
 * If the evaluation is not exhaustive or if the given percentage is less than 0.5, then only one
 * set is build, that contains the given percentage of preference.
 */
private List<List<Preference>> buildTestSets(DataModel dataModel, double trainingPercentage)
        throws TasteException {

    PreferenceArray targetUserPreferences = dataModel.getPreferencesFromUser(targetUser);

    if (trainingPercentage < 0.5 || !exhaustive) {
        // create only one set, fill it, exit
        return buildNonExhaustiveTestSet(targetUserPreferences, trainingPercentage);
    }

    int numberOfPreferences = dataModel.getPreferencesFromUser(targetUser).length();
    int numberOfSets = numberOfTestSets(trainingPercentage, numberOfPreferences);

    // Initialize the lists
    List<List<Preference>> result = new ArrayList<>(numberOfSets);
    for (int index = 0; index < numberOfSets; index++) {
        result.add(index, new ArrayList<Preference>());
    }
    if (numberOfSets == numberOfPreferences) {
        // fill each set with one preference. This ensures that each set
        // will contain one preference.
        for (int index = 0; index < result.size(); index++) {
            result.get(index).add(targetUserPreferences.get(index));
        }
    } else {
        // fill the sets randomly
        for (Preference currentPreference : dataModel.getPreferencesFromUser(targetUser)) {
            result.get((int) Math.floor(random.nextDouble() * numberOfSets)).add(currentPreference);
        }
    }

    return result;
}

From source file:org.easyrec.mahout.EasyrecInMemoryDataModelTest.java

License:Open Source License

@Test
public void testEasyrecDataModel_getPreferencesFromUser() throws TasteException {
    DataModel easyrecDataModel = new EasyrecDataModel(TENANT_ID, RATE_ACTION_TYPE_ID, HAS_RATING_VALUES,
            mahoutDataModelMappingDAO);/* w w w  .j a va 2  s  .c om*/
    easyrecDataModel = new EasyrecInMemoryDataModel(easyrecDataModel);

    PreferenceArray preferences = easyrecDataModel.getPreferencesFromUser(1);

    String ids = "";
    for (long id : preferences.getIDs()) {
        ids += id;
    }

    assertEquals("123", ids);
}