com.carrotsearch.hppc.IntFloatHashMap Java Examples

public BoostedComp(IntIntHashMap boostedDocs, ScoreDoc[] scoreDocs, float maxScore) {
    this.boostedMap = new IntFloatHashMap(boostedDocs.size()*2);

    for(int i=0; i<scoreDocs.length; i++) {
        if(boostedDocs.containsKey(scoreDocs[i].doc)) {
            boostedMap.put(scoreDocs[i].doc, maxScore+boostedDocs.get(scoreDocs[i].doc));
        } else {
            break;
        }
    }
}
 

public BoostedComp(IntIntHashMap boostedDocs, ScoreDoc[] scoreDocs, float maxScore) {
  this.boostedMap = new IntFloatHashMap(boostedDocs.size()*2);

  for(int i=0; i<scoreDocs.length; i++) {
    final int idx;
    if((idx = boostedDocs.indexOf(scoreDocs[i].doc)) >= 0) {
      boostedMap.put(scoreDocs[i].doc, maxScore+boostedDocs.indexGet(idx));
    } else {
      break;
    }
  }
}
 

/**
 * Create map with expected max value of key.
 * Although the map will automatically do resizing to be able to hold key {@code >= expectedKeyMax}.
 * But putting key much larger than {@code expectedKeyMax} is discourage since it can leads to use LOT OF memory.
 */
public IntFloatDynamicMap(int expectedKeyMax, float emptyValue) {
  this.threshold = threshold(expectedKeyMax);
  this.maxSize = expectedKeyMax;
  this.emptyValue = emptyValue;
  if (useArrayBased(expectedKeyMax)) {
    upgradeToArray();
  } else {
    this.hashMap = new IntFloatHashMap(mapExpectedElements(expectedKeyMax));
  }
}
 

@Override
public Score fit(final TimeSeries[] trainSamples) {
  // generate test train/split for cross-validation
  generateIndices(trainSamples);

  Score bestScore = null;
  int bestCorrectTraining = 0;

  int minWindowLength = 10;
  int maxWindowLength = getMax(trainSamples, MAX_WINDOW_LENGTH);

  // equi-distance sampling of windows
  ArrayList<Integer> windows = new ArrayList<>();
  double count = Math.sqrt(maxWindowLength);
  double distance = ((maxWindowLength - minWindowLength) / count);
  for (int c = minWindowLength; c <= maxWindowLength; c += distance) {
    windows.add(c);
  }

  for (boolean normMean : NORMALIZATION) {
    // train the shotgun models for different window lengths
    Ensemble<BossVSModel<IntFloatHashMap>> model = fitEnsemble(
            windows.toArray(new Integer[]{}), normMean, trainSamples);
    Double[] labels = predict(model, trainSamples);
    Predictions pred = evalLabels(trainSamples, labels);

    if (bestCorrectTraining <= pred.correct.get()) {
      bestCorrectTraining = pred.correct.get();
      bestScore = model.getHighestScoringModel().score;
      bestScore.training = pred.correct.get();
      this.model = model;
    }
  }

  // return score
  return bestScore;
}
 

protected void initMatrix(
    final ObjectObjectHashMap<Double, IntFloatHashMap> matrix,
    final Set<Double> uniqueLabels,
    final BagOfPattern[] bag) {
  for (Double label : uniqueLabels) {
    IntFloatHashMap stat = matrix.get(label);
    if (stat == null) {
      matrix.put(label, new IntFloatHashMap(bag[0].bag.size() * bag.length));
    } else {
      stat.clear();
    }
  }
}
 

public ObjectObjectHashMap<Double, IntFloatHashMap> createTfIdf(
    final BagOfPattern[] bagOfPatterns,
    final Set<Double> uniqueLabels) {
  int[] sampleIndices = createIndices(bagOfPatterns.length);
  return createTfIdf(bagOfPatterns, sampleIndices, uniqueLabels);
}