Example usage for org.apache.mahout.math.als ImplicitFeedbackAlternatingLeastSquaresSolver ImplicitFeedbackAlternatingLeastSquaresSolver

Introduction

In this page you can find the example usage for org.apache.mahout.math.als ImplicitFeedbackAlternatingLeastSquaresSolver ImplicitFeedbackAlternatingLeastSquaresSolver.

Prototype

public ImplicitFeedbackAlternatingLeastSquaresSolver(int numFeatures, double lambda, double alpha,
            OpenIntObjectHashMap<Vector> Y, int numTrainingThreads) 

Source Link

Usage

From source file:org.gpfvic.mahout.cf.taste.hadoop.als.SolveImplicitFeedbackMapper.java

License:Apache License

@Override
ImplicitFeedbackAlternatingLeastSquaresSolver createSharedInstance(Context ctx) throws IOException {
    Configuration conf = ctx.getConfiguration();

    double lambda = Double.parseDouble(conf.get(ParallelALSFactorizationJob.LAMBDA));
    double alpha = Double.parseDouble(conf.get(ParallelALSFactorizationJob.ALPHA));
    int numFeatures = conf.getInt(ParallelALSFactorizationJob.NUM_FEATURES, -1);
    int numEntities = Integer.parseInt(conf.get(ParallelALSFactorizationJob.NUM_ENTITIES));

    Preconditions.checkArgument(numFeatures > 0, "numFeatures must be greater then 0!");

    return new ImplicitFeedbackAlternatingLeastSquaresSolver(numFeatures, lambda, alpha,
            ALS.readMatrixByRowsFromDistributedCache(numEntities, conf), 1);
}

---

From source file:org.gpfvic.mahout.cf.taste.impl.recommender.svd.ALSWRFactorizer.java

License:Apache License

@Override
public Factorization factorize() throws TasteException {
    log.info("starting to compute the factorization...");
    final Features features = new Features(this);

    /* feature maps necessary for solving for implicit feedback */
    OpenIntObjectHashMap<Vector> userY = null;
    OpenIntObjectHashMap<Vector> itemY = null;

    if (usesImplicitFeedback) {
        userY = userFeaturesMapping(dataModel.getUserIDs(), dataModel.getNumUsers(), features.getU());
        itemY = itemFeaturesMapping(dataModel.getItemIDs(), dataModel.getNumItems(), features.getM());
    }/*from   www .  j  a v  a 2s  .com*/

    for (int iteration = 0; iteration < numIterations; iteration++) {
        log.info("iteration {}", iteration);

        /* fix M - compute U */
        ExecutorService queue = createQueue();
        LongPrimitiveIterator userIDsIterator = dataModel.getUserIDs();
        try {

            final ImplicitFeedbackAlternatingLeastSquaresSolver implicitFeedbackSolver = usesImplicitFeedback
                    ? new ImplicitFeedbackAlternatingLeastSquaresSolver(numFeatures, lambda, alpha, itemY,
                            numTrainingThreads)
                    : null;

            while (userIDsIterator.hasNext()) {
                final long userID = userIDsIterator.nextLong();
                final LongPrimitiveIterator itemIDsFromUser = dataModel.getItemIDsFromUser(userID).iterator();
                final PreferenceArray userPrefs = dataModel.getPreferencesFromUser(userID);
                queue.execute(new Runnable() {
                    @Override
                    public void run() {
                        List<Vector> featureVectors = new ArrayList<>();
                        while (itemIDsFromUser.hasNext()) {
                            long itemID = itemIDsFromUser.nextLong();
                            featureVectors.add(features.getItemFeatureColumn(itemIndex(itemID)));
                        }

                        Vector userFeatures = usesImplicitFeedback
                                ? implicitFeedbackSolver.solve(sparseUserRatingVector(userPrefs))
                                : AlternatingLeastSquaresSolver.solve(featureVectors, ratingVector(userPrefs),
                                        lambda, numFeatures);

                        features.setFeatureColumnInU(userIndex(userID), userFeatures);
                    }
                });
            }
        } finally {
            queue.shutdown();
            try {
                queue.awaitTermination(dataModel.getNumUsers(), TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                log.warn("Error when computing user features", e);
            }
        }

        /* fix U - compute M */
        queue = createQueue();
        LongPrimitiveIterator itemIDsIterator = dataModel.getItemIDs();
        try {

            final ImplicitFeedbackAlternatingLeastSquaresSolver implicitFeedbackSolver = usesImplicitFeedback
                    ? new ImplicitFeedbackAlternatingLeastSquaresSolver(numFeatures, lambda, alpha, userY,
                            numTrainingThreads)
                    : null;

            while (itemIDsIterator.hasNext()) {
                final long itemID = itemIDsIterator.nextLong();
                final PreferenceArray itemPrefs = dataModel.getPreferencesForItem(itemID);
                queue.execute(new Runnable() {
                    @Override
                    public void run() {
                        List<Vector> featureVectors = new ArrayList<>();
                        for (Preference pref : itemPrefs) {
                            long userID = pref.getUserID();
                            featureVectors.add(features.getUserFeatureColumn(userIndex(userID)));
                        }

                        Vector itemFeatures = usesImplicitFeedback
                                ? implicitFeedbackSolver.solve(sparseItemRatingVector(itemPrefs))
                                : AlternatingLeastSquaresSolver.solve(featureVectors, ratingVector(itemPrefs),
                                        lambda, numFeatures);

                        features.setFeatureColumnInM(itemIndex(itemID), itemFeatures);
                    }
                });
            }
        } finally {
            queue.shutdown();
            try {
                queue.awaitTermination(dataModel.getNumItems(), TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                log.warn("Error when computing item features", e);
            }
        }
    }

    log.info("finished computation of the factorization...");
    return createFactorization(features.getU(), features.getM());
}

---