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

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

Introduction

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

Prototype

int getNumItems() throws TasteException;

Source Link

Usage

From source file:ContentBasedRecommender.java

License:Apache License

/**
 * Method the creates a list of recommendations.
 * Already rated stories are excluded, as are stories present in the front end array if add="true"
 * //from   w  ww . j a va2 s  .c o m
 * @throws TasteException   thrown if there if something went wrong with Mahout
 */
public void runContentBasedRecommender() throws TasteException {
    /*Find out where this file is located*/
    try {
        fileLocation = new File(this.getClass().getProtectionDomain().getCodeSource().getLocation().toURI());
    } catch (URISyntaxException e) {
        e.printStackTrace();
    }
    /*"content"+userId is the name of the view we shall create*/
    conn.setConnection();

    /*Create a temporary view the includes all preferences values for this user*/
    conn.createView((int) userId);

    /*Sets the dataModel based on the data in the created view*/
    conn.setDataModel();

    DataModel model = conn.getDataModel();

    /*Gets all the info from the similarites.csv file into a list of objects accepted by Mahout*/
    Collection<ItemItemSimilarity> sim = getStorySimilarities();

    /*GenericItemBasedRecommender need an ItemSimilarity-object as input, so create an instance of this class.*/
    ItemSimilarity similarity = new GenericItemSimilarity(sim);

    /*Create a new Recommender-instance with our datamodel and story similarities*/
    GenericItemBasedRecommender recommender = new GenericItemBasedRecommender(model, similarity);

    /* Compute the recommendations. model.getNumItems() is the number of recommendations we want (we don't really want that many, 
     * but we don't know how many of the top items the user already have rated), don't worry about the null, 
     * and true tells the recommender that we want to include already known items*/
    List<RecommendedItem> recommendations = recommender.recommend(userId, model.getNumItems(), null, true);

    /*Find the stories that the user have rated*/
    HashMap<Integer, Integer> ratedStories = conn.getRated((int) userId);

    ArrayList<Integer> frontendStories = new ArrayList<>();

    /* Find the stories already present in the recommendations list at front end
     * These stories should not be recommended again*/
    if (add.equals("true")) {
        frontendStories = conn.getStoriesInFrontendArray((int) userId);
    }
    int ranking = 1;
    Random rand = new Random();
    int randomDislikedRanking = rand.nextInt(6) + 5;

    ArrayList<DatabaseInsertObject> itemsToBeInserted = new ArrayList<>();
    ArrayList<Long> idsToBeInserted = new ArrayList<>();
    for (RecommendedItem recommendation : recommendations) {
        /* To get a story outside of the users preferences, finds the least recommended story */
        if (randomDislikedRanking == ranking) {
            /*Make sure the false recommendation is not already in the front end array or already among the top ten recommendation (may happen if the user doesn't have many not seen/not rated stories left) */
            for (int i = 1; i < recommendations.size(); i++) {
                long dislikedStoryId = recommendations.get(recommendations.size() - i).getItemID();
                if (!frontendStories.contains((int) dislikedStoryId)
                        && !idsToBeInserted.contains(dislikedStoryId)
                        && ratedStories.get((int) dislikedStoryId) == null) {
                    itemsToBeInserted.add(new DatabaseInsertObject((int) userId, "DF." + dislikedStoryId,
                            "FalseRecommendation", 1, 0, ranking,
                            recommendations.get(recommendations.size() - i).getValue()));
                    idsToBeInserted.add(dislikedStoryId);
                    System.out.print("False recommend: ");
                    System.out.println(dislikedStoryId);
                    break;
                }
            }
            ranking++;
            if (ranking > 10) {
                break;
            }
            continue;
        }

        /*If the item has not been rated,is not already in the recommendation list at front end or already a false recommendation we insert it*/
        if ((ratedStories.get((int) recommendation.getItemID()) == null)
                && !frontendStories.contains((int) recommendation.getItemID())
                && !idsToBeInserted.contains(recommendation.getItemID())) {
            /*Get the 30 items that had most influence on the recommendation*/
            List<RecommendedItem> becauseItems = recommender.recommendedBecause(userId,
                    recommendation.getItemID(), 30);
            int counter = 1;
            ArrayList<RecommendedItem> explanationItems = new ArrayList<>();
            for (RecommendedItem because : becauseItems) {
                /*Add story to explanation if this story has been rated and the rating is good*/
                if (!explanationItems.contains(because) && ratedStories.get((int) because.getItemID()) != null
                        && ratedStories.get((int) because.getItemID()) > 2) {
                    explanationItems.add(because);
                    counter++;
                }
                if (counter > 3) {
                    break;
                }
            }
            /*Gets the titles of the explanation-stories and creates a string*/
            String explanation = conn.createExplanation(explanationItems);
            itemsToBeInserted.add(new DatabaseInsertObject((int) userId, "DF." + recommendation.getItemID(),
                    explanation, 0, 0, ranking, recommendation.getValue()));
            idsToBeInserted.add(recommendation.getItemID());
            System.out.println(recommendation);
            ranking++;
        }
        /*When we got 10 new recommendations, we're happy*/
        if (ranking > 10) {
            break;
        }
    }
    this.recommendations = recommendations;
    /*Delete the current recommendations stored in stored_story that has not been seen by the user*/
    conn.deleteRecommendations((int) userId);

    /*Insert the 10 items we found*/
    conn.insertUpdateRecommendValues(itemsToBeInserted);

    /*Drop our temporary view*/
    conn.dropView();
    conn.closeConnection();

}

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 w w  w  .  j  a  v a 2  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.msiiplab.recsys.rwr.ParallelGLRecommenderIRStatsEvaluator.java

License:Apache License

@Override
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());
        }/*w ww .  j a  v a2 s  .  c  o  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);

        // Futures
        ArrayList<Future<Integer>> futureList = new ArrayList<Future<Integer>>();

        int N_CPUS = Runtime.getRuntime().availableProcessors();
        ExecutorService pool = Executors.newFixedThreadPool(N_CPUS - 1);
        // ExecutorService pool = Executors.newFixedThreadPool(1);

        LongPrimitiveIterator it_user = testDataModel.getUserIDs();
        while (it_user.hasNext()) {
            long userID = it_user.nextLong();

            Future<Integer> future = pool.submit(new Eval(precision, rPrecision, recall, fallOut, nDCG, rNDCG,
                    macroDOA, microDOA1, microDOA2, macroInnerDOA, microInnerDOA1, microInnerDOA2,
                    trainDataModel, testDataModel, userID, recommender, at, rescorer, numItems));
            futureList.add(future);
        }

        for (Future<Integer> future : futureList) {
            numUsersRecommendedFor++;
            try {
                if (future.get() == 1) {
                    numUsersWithRecommendations++;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
                e.getCause().printStackTrace();
                System.exit(1);
            }
        }

        pool.shutdown();

        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:lib.similarity.AbstractUnboundedSimilarity.java

License:Apache License

/**
 * <p>/*from   ww  w.  j  a  v  a2s.  c om*/
 * Creates an AbstractUnboundedSimilarity.
 * </p>
 */
AbstractUnboundedSimilarity(final DataModel dataModel) throws TasteException {
    super(dataModel);

    this.cachedNumItems = dataModel.getNumItems();
    this.cachedNumUsers = dataModel.getNumUsers();
    this.refreshHelper = new RefreshHelper(new Callable<Object>() {
        @Override
        public Object call() throws TasteException {
            cachedNumItems = dataModel.getNumItems();
            cachedNumUsers = dataModel.getNumUsers();
            return null;
        }
    });
}

From source file:net.recommenders.rival.examples.movielens100k.IterativeCrossValidatedMahoutKNNRecommenderEvaluator.java

License:Apache License

/**
 * Recommends using an UB algorithm./*  w  w w .j a v  a 2  s.  c o  m*/
 *
 * @param nFolds number of folds
 * @param inPath path where training and test models have been stored
 * @param outPath path where recommendation files will be stored
 */
public static void recommend(final int nFolds, final String inPath, final String outPath) {
    for (int i = 0; i < nFolds; i++) {
        org.apache.mahout.cf.taste.model.DataModel trainModel;
        org.apache.mahout.cf.taste.model.DataModel testModel;
        try {
            trainModel = new FileDataModel(new File(inPath + "train_" + i + ".csv"));
            testModel = new FileDataModel(new File(inPath + "test_" + i + ".csv"));
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }

        GenericRecommenderBuilder grb = new GenericRecommenderBuilder();
        String recommenderClass = "org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender";
        String similarityClass = "org.apache.mahout.cf.taste.impl.similarity.PearsonCorrelationSimilarity";
        int neighborhoodSize = NEIGH_SIZE;
        Recommender recommender = null;
        try {
            recommender = grb.buildRecommender(trainModel, recommenderClass, similarityClass, neighborhoodSize);
        } catch (RecommenderException e) {
            e.printStackTrace();
        }

        String fileName = "recs_" + i + ".csv";

        LongPrimitiveIterator users;
        try {
            users = testModel.getUserIDs();
            boolean createFile = true;
            while (users.hasNext()) {
                long u = users.nextLong();
                assert recommender != null;
                List<RecommendedItem> items = recommender.recommend(u, trainModel.getNumItems());
                RecommenderIO.writeData(u, items, outPath, fileName, !createFile, null);
                createFile = false;
            }
        } catch (TasteException e) {
            e.printStackTrace();
        }
    }
}

From source file:net.recommenders.rival.examples.movielens100k.RandomSplitMahoutKNNRecommenderEvaluator.java

License:Apache License

/**
 * Recommends using an UB algorithm./*from ww w  .  ja v  a2s.c om*/
 *
 * @param inPath path where training and test models have been stored
 * @param outPath path where recommendation files will be stored
 */
public static void recommend(final String inPath, final String outPath) {
    int i = 0;
    org.apache.mahout.cf.taste.model.DataModel trainModel = null;
    org.apache.mahout.cf.taste.model.DataModel testModel = null;
    try {
        trainModel = new FileDataModel(new File(inPath + "train_" + i + ".csv"));
        testModel = new FileDataModel(new File(inPath + "test_" + i + ".csv"));
    } catch (IOException e) {
        e.printStackTrace();
        return;
    }

    GenericRecommenderBuilder grb = new GenericRecommenderBuilder();
    String recommenderClass = "org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender";
    String similarityClass = "org.apache.mahout.cf.taste.impl.similarity.PearsonCorrelationSimilarity";
    int neighborhoodSize = NEIGH_SIZE;
    Recommender recommender = null;
    try {
        recommender = grb.buildRecommender(trainModel, recommenderClass, similarityClass, neighborhoodSize);
    } catch (RecommenderException e) {
        e.printStackTrace();
    }

    String fileName = "recs_" + i + ".csv";

    LongPrimitiveIterator users = null;
    try {
        users = testModel.getUserIDs();
        boolean createFile = true;
        while (users.hasNext()) {
            long u = users.nextLong();
            List<RecommendedItem> items = recommender.recommend(u, trainModel.getNumItems());
            RecommenderIO.writeData(u, items, outPath, fileName, !createFile, null);
            createFile = false;
        }
    } catch (TasteException e) {
        e.printStackTrace();
    }
}

From source file:net.recommenders.rival.examples.movielens100k.TemporalSplitMahoutKNNRecommenderEvaluator.java

License:Apache License

/**
 * Recommends using an UB algorithm./*w w  w .ja v  a2 s .com*/
 *
 * @param inPath path where training and test models have been stored
 * @param outPath path where recommendation files will be stored
 */
public static void recommend(final String inPath, final String outPath) {
    int i = 0;
    org.apache.mahout.cf.taste.model.DataModel trainModel;
    org.apache.mahout.cf.taste.model.DataModel testModel;
    try {
        trainModel = new FileDataModel(new File(inPath + "train_" + i + ".csv"));
        testModel = new FileDataModel(new File(inPath + "test_" + i + ".csv"));
    } catch (IOException e) {
        e.printStackTrace();
        return;
    }

    GenericRecommenderBuilder grb = new GenericRecommenderBuilder();
    String recommenderClass = "org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender";
    String similarityClass = "org.apache.mahout.cf.taste.impl.similarity.PearsonCorrelationSimilarity";
    int neighborhoodSize = NEIGH_SIZE;
    Recommender recommender = null;
    try {
        recommender = grb.buildRecommender(trainModel, recommenderClass, similarityClass, neighborhoodSize);
    } catch (RecommenderException e) {
        e.printStackTrace();
    }

    String fileName = "recs_" + i + ".csv";

    LongPrimitiveIterator users;
    try {
        users = testModel.getUserIDs();
        boolean createFile = true;
        while (users.hasNext()) {
            long u = users.nextLong();
            assert recommender != null;
            List<RecommendedItem> items = recommender.recommend(u, trainModel.getNumItems());
            RecommenderIO.writeData(u, items, outPath, fileName, !createFile, null);
            createFile = false;
        }
    } catch (TasteException e) {
        e.printStackTrace();
    }
}

From source file:net.ufida.info.mahout.common.MemoryDiffStorage.java

License:Apache License

/**
 * <p>/*  w w w  .ja va 2s.  co  m*/
 * See {@link SlopeOneRecommender} for the meaning of
 * {@code stdDevWeighted}. {@code maxEntries} controls the maximum number of
 * item-item average preference differences that will be tracked internally. After the limit is reached, if
 * a new item-item pair is observed in the data it will be ignored. This is recommended for large datasets.
 * The first {@code maxEntries} item-item pairs observed in the data are tracked. Assuming that item
 * ratings are reasonably distributed among users, this should only ignore item-item pairs that are very
 * infrequently co-rated by a user. The intuition is that data on these infrequently co-rated item-item
 * pairs is less reliable and should be the first that is ignored. This parameter can be used to limit the
 * memory requirements of {@link SlopeOneRecommender}, which otherwise grow as the square of the number of
 * items that exist in the {@link DataModel}. Memory requirements can reach gigabytes with only about 10000
 * items, so this may be necessary on larger datasets.
 *
 * @param stdDevWeighted
 *          see {@link SlopeOneRecommender}
 * @param maxEntries
 *          maximum number of item-item average preference differences to track internally
 * @throws IllegalArgumentException
 *           if {@code maxEntries} is not positive or {@code dataModel} is null
 */
public MemoryDiffStorage(DataModel dataModel, Weighting stdDevWeighted, long maxEntries) throws TasteException {
    Preconditions.checkArgument(dataModel != null, "dataModel is null");
    Preconditions.checkArgument(dataModel.getNumItems() >= 1, "dataModel has no items");
    Preconditions.checkArgument(maxEntries > 0L, "maxEntries must be positive");
    this.dataModel = dataModel;
    this.stdDevWeighted = stdDevWeighted == Weighting.WEIGHTED;
    this.maxEntries = maxEntries;
    this.averageDiffs = new FastByIDMap<FastByIDMap<RunningAverage>>();
    this.averageItemPref = new FastByIDMap<RunningAverage>();
    this.buildAverageDiffsLock = new ReentrantReadWriteLock();
    this.allRecommendableItemIDs = new FastIDSet(dataModel.getNumItems());

    //?
    this.refreshHelper = new RefreshHelper(new Callable<Object>() {
        @Override
        public Object call() throws TasteException {
            buildAverageDiffs(); //
            return null;
        }
    });

    refreshHelper.addDependency(dataModel); //??

    //
    /* List<Refreshable> list = new ArrayList<Refreshable>();
     list.add(dataModel);
     refreshHelper.refresh(list);     */
    buildAverageDiffs();
}

From source file:norbert.mynemo.core.recommendation.recommender.ItemSimilarityRecommender.java

License:Apache License

@Override
public Recommender buildRecommender(DataModel dataModel) throws TasteException {
    checkArgument(dataModel != null, "Data model type must not be null.");

    ItemSimilarity similarity = null;//from   w w w  .  jav a  2s .  c  o m
    switch (selectedSimilarity) {
    case ITEM_SIMILARITY_WITH_CITY_BLOCK_DISTANCE:
        similarity = new CityBlockSimilarity(dataModel);
        break;
    case ITEM_SIMILARITY_WITH_EUCLIDEAN_DISTANCE:
        similarity = new EuclideanDistanceSimilarity(dataModel, Weighting.UNWEIGHTED);
        break;
    case ITEM_SIMILARITY_WITH_LOG_LIKELIHOOD:
        similarity = new LogLikelihoodSimilarity(dataModel);
        break;
    case ITEM_SIMILARITY_WITH_PEARSON_CORRELATION:
        similarity = new PearsonCorrelationSimilarity(dataModel, Weighting.UNWEIGHTED);
        break;
    case ITEM_SIMILARITY_WITH_TANIMOTO_COEFFICIENT:
        similarity = new TanimotoCoefficientSimilarity(dataModel);
        break;
    case ITEM_SIMILARITY_WITH_UNCENTERED_COSINE:
        similarity = new UncenteredCosineSimilarity(dataModel, Weighting.UNWEIGHTED);
        break;
    case ITEM_SIMILARITY_WITH_WEIGHTED_EUCLIDEAN_DISTANCE:
        similarity = new EuclideanDistanceSimilarity(dataModel, Weighting.WEIGHTED);
        break;
    case ITEM_SIMILARITY_WITH_WEIGHTED_PEARSON_CORRELATION:
        similarity = new PearsonCorrelationSimilarity(dataModel, Weighting.WEIGHTED);
        break;
    case ITEM_SIMILARITY_WITH_WEIGHTED_UNCENTERED_COSINE:
        similarity = new UncenteredCosineSimilarity(dataModel, Weighting.WEIGHTED);
        break;
    default:
        throw new IllegalStateException();
    }

    int cacheSize = Math.min(dataModel.getNumItems() * dataModel.getNumItems(), MAXIMUM_CACHE_SIZE);
    similarity = new CachingItemSimilarity(similarity, cacheSize);

    return new GenericItemBasedRecommender(dataModel, similarity);
}

From source file:norbert.mynemo.ui.RecommendCommandParser.java

License:Apache License

/**
 * Parses and checks the "data-model" option.
 *///from www.j a va 2  s  . com
private static DataModel parseDataModel(String dataModel) throws TasteException {
    if (!new File(dataModel).exists()) {
        throw new IllegalArgumentException("Error: unable to find the the data model file.");
    }

    DataModel result;

    try {
        result = new StringUserDataModel(new File(dataModel));
    } catch (IOException e) {
        throw new IllegalStateException("Error: unable to load the data model.", e);
    }

    // check
    if (result.getNumUsers() == 0 || result.getNumItems() == 0) {
        throw new IllegalArgumentException("Error: the data model doesn't contain any data.");
    }

    return result;
}