示例#1
0
 public static final synchronized <K, V extends Comparable<? super V>>
     Map<K, V> sortDescendingByValue(final Map<K, V> map) {
   Map<K, V> result = new LinkedHashMap<>();
   Stream<Map.Entry<K, V>> stream = map.entrySet().stream();
   stream
       .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
       .forEach(e -> result.put(e.getKey(), e.getValue()));
   return result;
 }
  @Override
  public void annotate(Blackboard blackboard, DocumentComponent component) {

    // get the grams and order them by score
    Collection<Gram> grams = blackboard.getKeyphrases();
    Map<Keyphrase, Double> scoredGrams = new HashMap<>();

    for (Gram g : grams) {
      Keyphrase k = (Keyphrase) g;
      scoredGrams.put(k, k.getFeature(GenericEvaluatorAnnotator.SCORE));
    }

    List<Map.Entry<Keyphrase, Double>> gramsToTrash =
        scoredGrams
            .entrySet()
            .stream()
            .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
            .collect(Collectors.toList());

    // now the have the gram ordered by score.
    // we want to keep at least the first 5%; then, we look for the maximum
    // steep in score in the following 20%, and we discard everything after
    // that remains.

    double bestRange = Math.ceil((gramsToTrash.size() * 5.0) / 100.0);
    double steepRange = Math.ceil((gramsToTrash.size() * 25.0) / 100.0);

    // keep the first 5%
    for (int i = 0; i < bestRange; i++) {
      gramsToTrash.remove(0);
    }

    double maxSteep = Double.MIN_VALUE;
    int maxSteepIndex = Integer.MIN_VALUE;

    // search for the maximum steep in the next 15%
    for (int i = 0; i < steepRange - 1; i++) {

      double steep = (gramsToTrash.get(i).getValue() - gramsToTrash.get(i + 1).getValue());

      if (steep > maxSteep) {
        maxSteep = steep;
        maxSteepIndex = i;
      }
    }

    // keep the grams before the steep
    for (int i = 0; i < maxSteepIndex; i++) {
      gramsToTrash.remove(0);
    }

    // now remove the remaining grams from the blackboard.
    for (Map.Entry<Keyphrase, Double> e : gramsToTrash) blackboard.removeKeyphrase(e.getKey());
  }
示例#3
0
  @Override
  public void run() {

    while (true) {
      Event e = events.poll();
      if (e != null && EventType.SORT.equals(e.getType())) {
        long start = System.currentTimeMillis();
        if (!map.isEmpty()) {
          map.entrySet().stream().sorted(Map.Entry.<String, Integer>comparingByValue());
        }
        long finish = System.currentTimeMillis();
        e.setProcessingTime(finish - start);
        e.setStatus(EventStatus.PROCESSED);
      }
    }
  }
 private List<String> packImports() {
   return mapSimpleNames
       .entrySet()
       .stream()
       .filter(
           ent ->
               // exclude the current class or one of the nested ones
               // empty, java.lang and the current packages
               !setNotImportedNames.contains(ent.getKey())
                   && !ent.getValue().isEmpty()
                   && !JAVA_LANG_PACKAGE.equals(ent.getValue())
                   && !ent.getValue().equals(currentPackagePoint))
       .sorted(
           Map.Entry.<String, String>comparingByValue().thenComparing(Map.Entry.comparingByKey()))
       .map(ent -> ent.getValue() + "." + ent.getKey())
       .collect(Collectors.toList());
 }
示例#5
0
  public static Map<String, Integer> freq(String safeLyrics) {
    Map<String, Integer> freq = new HashMap<>();

    Matcher matcher = tokenizer.matcher(safeLyrics);

    // Create a map of the frequency
    while (matcher.find()) {
      String word = matcher.group().toLowerCase();
      freq.put(word, freq.getOrDefault(word, 0) + 1);
    }

    // Sort the map by descending value
    Map<String, Integer> sortedMap =
        freq.entrySet()
            .stream()
            .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
            .collect(
                Collectors.toMap(
                    Entry::getKey, Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));

    return sortedMap;
  }
示例#6
0
  private int classify(List<Classifier> classifiers, Instance instance) {

    List<Double> predictedClasses =
        classifiers
            .stream()
            .map(
                classifier -> {
                  try {
                    return classifier.classifyInstance(instance);
                  } catch (Exception e) {
                    return -1.0;
                  }
                })
            .collect(Collectors.toList());

    System.out.println("Resultados de clasificar muestra:");
    System.out.println(predictedClasses);

    Map<Double, Long> predictedClassOcurrencesMap =
        predictedClasses
            .stream()
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

    System.out.println("Mapa de ocurrencias:");
    System.out.println(predictedClassOcurrencesMap);

    Double predictedClass =
        predictedClassOcurrencesMap
            .entrySet()
            .stream()
            .max(Map.Entry.comparingByValue())
            .get()
            .getKey();

    System.out.println("Resultado final:");
    System.out.println(predictedClass);

    return predictedClass.intValue();
  }