Example usage for com.google.common.collect Ordering greatestOf

List of usage examples for com.google.common.collect Ordering greatestOf

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.collect.*
  5. Ordering
  6. greatestOf

Introduction

In this page you can find the example usage for com.google.common.collect Ordering greatestOf.

Prototype

public <E extends T> List<E> greatestOf(Iterator<E> iterator, int k)

Source Link

Document

Returns the k greatest elements from the given iterator according to this ordering, in order from greatest to least.

Usage

From source file:com.twitter.common.collections.Multimaps.java

/**
 * Returns the set of keys associated with the largest values in the multimap.
 *
 * @param map The multimap to search./*w  w w . j  a  v  a2  s  . c o m*/
 * @param topValues Number of groupings to find the keys for.
 * @return The keys associated with the largest groups, of maximum size {@code topValues}.
 */
public static <K> Set<K> getLargestGroups(Multimap<K, ?> map, int topValues) {
    Ordering<Multiset.Entry<K>> groupOrdering = new Ordering<Multiset.Entry<K>>() {
        @Override
        public int compare(Multiset.Entry<K> entry1, Multiset.Entry<K> entry2) {
            return entry1.getCount() - entry2.getCount();
            // overflow-safe, since sizes are nonnegative
        }
    };
    Set<K> topKeys = Sets.newHashSetWithExpectedSize(topValues);
    for (Multiset.Entry<K> entry : groupOrdering.greatestOf(map.keys().entrySet(), topValues)) {
        topKeys.add(entry.getElement());
    }
    return topKeys;
}

From source file:com.xiaomi.linden.cluster.ResultMerger.java

private static LindenResult mergeGroupSearch(LindenSearchRequest lindenRequest, List<LindenResult> resultList) {
    LindenResult mergedResult = resultList.get(0);
    if (!mergedResult.isSetHits()) {
        mergedResult.setHits(new ArrayList<LindenHit>());
    }//from   ww  w . j a  v a 2  s  .  c o  m
    String groupField = lindenRequest.getGroupParam().getGroupField();
    int innerLimit = lindenRequest.getGroupParam().getGroupInnerLimit();
    //traverse LindenResults from shards
    for (int i = 1; i < resultList.size(); ++i) {
        LindenResult subResult = resultList.get(i);
        if (!subResult.isSetHits()) {
            continue;
        }
        mergedResult.totalHits += subResult.totalHits;
        mergedResult.totalGroups = Math.max(mergedResult.totalGroups, subResult.totalGroups);
        mergedResult.totalGroupHits += subResult.totalGroupHits;
        //traverse groups in waiting LindenResult
        for (LindenHit subGroup : subResult.getHits()) {
            String groupName = subGroup.getFields().get(groupField);
            boolean isFound = false;
            //find the group in the merged groupList
            for (int j = 0; j < mergedResult.getHitsSize(); ++j) {
                LindenHit mergedHit = mergedResult.getHits().get(j);
                if (mergedHit.getFields().get(groupField).equals(groupName)) {
                    Iterable<LindenHit> groupIterable = Iterables.mergeSorted(
                            ImmutableList.of(subGroup.getGroupHits(), mergedHit.getGroupHits()),
                            new LindenHitCmp(null));
                    List<LindenHit> hits = Lists.newArrayList(Iterables.limit(groupIterable, innerLimit));
                    if (mergedHit.getScore() < subGroup.getScore()) {
                        mergedHit = subGroup;
                    }
                    mergedHit.setGroupHits(hits);
                    mergedResult.getHits().set(j, mergedHit);
                    isFound = true;
                    break;
                }
            }
            if (!isFound) {
                mergedResult.getHits().add(subGroup);
            }
        }
    }
    //sort the group by score
    Ordering<LindenHit> ordering = new Ordering<LindenHit>() {
        @Override
        public int compare(@Nullable LindenHit left, @Nullable LindenHit right) {
            return Double.compare(left.getScore(), right.getScore());
        }
    };
    List<LindenHit> orderedHits = ordering.greatestOf(mergedResult.getHits(), mergedResult.getHitsSize()); //offset -> offset+size groups
    int from = lindenRequest.getOffset();
    int size = lindenRequest.getLength();
    if (from < orderedHits.size()) {
        List<LindenHit> subHits = orderedHits.subList(from, Math.min(from + size, orderedHits.size()));
        mergedResult.setHits(subHits);
    } else {
        mergedResult.setHits(new ArrayList<LindenHit>());
    }
    return mergedResult;
}

From source file:org.glowroot.local.ui.TransactionJsonService.java

private static List<String> getTopTimerNames(List<StackedPoint> stackedPoints, int topX) {
    MutableLongMap<String> timerTotals = new MutableLongMap<String>();
    for (StackedPoint stackedPoint : stackedPoints) {
        for (Entry<String, MutableLong> entry : stackedPoint.getStackedTimers().entrySet()) {
            timerTotals.add(entry.getKey(), entry.getValue().longValue());
        }/*from   w ww . jav a 2  s  .  c  o m*/
    }
    Ordering<Entry<String, MutableLong>> valueOrdering = Ordering.natural()
            .onResultOf(new Function<Entry<String, MutableLong>, Long>() {
                @Override
                public Long apply(@Nullable Entry<String, MutableLong> entry) {
                    checkNotNull(entry);
                    return entry.getValue().longValue();
                }
            });
    List<String> timerNames = Lists.newArrayList();
    @SuppressWarnings("assignment.type.incompatible")
    List<Entry<String, MutableLong>> topTimerTotals = valueOrdering.greatestOf(timerTotals.entrySet(), topX);
    for (Entry<String, MutableLong> entry : topTimerTotals) {
        timerNames.add(entry.getKey());
    }
    return timerNames;
}

From source file:org.grouplens.samantha.modeler.ranking.NDCGLoss.java

public double getMetric(int maxN, List<StochasticOracle> topN, double[] scores, double[] relevance) {
    double dcg = 0.0;
    for (int i = 0; i < maxN; i++) {
        StochasticOracle oracle = topN.get(i);
        relevance[i] = oracle.getLabel();
        dcg += (Math.pow(2.0, relevance[i]) - 1.0) / Math.log(2 + i);
    }//from  w w  w.  java2 s . com
    Ordering<StochasticOracle> ordering = RankingUtilities.stochasticOracleLabelOrdering();
    List<StochasticOracle> bestTop = ordering.greatestOf(topN, topN.size());
    double maxDcg = 0.0;
    for (int i = 0; i < maxN; i++) {
        StochasticOracle oracle = bestTop.get(i);
        maxDcg += (Math.pow(2.0, oracle.getLabel()) - 1.0) / Math.log(2 + i);
    }
    scores[maxN] = maxDcg;
    return dcg / maxDcg;
}

From source file:com.anhth12.lambda.app.serving.als.Because.java

@GET
@Path("{userID}/{itemID}")
@Produces({ MediaType.TEXT_PLAIN, CSVMessageBodyWriter.TEXT_CSV, MediaType.APPLICATION_JSON })
public List<IDValue> get(@PathParam("userID") String userID, @PathParam("itemID") String itemID,
        @DefaultValue("10") @QueryParam("howMany") int howMany,
        @DefaultValue("0") @QueryParam("offset") int offset) throws LambdaServingException {
    check(howMany > 0, "howMany must be positive");
    check(offset >= 0, "offset must be non-negative");

    ALSServingModel model = getALSServingModel();
    float[] itemVector = model.getItemVector(itemID);
    checkExists(itemVector != null, itemID);
    List<Pair<String, float[]>> knownItemVectors = model.getKnowItemVectorsForUser(userID);

    checkExists(knownItemVectors != null, itemID);

    Iterable<Pair<String, Double>> idSimilarities = Iterables.transform(knownItemVectors,
            new CosineSimilarityFunction(itemVector));

    Ordering<Pair<?, Double>> ordering = Ordering.from(PairComparators.<Double>bySecond());

    return toIDValueResponse(ordering.greatestOf(idSimilarities, howMany + offset), howMany, offset);
}

From source file:org.grouplens.samantha.server.ranker.PredictorBasedRanker.java

public RankedResult rank(RetrievedResult retrievedResult, RequestContext requestContext) {
    List<ObjectNode> entityList = retrievedResult.getEntityList();
    List<Prediction> predictions = predictor.predict(entityList, requestContext);
    int curLimit = limit;
    if (pageSize == 0 || limit > predictions.size()) {
        curLimit = predictions.size();/*from   w ww  .  j  av  a  2 s . c  o  m*/
    }
    Ordering<Prediction> ordering = RankerUtilities.scoredResultScoreOrdering();
    List<Prediction> candidates = ordering.greatestOf(predictions, offset + curLimit);
    List<Prediction> recs;
    if (candidates.size() < offset) {
        recs = new ArrayList<>();
    } else {
        recs = candidates.subList(offset, candidates.size());
    }
    List<ObjectNode> recEntities = new ArrayList<>(recs.size());
    for (Prediction pred : recs) {
        recEntities.add(pred.getEntity());
    }
    for (EntityExpander expander : entityExpanders) {
        expander.expand(recEntities, requestContext);
    }
    return new RankedResult(recs, offset, curLimit, predictions.size());
}

From source file:com.cloudera.oryx.app.serving.als.Because.java

@GET
@Path("{userID}/{itemID}")
@Produces({ MediaType.TEXT_PLAIN, CSVMessageBodyWriter.TEXT_CSV, MediaType.APPLICATION_JSON })
public List<IDValue> get(@PathParam("userID") String userID, @PathParam("itemID") String itemID,
        @DefaultValue("10") @QueryParam("howMany") int howMany,
        @DefaultValue("0") @QueryParam("offset") int offset) throws OryxServingException {

    check(howMany > 0, "howMany must be positive");
    check(offset >= 0, "offset must be non-negative");

    ALSServingModel model = getALSServingModel();
    float[] itemVector = model.getItemVector(itemID);
    checkExists(itemVector != null, itemID);
    List<Pair<String, float[]>> knownItemVectors = model.getKnownItemVectorsForUser(userID);
    checkExists(knownItemVectors != null, userID);

    Iterable<Pair<String, Double>> idSimilarities = Iterables.transform(knownItemVectors,
            new CosineSimilarityFunction(itemVector));

    Ordering<Pair<?, Double>> ordering = Ordering.from(PairComparators.<Double>bySecond());
    return toIDValueResponse(ordering.greatestOf(idSimilarities, howMany + offset), howMany, offset);
}

From source file:com.cloudera.oryx.ml.serving.als.Because.java

@GET
@Path("{userID}/{itemID}")
@Produces({ CSVMessageBodyWriter.TEXT_CSV, MediaType.APPLICATION_JSON })
public List<IDValue> get(@PathParam("userID") String userID, @PathParam("itemID") String itemID,
        @DefaultValue("10") @QueryParam("howMany") int howMany,
        @DefaultValue("0") @QueryParam("offset") int offset) throws OryxServingException {

    check(howMany > 0, "howMany must be positive");
    check(offset >= 0, "offset must be non-negative");

    ALSServingModel model = getALSServingModel();
    float[] itemVector = model.getItemVector(itemID);
    checkExists(itemVector != null, itemID);
    List<Pair<String, float[]>> knownItemVectors = model.getKnownItemVectorsForUser(userID);
    checkExists(knownItemVectors != null, userID);

    Iterable<Pair<String, Double>> idSimilarities = Iterables.transform(knownItemVectors,
            new CosineSimilarityFunction(itemVector));

    Ordering<Pair<?, Double>> ordering = Ordering.from(PairComparators.<Double>bySecond());
    return toIDValueResponse(ordering.greatestOf(idSimilarities, howMany + offset), howMany, offset);
}

From source file:org.grouplens.samantha.server.ranker.PercentileBlendingRanker.java

public RankedResult rank(RetrievedResult retrievedResult, RequestContext requestContext) {
    List<ObjectNode> entityList = retrievedResult.getEntityList();
    for (EntityExpander expander : entityExpanders) {
        entityList = expander.expand(entityList, requestContext);
    }/* w  ww . jav  a 2s .  c  o  m*/
    int listSize = entityList.size();
    if (listSize > 0) {
        for (Object2DoubleMap.Entry<String> entry : defaults.object2DoubleEntrySet()) {
            String key = entry.getKey();
            entityList.sort(SortingUtilities.jsonFieldComparator(key));
            for (int i = 0; i < entityList.size(); i++) {
                entityList.get(i).put(key + "Percentile", (double) i / listSize);
            }
        }
    }
    int curLimit = limit;
    if (pageSize == 0 || limit > listSize) {
        curLimit = entityList.size();
    }
    List<Prediction> scoredList = new ArrayList<>(entityList.size());
    for (ObjectNode entity : entityList) {
        double score = 0.0;
        for (Object2DoubleMap.Entry<String> entry : defaults.object2DoubleEntrySet()) {
            String key = entry.getKey();
            score += (entry.getDoubleValue() * entity.get(key + "Percentile").asDouble());
        }
        scoredList.add(new Prediction(entity, null, score));
    }
    Ordering<Prediction> ordering = RankerUtilities.scoredResultScoreOrdering();
    List<Prediction> candidates = ordering.greatestOf(scoredList, offset + curLimit);
    List<Prediction> recs;
    if (candidates.size() < offset) {
        recs = new ArrayList<>();
    } else {
        recs = candidates.subList(offset, candidates.size());
    }
    return new RankedResult(recs, offset, curLimit, scoredList.size());
}

From source file:org.grouplens.samantha.modeler.ranking.AbstractLambdaLoss.java

public List<StochasticOracle> wrapOracle(List<StochasticOracle> oracles) {
    if (oracles.size() <= 1) {
        return new ArrayList<>();
    }/*from w w w . j a v a 2  s.co m*/
    int maxN = N;
    if (maxN == 0 || maxN > oracles.size()) {
        maxN = oracles.size();
    }
    List<StochasticOracle> newOracles = new ArrayList<>(maxN);
    Ordering<StochasticOracle> ordering = RankingUtilities.stochasticOracleOrdering();
    List<StochasticOracle> topN = ordering.greatestOf(oracles, maxN);
    double[] scores = new double[maxN + 1];
    double[] relevance = new double[maxN];
    double metric = getMetric(maxN, topN, scores, relevance);
    double[] lambdas = new double[maxN];
    for (int i = 0; i < maxN; i++) {
        for (int j = i + 1; j < maxN; j++) {
            if (relevance[i] != relevance[j]) {
                StochasticOracle highOracle = topN.get(i);
                StochasticOracle lowOracle = topN.get(j);
                double diff = (highOracle.getModelOutput() - lowOracle.getModelOutput());
                double ijCoef = -sigma / (1.0 + Math.exp(sigma * diff));
                double jiCoef = -sigma / (1.0 + Math.exp(-sigma * diff));
                double delta = Math.abs(getDelta(i, j, scores, relevance));
                if (relevance[i] > relevance[j]) {
                    lambdas[i] += ijCoef * delta;
                    lambdas[j] -= jiCoef * delta;
                } else {
                    lambdas[i] -= ijCoef * delta;
                    lambdas[j] += jiCoef * delta;
                }
            }
        }
    }
    double objVal = -metric / maxN;
    for (int i = 0; i < maxN; i++) {
        StochasticOracle oracle = topN.get(i);
        double weight = oracle.getWeight();
        oracle.setObjVal(objVal * weight);
        oracle.setGradient(lambdas[i] * weight);
        newOracles.add(oracle);
    }
    return newOracles;
}