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

List of usage examples for org.apache.mahout.math.als ImplicitFeedbackAlternatingLeastSquaresSolver solve

Introduction

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

Prototype

public Vector solve(Vector ratings) 

Source Link

Usage

From source file:org.codelibs.elasticsearch.taste.recommender.svd.ALSWRFactorizer.java

License:Apache License

@Override
public Factorization factorize() {
    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   w w w.  ja v a  2s. c om

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

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

            final ImplicitFeedbackAlternatingLeastSquaresSolver implicitFeedbackSolver = usesImplicitFeedback
                    ? new ImplicitFeedbackAlternatingLeastSquaresSolver(numFeatures, lambda, alpha, itemY)
                    : 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() {
                        final List<Vector> featureVectors = Lists.newArrayList();
                        while (itemIDsFromUser.hasNext()) {
                            final long itemID = itemIDsFromUser.nextLong();
                            featureVectors.add(features.getItemFeatureColumn(itemIndex(itemID)));
                        }

                        final 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 (final InterruptedException e) {
                log.warn("Error when computing user features", e);
            }
        }

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

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

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

                        final 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 (final InterruptedException e) {
                log.warn("Error when computing item features", e);
            }
        }
    }

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

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

License:Apache License

@Override
protected void map(IntWritable userOrItemID, VectorWritable ratingsWritable, Context ctx)
        throws IOException, InterruptedException {
    ImplicitFeedbackAlternatingLeastSquaresSolver solver = getSharedInstance();
    uiOrmj.set(solver.solve(ratingsWritable.get()));
    ctx.write(userOrItemID, uiOrmj);//from   w w w. j  av  a2  s.co m
}

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());
    }/*w  w w.  j av a2s.c om*/

    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());
}

From source file:org.plista.kornakapi.core.optimizer.ErrorALSWRFactorizer.java

License:Apache License

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

    Double[] errors = new Double[numIterations];
    for (int iteration = 0; iteration < numIterations; iteration++) {
        LongPrimitiveIterator userIDsIterator = dataModel.getUserIDs();
        LongPrimitiveIterator itemIDsIterator = dataModel.getItemIDs();
        log.info("iteration {}", iteration);

        /* fix M - compute U */
        ExecutorService queue = createQueue();

        try {

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

            while (userIDsIterator.hasNext()) {
                final long userID = userIDsIterator.nextLong();
                if (usesImplicitFeedback) {
                    final PreferenceArray userPrefs = dataModel.getPreferencesFromUser(userID);
                    queue.execute(new Runnable() {
                        @Override
                        public void run() {

                            Vector userFeatures = implicitFeedbackSolver
                                    .solve(sparseUserRatingVector(userPrefs));
                            //userFeatures = userFeatures.divide(Math.sqrt(userFeatures.getLengthSquared()));
                            features.setFeatureColumnInU(userIndex(userID), userFeatures);

                        }
                    });

                } else {
                    final LongPrimitiveIterator itemIDsFromUser = dataModel.getItemIDsFromUser(userID)
                            .iterator();
                    final PreferenceArray userPrefs = dataModel.getPreferencesFromUser(userID);
                    queue.execute(new Runnable() {
                        @Override
                        public void run() {
                            List<Vector> featureVectors = Lists.newArrayList();
                            while (itemIDsFromUser.hasNext()) {
                                long itemID = itemIDsFromUser.nextLong();
                                featureVectors.add(features.getItemFeatureColumn(itemIndex(itemID)));
                            }
                            Vector userFeatures = 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();

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

                while (itemIDsIterator.hasNext()) {

                    final long itemID = itemIDsIterator.nextLong();
                    final PreferenceArray itemPrefs = dataModel.getPreferencesForItem(itemID);
                    queue.execute(new Runnable() {
                        @Override
                        public void run() {
                            Vector itemFeatures = implicitFeedbackSolver
                                    .solve(sparseItemRatingVector(itemPrefs));
                            //itemFeatures = itemFeatures.divide(Math.sqrt(itemFeatures.getLengthSquared()));
                            features.setFeatureColumnInM(itemIndex(itemID), itemFeatures);
                        }
                    });
                }
            } else {
                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 = Lists.newArrayList();
                            for (Preference pref : itemPrefs) {
                                long userID = pref.getUserID();
                                featureVectors.add(features.getUserFeatureColumn(userIndex(userID)));
                            }
                            Vector itemFeatures = 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);
            }
        }
        userIDsIterator = testModel.getUserIDs();
        double error = 0;
        while (userIDsIterator.hasNext()) {
            Long userID = userIDsIterator.next();
            PreferenceArray userPrefs = testModel.getPreferencesFromUser(userID);
            Vector userf = features.getUserFeatureColumn(userIndex(userID));
            long[] itemIDs = userPrefs.getIDs();
            int idx = 0;
            for (long itemID : itemIDs) {
                Vector itemf = features.getItemFeatureColumn(itemIndex(itemID));
                double pref = itemf.dot(userf);
                double realpref = userPrefs.getValue(idx);
                idx++;
                error = error + Math.abs(pref - realpref);
            }
        }
        errors[iteration] = error;

    }
    ErrorFactorization factorization = createErrorFactorization(features.getU(), features.getM(), errors);
    log.info("finished computation of the factorization...");
    return factorization;
}