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:org.grouplens.samantha.server.ranker.FieldBlendingRanker.java

public RankedResult rank(RetrievedResult retrievedResult, RequestContext requestContext) {
    List<ObjectNode> entityList = retrievedResult.getEntityList();
    for (EntityExpander expander : entityExpanders) {
        entityList = expander.expand(entityList, requestContext);
    }//from w  w w .j  a v a 2s .  co  m
    int curLimit = limit;
    if (pageSize == 0 || limit > entityList.size()) {
        curLimit = entityList.size();
    }
    Object2DoubleMap<String> field2min = new Object2DoubleOpenHashMap<>(defaults.size());
    Object2DoubleMap<String> field2max = new Object2DoubleOpenHashMap<>(defaults.size());
    for (Object2DoubleMap.Entry<String> entry : defaults.object2DoubleEntrySet()) {
        String key = entry.getKey();
        for (JsonNode entity : entityList) {
            if (entity.has(key)) {
                double curVal = entity.get(key).asDouble();
                double curMin = field2min.getOrDefault(key, Double.MAX_VALUE);
                double curMax = field2max.getOrDefault(key, Double.MIN_VALUE);
                if (curMin > curVal) {
                    field2min.put(key, curVal);
                }
                if (curMax < curVal) {
                    field2max.put(key, curVal);
                }
            }
        }
    }
    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();
            if (entity.has(key)) {
                double min = field2min.getDouble(key);
                double max = field2max.getDouble(key);
                double val = (min == max) ? 0.0 : (entity.get(key).asDouble() - min) / (max - min);
                score += (entry.getDoubleValue() * val);
            }
        }
        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.server.evaluator.metric.NDCG.java

public void add(List<ObjectNode> groundTruth, List<Prediction> recommendations) {
    Object2DoubleMap<String> releItems = new Object2DoubleOpenHashMap<>();
    for (JsonNode entity : groundTruth) {
        String item = FeatureExtractorUtilities.composeConcatenatedKey(entity, config.itemKeys);
        releItems.put(item, entity.get(config.relevanceKey).asDouble());
    }//from   w w  w.  ja  v a  2s .  c o m
    int maxN = 0;
    for (Integer n : config.N) {
        if (n > maxN) {
            maxN = n;
        }
        if (recommendations.size() < n) {
            Logger.error("The number of recommendations({}) is less than the indicated NDCG N({})",
                    recommendations.size(), n);
        }
    }
    double[] dcg = new double[config.N.size()];
    for (int i = 0; i < recommendations.size(); i++) {
        int rank = i + 1;
        String recItem = FeatureExtractorUtilities.composeConcatenatedKey(recommendations.get(i).getEntity(),
                config.itemKeys);
        if (releItems.containsKey(recItem)) {
            for (int j = 0; j < config.N.size(); j++) {
                int n = config.N.get(j);
                if (rank <= n) {
                    dcg[j] += (Math.pow(2.0, releItems.getDouble(recItem)) / Math.log(1.0 + rank));
                }
            }
        }
        if (rank > maxN) {
            break;
        }
    }
    double[] maxDcg = new double[config.N.size()];
    if (groundTruth.size() <= maxN) {
        maxN = groundTruth.size();
    }
    Ordering<ObjectNode> ordering = RetrieverUtilities.jsonFieldOrdering(config.relevanceKey);
    List<ObjectNode> topN = ordering.greatestOf(groundTruth, maxN);
    for (int i = 0; i < topN.size(); i++) {
        int rank = i + 1;
        double relevance = topN.get(i).get(config.relevanceKey).asDouble();
        if (relevance > 0.0) {
            for (int j = 0; j < config.N.size(); j++) {
                int n = config.N.get(j);
                if (rank <= n) {
                    maxDcg[j] += (Math.pow(2.0, relevance) / Math.log(1.0 + rank));
                }
            }
        } else {
            break;
        }
    }
    for (int i = 0; i < config.N.size(); i++) {
        DCG.set(i, DCG.getDouble(i) + dcg[i] / maxDcg[i]);
    }
    cnt += 1;
}

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

public RankedResult rank(RetrievedResult retrievedResult, RequestContext requestContext) {
    List<ObjectNode> entityList = retrievedResult.getEntityList();
    int curLimit = limit;
    if (pageSize == 0 || limit > entityList.size()) {
        curLimit = entityList.size();/*from   w  ww  .  j  ava  2  s .co m*/
    }
    List<Prediction> scoredList = new ArrayList<>(entityList.size());
    for (ObjectNode entity : entityList) {
        scoredList.add(new Prediction(entity, null, 0.0));
    }
    List<Prediction> candidates;
    if (whetherOrder) {
        Ordering<Prediction> ordering = RankerUtilities.scoredResultFieldOrdering(orderField);
        if (ascending) {
            candidates = ordering.leastOf(scoredList, offset + curLimit);
        } else {
            candidates = ordering.greatestOf(scoredList, offset + curLimit);
        }
    } else {
        candidates = scoredList;
    }
    List<Prediction> recs;
    if (offset >= candidates.size()) {
        recs = new ArrayList<>();
    } else {
        recs = candidates.subList(offset, curLimit);
    }
    return new RankedResult(recs, offset, curLimit, retrievedResult.getMaxHits());
}

From source file:org.lenskit.basic.TopNItemRecommender.java

@Nonnull
private ResultList getTopNResults(int n, Iterable<Result> scores) {
    Ordering<Result> ord = Results.scoreOrder();
    List<Result> topN;
    if (n < 0) {
        topN = ord.reverse().immutableSortedCopy(scores);
    } else {/*from  w w w . ja v  a2 s  .  c o m*/
        topN = ord.greatestOf(scores, n);
    }
    return Results.newResultList(topN);
}

From source file:org.grouplens.samantha.modeler.knn.FeatureKnnModel.java

private List<double[]> getNeighbors(int curIndex, IntList svdIndices, SVDFeature svdFeature) {
    List<double[]> raw = new ArrayList<>(svdIndices.size());
    for (int target : svdIndices) {
        if (target != curIndex) {
            double[] pair = new double[2];
            pair[0] = target;/*from  w w  w  . j ava2s .  c  o m*/
            pair[1] = svdFeature.getVectorVarByNameIndex(SVDFeatureKey.FACTORS.get(), target)
                    .cosine(svdFeature.getVectorVarByNameIndex(SVDFeatureKey.FACTORS.get(), curIndex));
            raw.add(pair);
        }
    }
    Ordering<double[]> pairDoubleOrdering = SortingUtilities.pairDoubleSecondOrdering();
    List<double[]> neighbors;
    if (reverse) {
        neighbors = pairDoubleOrdering.leastOf(raw, numNeighbors);
    } else {
        neighbors = pairDoubleOrdering.greatestOf(raw, numNeighbors);
    }
    return neighbors;
}

From source file:co.cask.tigon.analytics.Analytics.java

@Tick(unit = TimeUnit.SECONDS, delay = 60)
public void logTopTweets() throws InterruptedException {
    if (hashtagCounts.isEmpty()) {
        return;/*  ww  w.j a va 2 s .  c om*/
    }

    Ordering<Map.Entry<String, Integer>> entryOrdering = Ordering.natural()
            .onResultOf(new Function<Map.Entry<String, Integer>, Integer>() {
                public Integer apply(Map.Entry<String, Integer> entry) {
                    return entry.getValue();
                }
            });

    List<Map.Entry<String, Integer>> topHashtags = entryOrdering.greatestOf(hashtagCounts.entrySet(), 10);
    hashtagCounts.clear();
    LOG.info("Top hashtags in the last minute : " + topHashtags);
}

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

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

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

private static void mergeFacet(final LindenSearchRequest lindenRequest, final List<LindenResult> resultList,
        LindenResult mergedResult) {/*from  ww w  . j a  va 2s .co m*/
    if (resultList.size() == 1) {
        mergedResult.setFacetResults(resultList.get(0).getFacetResults());
        mergedResult.setAggregationResults(resultList.get(0).getAggregationResults());
        return;
    }
    Ordering<LindenLabelAndValue> labelAndValueOrdering = new Ordering<LindenLabelAndValue>() {
        @Override
        public int compare(@Nullable LindenLabelAndValue lv1, @Nullable LindenLabelAndValue lv2) {
            int cmp = Integer.compare(lv1.getValue(), lv2.getValue());
            if (cmp != 0) {
                return cmp;
            }
            return lv2.getLabel().compareTo(lv1.getLabel());
        }
    };

    // merge browse result
    for (int i = 0; i < lindenRequest.getFacet().getFacetParamsSize(); ++i) {
        LindenFacetResult mergedFacetResult = new LindenFacetResult();
        mergedFacetResult.setDim(lindenRequest.getFacet().getFacetParams().get(i).facetDimAndPath.dim);
        mergedFacetResult.setPath(lindenRequest.getFacet().getFacetParams().get(i).facetDimAndPath.path);
        Map<String, Integer> labelValueMap = new HashMap<>();
        for (int j = 0; j < resultList.size(); ++j) {
            if (resultList.get(j).getFacetResults() == null) {
                continue;
            }
            LindenFacetResult lindenFacetResult = resultList.get(j).getFacetResults().get(i);
            if (lindenFacetResult == null) {
                continue;
            }
            mergedFacetResult.setValue(mergedFacetResult.getValue() + lindenFacetResult.getValue());
            if (lindenFacetResult.getChildCount() > mergedFacetResult.getChildCount()) {
                mergedFacetResult.setChildCount(lindenFacetResult.getChildCount());
            }
            for (int k = 0; k < lindenFacetResult.getLabelValuesSize(); ++k) {
                String label = lindenFacetResult.getLabelValues().get(k).getLabel();
                int previous = labelValueMap.containsKey(label) ? labelValueMap.get(label) : 0;
                labelValueMap.put(label, previous + lindenFacetResult.getLabelValues().get(k).getValue());
            }
        }
        if (labelValueMap.size() > 0) {
            List<LindenLabelAndValue> labelAndValues = new ArrayList<>();
            Set<Map.Entry<String, Integer>> entrySet = labelValueMap.entrySet();
            for (Iterator<Map.Entry<String, Integer>> it = entrySet.iterator(); it.hasNext();) {
                Map.Entry<String, Integer> entry = it.next();
                labelAndValues.add(new LindenLabelAndValue(entry.getKey(), entry.getValue()));
            }
            if (labelAndValues.size() > mergedFacetResult.getChildCount()) {
                mergedFacetResult.setChildCount(labelAndValues.size());
            }
            List<LindenLabelAndValue> topLabelAndValues = labelAndValueOrdering.greatestOf(labelAndValues,
                    lindenRequest.getFacet().getFacetParams().get(i).getTopN());
            mergedFacetResult.setLabelValues(topLabelAndValues);
        }
        mergedResult.addToFacetResults(mergedFacetResult);
    }

    // merge aggregation result
    for (int i = 0; i < lindenRequest.getFacet().getAggregationsSize(); ++i) {
        AggregationResult mergedAggregationResult = new AggregationResult();
        mergedAggregationResult.setField(lindenRequest.getFacet().getAggregations().get(i).getField());
        List<LindenLabelAndValue> lindenLabelAndValues = new ArrayList<>();
        for (int j = 0; j < lindenRequest.getFacet().getAggregations().get(i).getBucketsSize(); ++j) {
            LindenLabelAndValue lindenLabelAndValue = new LindenLabelAndValue();
            lindenLabelAndValue.setLabel(
                    resultList.get(0).getAggregationResults().get(i).getLabelValues().get(j).getLabel());
            int value = 0;
            for (int k = 0; k < resultList.size(); ++k) {
                value += resultList.get(k).getAggregationResults().get(i).getLabelValues().get(j).getValue();
            }
            lindenLabelAndValue.setValue(value);
            lindenLabelAndValues.add(lindenLabelAndValue);
        }
        mergedAggregationResult.setLabelValues(lindenLabelAndValues);
        mergedResult.addToAggregationResults(mergedAggregationResult);
    }
}