it.unimi.dsi.fastutil.ints.Int2DoubleMap Java Examples

@Override
public FastRecommendation getRecommendation(int uidx, int maxLength, IntPredicate filter) {
    if (uidx == -1) {
        return new FastRecommendation(uidx, new ArrayList<>(0));
    }

    Int2DoubleMap scoresMap = getScoresMap(uidx);

    final IntDoubleTopN topN = new IntDoubleTopN(min(maxLength, scoresMap.size()));
    scoresMap.int2DoubleEntrySet().forEach(e -> {
        int iidx = e.getIntKey();
        double score = e.getDoubleValue();
        if (filter.test(iidx)) {
            topN.add(iidx, score);
        }
    });

    topN.sort();

    List<Tuple2id> items = topN.reverseStream()
            .collect(toList());

    return new FastRecommendation(uidx, items);
}
 

private Int2DoubleMap getProductMap(int uidx) {
    Int2DoubleOpenHashMap productMap = new Int2DoubleOpenHashMap();
    productMap.defaultReturnValue(0.0);

    if (data.useIteratorsPreferentially()) {
        IntIterator iidxs = data.getUidxIidxs(uidx);
        DoubleIterator ivs = data.getUidxVs(uidx);
        while (iidxs.hasNext()) {
            int iidx = iidxs.nextInt();
            double iv = ivs.nextDouble();
            IntIterator vidxs = data.getIidxUidxs(iidx);
            DoubleIterator vvs = data.getIidxVs(iidx);
            while (vidxs.hasNext()) {
                productMap.addTo(vidxs.nextInt(), iv * vvs.nextDouble());
            }
        }
    } else {
        data.getUidxPreferences(uidx)
                .forEach(ip -> data.getIidxPreferences(ip.v1)
                        .forEach(up -> productMap.addTo(up.v1, ip.v2 * up.v2)));
    }

    productMap.remove(uidx);

    return productMap;
}
 

@Test
public void testValues() {
	Int2DoubleMap map = new Int2DoubleOpenHashMap();
	map.put(1, 0.5);
	map.put(2, 0.4);
	Int2DoubleRow row = createRow(map, 3);
	assertThat(row.values()).contains(0.5, 0.4);
}
 

/**
 * Tests the local (user) probability method with alpha = 0.0.
 */
@Test
public void testLocalModelAlpha00() {
    Int2DoubleMap expectedLocalP = new Int2DoubleOpenHashMap();
    expectedLocalP.put(1, 0.8);
    expectedLocalP.put(2, 0.2);
    
    checkLocalModel(0.0, expectedLocalP);
}
 

/**
 * Tests the global probability method (BinomialModel::p).
 */
@Test
public void testGlobalModel() {
    Int2DoubleMap expectedGlobalP = new Int2DoubleOpenHashMap();
    expectedGlobalP.put(1, 0.8);
    expectedGlobalP.put(2, 0.2);
    
    BinomialModel<Integer, Integer, Integer> bm = new BinomialModel<>(false, Stream.empty(), preferences, featureData, 0.0);
    
    assertEquals(expectedGlobalP.keySet(), bm.getFeatures());
    expectedGlobalP.forEach((f, p) -> assertEquals(p, bm.p(f), 0.0001));
}
 

private RealVector extractDenseVector(int dim, LearningInstance instance) {
    Int2DoubleMap features = ((StandardLearningInstance) instance).getFeatures();
    RealVector x = MatrixUtils.createRealVector(new double[dim]);
    for (Int2DoubleMap.Entry entry : features.int2DoubleEntrySet()) {
        x.setEntry(entry.getIntKey(), entry.getDoubleValue());
    }
    return x;
}
 

public LabeledPoint getLabeledPoint() {
    Int2DoubleMap features = instance.getFeatures();
    float[] values = new float[features.size()];
    double[] froms = features.values().toDoubleArray();
    for (int i=0; i<froms.length; i++) {
        values[i] = (float) froms[i];
    }
    return new LabeledPoint((float) instance.getLabel(), features.keySet().toIntArray(), values);
}
 

/**
 * Tests the local (user) probability method with alpha = 0.5.
 */
@Test
public void testLocalModelAlpha05() {
    Int2DoubleMap expectedLocalP = new Int2DoubleOpenHashMap();
    expectedLocalP.put(1, 0.9);
    expectedLocalP.put(2, 0.1);
    
    checkLocalModel(0.5, expectedLocalP);
}
 

/**
 * Tests the local (user) probability method with alpha = 1.0.
 */
@Test
public void testLocalModelAlpha10() {
    Int2DoubleMap expectedLocalP = new Int2DoubleOpenHashMap();
    expectedLocalP.put(1, 1.0);
    
    checkLocalModel(1.0, expectedLocalP);
}
 

public LearningInstance featurize(JsonNode entity, boolean update) {
    Map<String, List<Feature>> feaMap = new HashMap<>();
    for (FeatureExtractor extractor : featureExtractors) {
        feaMap.putAll(extractor.extract(entity, update,
                indexSpace));
    }
    Int2DoubleMap feas = new Int2DoubleOpenHashMap();
    for (String fea : features) {
        if (feaMap.containsKey(fea)) {
            for (Feature feature : feaMap.get(fea)) {
                feas.put(feature.getIndex(), feature.getValue());
            }
        }
    }
    double label = StandardLearningInstance.defaultLabel;
    double weight = StandardLearningInstance.defaultWeight;
    if (entity.has(labelName)) {
        label = entity.get(labelName).asDouble();
    } else if (feaMap.containsKey(labelName)) {
        label = feaMap.get(labelName).get(0).getIndex();
    }
    if (entity.has(weightName)) {
        weight = entity.get(weightName).asDouble();
    } else if (feaMap.containsKey(weightName)) {
        weight = feaMap.get(weightName).get(0).getValue();
    }
    String group = null;
    if (groupKeys != null && groupKeys.size() > 0) {
        group = FeatureExtractorUtilities.composeConcatenatedKey(entity, groupKeys);
    }
    return new StandardLearningInstance(feas, label, weight, group);
}
 

private void checkLocalModel(double alpha, Int2DoubleMap expectedLocalP) {
    BinomialModel<Integer, Integer, Integer> bm = new BinomialModel<>(false, Stream.empty(), preferences, featureData, alpha);
    BinomialModel<Integer, Integer, Integer>.UserBinomialModel ubm = bm.getModel(1);
    
    assertEquals(expectedLocalP.keySet(), ubm.getFeatures());
    expectedLocalP.forEach((f, p) -> assertEquals(p, ubm.p(f), 0.0001));
}
 

@Test
public void testGetOrDefault() {
	Int2DoubleMap map = new Int2DoubleOpenHashMap();
	map.put(1, 0.5);
	map.put(2, 0.4);
	Int2DoubleRow row = createRow(map, 3);
	assertThat(row.getOrDefault(0)).isEqualTo(0.0);
	assertThat(row.getOrDefault(1)).isEqualTo(0.5);
	assertThat(row.getOrDefault(2)).isEqualTo(0.4);
}
 

@Test
public void testAsMap() {
	Int2DoubleMap map = new Int2DoubleOpenHashMap();
	map.put(1, 0.5);
	map.put(2, 0.4);
	Int2DoubleRow row = createRow(map, 3);
	assertThat(row.asMap()).hasSize(2);
	assertThat(row.asMap()).containsEntry(1, 0.5);
	assertThat(row.asMap()).containsEntry(2, 0.4);
}
 

/**
 * Returns a map of item-score pairs.
 *
 * @param uidx index of the user whose scores are predicted
 * @return a map of item-score pairs
 */
@Override
public Int2DoubleMap getScoresMap(int uidx) {
    Int2DoubleOpenHashMap scoresMap = new Int2DoubleOpenHashMap();
    scoresMap.defaultReturnValue(0.0);
    data.getUidxPreferences(uidx)
            .forEach(jp -> neighborhood.getNeighbors(jp.v1)
                    .forEach(is -> {
                        double w = pow(is.v2, q);
                        scoresMap.addTo(is.v1, w * jp.v2);
                    }));

    return scoresMap;
}
 

@Override
protected Int2DoubleRow createRow(Int2DoubleMap map, int size) {
	double[] row = new double[size];
	for (Entry entry : map.int2DoubleEntrySet()) {
		int columnKey = entry.getIntKey();
		row[columnKey] = entry.getDoubleValue();
	}
	return new Int2DoubleArrayRow(row);
}
 

/**
 * Returns a map of item-score pairs.
 *
 * @param uidx index of the user whose scores are predicted
 * @return a map of item-score pairs
 */
@Override
public Int2DoubleMap getScoresMap(int uidx) {
    Int2DoubleOpenHashMap scoresMap = new Int2DoubleOpenHashMap();
    scoresMap.defaultReturnValue(0.0);
    neighborhood.getNeighbors(uidx).forEach(vs -> {
        double w = pow(vs.v2, q);
        data.getUidxPreferences(vs.v1).forEach(iv -> {
            double p = w * iv.v2;
            scoresMap.addTo(iv.v1, p);
        });
    });

    return scoresMap;
}
 

/**
 * Returns a map of item-score pairs.
 *
 * @param uidx index of the user whose scores are predicted
 * @return a map of item-score pairs
 */
@Override
public Int2DoubleMap getScoresMap(int uidx) {
    Int2DoubleOpenHashMap scoresMap = new Int2DoubleOpenHashMap();
    for (Entry<FastRankingRecommender<U, I>, Double> rw : recommenders) {
        double w = rw.getValue();
        rw.getKey().getScoresMap(uidx).int2DoubleEntrySet()
                .forEach(e -> scoresMap.addTo(e.getIntKey(), w * e.getDoubleValue()));
    }
    
    return scoresMap;
}
 

@Override
public Int2DoubleMap asMap() {
	Int2DoubleMap mapRow = new Int2DoubleOpenHashMap(array.length);
	for (int i = 0; i < array.length; i++) {
		double value = array[i];
		if (isNotDefault(value)) {
			mapRow.put(i, value);
		}
	}
	return mapRow;
}
 

private IntCollection getSimilarRecords(int leftValue) {
	Int2DoubleMap row = similarityTable.row(leftValue).asMap();
	IntCollection result = new IntArrayList();
	Seq.seq(row.int2DoubleEntrySet())
		.filter(this::isAbove)
		.map(this::getRecords)
		.forEach(result::addAll);
	return result;
}
 

private static WithRow with(Int2DoubleMap row) {
	return new WithRow(row);
}
 

public Int2DoubleMap getFeatures() {
    return features;
}
 

public StandardLearningInstance(Int2DoubleMap features, double label, double weight, String group) {
    super(group);
    this.features = features;
    this.weight = weight;
    this.label = label;
}
 

@Override
protected Int2DoubleRow createRow(Int2DoubleMap map, int size) {
	return new Int2DoubleMapRow(map);
}
 

@Override
public Int2DoubleMap asMap() {
	return map;
}
 

@Override
public Int2DoubleRow create(Collection<To> similarities) {
	int size = similarities.size();
	Int2DoubleMap row = new Int2DoubleOpenHashMap(size);
	return with(row).process(similarities);
}
 

/**
 * Constructor.
 *
 * @param target target value
 * @param features sparse feature vector
 */
public FMInstance(double target, Int2DoubleMap features) {
    this.features = features;
    this.target = target;
}
 

/**
 * Returns a map of item-score pairs.
 *
 * @param uidx index of the user whose scores are predicted
 * @return a map of item-score pairs
 */
public abstract Int2DoubleMap getScoresMap(int uidx);
 

protected abstract Int2DoubleRow createRow(Int2DoubleMap map, int size); 

Int2DoubleMap asMap();