@Override public UserIdealRelevanceModel<U, I> getModel(U user) { return (UserIdealRelevanceModel<U, I>) super.getModel(user); }
@Override protected UserIdealRelevanceModel<U, I> get(U user) { return new UserBinaryRelevanceModel(user); }
@Override protected UserRelevanceModel<U, I> get(U user) { return new UserSmo4RelevanceModel(user); }
/** * Returns a score for the recommendation list. * * @param recommendation recommendation list * @return score of the metric to the recommendation */ @Override public double evaluate(Recommendation<U, I> recommendation) { RelevanceModel.UserRelevanceModel<U, I> urm = relModel.getModel(recommendation.getUser()); List<Tuple2od<I>> items = recommendation.getItems(); int r = range(0, items.size()) .limit(cutoff) .filter(k -> urm.isRelevant(items.get(k).v1)) .findFirst().orElse(-1); if (r == -1) { return 0; } else { return 1 / (1.0 + r); } } }
@Override public void add(Recommendation<U, I> recommendation) { RelevanceModel.UserRelevanceModel<U, I> urm = rel.getModel(recommendation.getUser()); List<Tuple2od<I>> list = recommendation.getItems(); int rank = Math.min(cutoff, list.size()); double userNorm = IntStream.range(0, rank).mapToDouble(disc::disc).sum(); IntStream.range(0, rank).forEach(k -> { I i = list.get(k).v1; double d = disc.disc(k); double w = d * urm.gain(i) / userNorm; itemCount.addTo(i, d); itemWeight.addTo(i, w); }); freeNorm += userNorm; numUsers++; }
/** * Constructor. * * @param cutoff maximum length of the recommendation lists that is evaluated */ public Entropy(int cutoff) { super(cutoff, new NoDiscountModel(), new NoRelevanceModel<>()); } }
UserIdealRelevanceModel<U, I> userRelModel = relModel.getModel(recommendation.getUser()); int nRelItems = min(cutoff, userRelModel.getRelevantItems().size()); if (nRelItems == 0) { return 0.0; if (userRelModel.isRelevant(pair.v1)) { relCount++; ap += relCount / (double) rank;
/** * Returns a score for the recommendation list. * * @param recommendation recommendation list * @return score of the metric to the recommendation */ @Override public double evaluate(Recommendation<U, I> recommendation) { U user = recommendation.getUser(); IdealRelevanceModel.UserIdealRelevanceModel<U, I> userRelModel = relModel.getModel(user); int numberOfAllRelevant = relModel.getModel(user).getRelevantItems().size(); if (numberOfAllRelevant == 0) { return 0.0; } return recommendation.getItems().stream() .limit(cutoff) .map(Tuple2od::v1) .filter(userRelModel::isRelevant) .count() / (double) numberOfAllRelevant; } }
UserRelevanceModel<U, I> urm = relModel.getModel(recommendation.getUser()); if (urm.isRelevant(pair.v1)) { double gain = featureData.getItemFeatures(pair.v1).sequential() .map(Tuple2::v1)
/** * Returns a score for the recommendation list. * * @param recommendation recommendation list * @return score of the metric to the recommendation */ @Override public double evaluate(Recommendation<U, I> recommendation) { RelevanceModel.UserRelevanceModel<U, I> userRelModel = relModel.getModel(recommendation.getUser()); Set<F> subtopics = new HashSet<>(); int rank = 0; for (Tuple2od<I> iv : recommendation.getItems()) { if (userRelModel.isRelevant(iv.v1)) { subtopics.addAll(featureData.getItemFeatures(iv.v1) .map(Tuple2::v1) .collect(toList())); } rank++; if (rank >= cutoff) { break; } } return subtopics.size() / (double) featureData.numFeatures(); }
/** * Constructor. * * @param cutoff maximum length of the recommendation lists that is evaluated */ public GiniSimpsonIndex(int cutoff) { super(cutoff, new NoDiscountModel(), new NoRelevanceModel<>()); }
@Override public double evaluate(Recommendation<U, I> recommendation) { UserRelevanceModel<U, I> urm = relModel.getModel(recommendation.getUser()); return recommendation.getItems().stream() .limit(cutoff) .map(Tuple2od::v1) .filter(urm::isRelevant) .count() >= k ? 1.0 : 0.0; }
/** * Returns a score for the recommendation list. * * @param recommendation recommendation list * @return score of the metric to the recommendation */ @Override public double evaluate(Recommendation<U, I> recommendation) { RelevanceModel.UserRelevanceModel<U, I> userRelModel = relModel.getModel(recommendation.getUser()); BinomialModel<U, I, F>.UserBinomialModel prob = binomialModel.getModel(recommendation.getUser()); Object2IntOpenHashMap<F> count = new Object2IntOpenHashMap<>(); count.defaultReturnValue(0); int rank = 0; int nrel = 0; for (Tuple2od<I> iv : recommendation.getItems()) { if (userRelModel.isRelevant(iv.v1)) { featureData.getItemFeatures(iv.v1) .forEach(fv -> count.addTo(fv.v1, 1)); nrel++; } rank++; if (rank >= cutoff) { break; } } return getResultFromCount(prob, count, nrel, rank); }
public double evaluate(Recommendation<U, I> recommendation) { U u = recommendation.getUser(); RelevanceModel.UserRelevanceModel<U, I> userRelModel = relModel.getModel(u); ItemNovelty.UserItemNoveltyModel<U, I> uinm = novelty.getModel(u); nov += disc.disc(rank) * userRelModel.gain(iv.v1) * uinm.novelty(iv.v1); norm += disc.disc(rank); rank++;
/** * Constructor. * * @param cutoff maximum length of the recommendation lists that is evaluated * @param numItems total number of items in the catalog */ public GiniIndex(int cutoff, int numItems) { super(cutoff, new NoDiscountModel(), new NoRelevanceModel<>()); this.numItems = numItems; }
/** * Returns a score for the recommendation list. * * @param recommendation recommendation list * @return score of the metric to the recommendation */ @Override public double evaluate(Recommendation<U, I> recommendation) { UserRelevanceModel<U, I> userRelModel = relModel.getModel(recommendation.getUser()); return recommendation.getItems().stream() .limit(cutoff) .map(Tuple2od::v1) .filter(userRelModel::isRelevant) .count() / (double) cutoff; } }
@Override public double evaluate(Recommendation<U, I> recommendation) { RelevanceModel.UserRelevanceModel<U, I> userRelModel = relModel.getModel(recommendation.getUser()); BinomialModel<U, I, F>.UserBinomialModel prob = binomialModel.getModel(recommendation.getUser()); double cpr = 0.0; for (Tuple2od<I> iv : recommendation.getItems()) { if (userRelModel.isRelevant(iv.v1)) { featureData.getItemFeatures(iv.v1) .forEach(fv -> count.addTo(fv.v1, 1));
/** * Constructor. * * @param cutoff maximum length of the recommendation lists that is evaluated */ public IUD(int cutoff) { super(cutoff, new NoDiscountModel(), new NoRelevanceModel<>()); }
/** * Constructor. * * @param cutoff maximum size of the recommendation list that is evaluated * @param nSystems number of compared systems * @param otherUserRecommendations other systems recommendations */ public ISD(int cutoff, int nSystems, Function<U, List<List<I>>> otherUserRecommendations) { super(cutoff, new ISDCItemNovelty<>(nSystems, otherUserRecommendations, new NoDiscountModel()), new NoRelevanceModel<>(), new NoDiscountModel()); }