public NeighborIterator(long uid, Long2DoubleMap uvec, LongSet nbrs) { user = uid; userVector = uvec; neighborIter = nbrs.iterator(); } @Override
NeighborIterator(long uid, Long2DoubleMap uvec, LongSet nbrs) { user = uid; userVector = uvec; neighborIter = nbrs.iterator(); }
@Override public ObjectIterator<Entry> iterator() { return new ObjectIterator<Entry>() { LongIterator iter = keySet.iterator(); @Override public boolean hasNext() { return iter.hasNext(); } @Override public Entry next() { IndirectEntry e = new IndirectEntry(); e.key = iter.nextLong(); return e; } }; }
@Override public Iterable<Entity> entities() { return () -> new BareEntityCollection.EntityIterator(entityType, ids.iterator()); }
@Override public ObjectIterator<Entry> fastIterator() { return new ObjectIterator<Entry>() { LongIterator iter = keySet.iterator(); IndirectEntry e = new IndirectEntry(); @Override public boolean hasNext() { return iter.hasNext(); } @Override public Entry next() { e.key = iter.nextLong(); return e; } }; }
@Override public String get() { String name = fileName; logger.info("writing {}", name); File file = new File(workingDir, name); try (PrintWriter writer = new PrintWriter(file, CHARSET_UTF_8)) { LongIterator iter = identifiers.iterator(); while (iter.hasNext()) { writer.println(iter.nextLong()); } } catch (IOException e) { throw new ExternalProcessException("Error creating ratings file", e); } return name; } }
/** * Compute the set difference of two sets. * * @param items The initial set * @param exclude The items to remove * @return The elements of <var>items</var> that are not in <var>exclude</var>. */ public static LongSortedSet setDifference(LongSet items, LongSet exclude) { long[] data = new long[items.size()]; final LongIterator iter = items.iterator(); int i = 0; while (iter.hasNext()) { final long x = iter.nextLong(); if (!exclude.contains(x)) { data[i++] = x; } } if (!(items instanceof LongSortedSet)) { Arrays.sort(data, 0, i); } // trim the array if (data.length * 2 > i * 3) { data = Arrays.copyOf(data, i); } return SortedKeyIndex.wrap(data, i).keySet(); }
/** * Compute the size of the intersection of two sets. * @param a The first set. * @param b The second set. * @return The size of the intersection of the two sets. */ public static int intersectSize(LongSet a, LongSet b) { if (a instanceof LongSortedSet && b instanceof LongSortedSet) { return intersectSize((LongSortedSet) a, (LongSortedSet) b); } else { int n = 0; LongIterator iter = a.iterator(); while (iter.hasNext()) { long x = iter.nextLong(); if (b.contains(x)) { n += 1; } } return n; } }
/** * Creates an accumulator to process rating data and generate the necessary data for * a {@code SlopeOneItemScorer}. * * @param damping A damping term for deviation calculations. * @param items The set of known item IDs. */ public SlopeOneModelDataAccumulator(double damping, LongSet items) { this.damping = damping; workMatrix = new Long2ObjectOpenHashMap<>(items.size()); LongIterator iter = items.iterator(); while (iter.hasNext()) { long item = iter.nextLong(); workMatrix.put(item, Pair.<Long2DoubleMap, Long2IntMap>of(new Long2DoubleOpenHashMap(), new Long2IntOpenHashMap())); } }
/** * Constructs and returns a {@link SlopeOneModel}. */ @Override public SlopeOneModel get() { LongSet items = buildContext.getItems(); LongIterator outer = items.iterator(); while (outer.hasNext()) { final long item1 = outer.nextLong(); final Long2DoubleSortedMap vec1 = buildContext.itemVector(item1); LongIterator inner = items.iterator(); while (inner.hasNext()) { final long item2 = inner.nextLong(); if (item1 != item2) { Long2DoubleSortedMap vec2 = buildContext.itemVector(item2); accumulator.putItemPair(item1, vec1, item2, vec2); } } } return new SlopeOneModel(accumulator.buildMatrix()); } }
public AdaptiveSparseItemIterator(ItemItemBuildContext context, LongSet users, long lowerBound) { this.context = context; this.users = users; this.lowerBound = lowerBound; if (lowerBound == Long.MIN_VALUE) { universeSize = context.getItems().size(); } else { // since universe size is only used for sparsity estimation, it is // fine to have an off-by-1 discrepancy between this & iterator behavior universeSize = context.getItems().tailSet(lowerBound).size(); } seen = new LongOpenHashSet(context.getItems().size()); userIter = users.iterator(); }
for (LongIterator iter = items.iterator(); iter.hasNext();) { long item = iter.nextLong(); heaps.put(item, SortedListAccumulator.decreasing(neighborhoodSize,
/** * Compute the intersection of two sets. * * @param a The first set. * @param b The second set. * @return The elements present in both sets. */ public static LongSortedSet setIntersect(LongSet a, LongSet b) { if (a instanceof LongSortedSet && b instanceof LongSortedSet) { return setIntersect((LongSortedSet) a, (LongSortedSet) b); } else if (a.size() <= b.size()) { LongArrayList longs = new LongArrayList(Math.min(a.size(), b.size())); LongIterator iter = a.iterator(); while (iter.hasNext()) { long key = iter.nextLong(); if (b.contains(key)) { longs.add(key); } } return LongUtils.packedSet(longs); } else { return setIntersect(b, a); } }
@Override public ItemBiasModel get() { Long2DoubleMap offsets; if (damping > 0) { offsets = new Long2DoubleOpenHashMap(); LongIterator iter = summary.getItems().iterator(); while (iter.hasNext()) { long item = iter.nextLong(); double off = summary.getItemOffset(item); int count = summary.getItemRatingCount(item); offsets.put(item, count * off / (count + damping)); } } else { offsets = summary.getItemOffets(); } return new ItemBiasModel(summary.getGlobalMean(), offsets); } }
assert normV != null; normedVectors.add(normV); for (LongIterator iiter = rawV.keySet().iterator(); iiter.hasNext();) { final long item = iiter.nextLong(); LongList itemUsers = itemUserLists.get(item);
LongList selected = new LongArrayList(num); int n = 0; LongIterator iter = set.iterator(); while (iter.hasNext()) { final long item = iter.nextLong();
/** * Get the IDs of the candidate neighbors for a user. * @param user The user. * @param userItems The user's rated items. * @param targetItems The set of target items. * @return The set of IDs of candidate neighbors. */ private LongSet findCandidateNeighbors(long user, LongSet userItems, LongCollection targetItems) { LongSet users = new LongOpenHashSet(100); LongIterator items; if (userItems.size() < targetItems.size()) { items = userItems.iterator(); } else { items = targetItems.iterator(); } while (items.hasNext()) { LongSet iusers = dao.query(CommonTypes.RATING) .withAttribute(CommonAttributes.ITEM_ID, items.nextLong()) .valueSet(CommonAttributes.USER_ID); if (iusers != null) { users.addAll(iusers); } } users.remove(user); return users; }
static ResultList merge(int n, ResultList left, ResultList right, double weight) { Long2IntMap leftRanks = LongUtils.itemRanks(LongUtils.asLongList(left.idList())); Long2IntMap rightRanks = LongUtils.itemRanks(LongUtils.asLongList(right.idList())); int nl = left.size(); int nr = right.size(); LongSet allItems = new LongOpenHashSet(); allItems.addAll(leftRanks.keySet()); allItems.addAll(rightRanks.keySet()); ResultAccumulator accum = ResultAccumulator.create(n); for (LongIterator iter = allItems.iterator(); iter.hasNext();) { long item = iter.nextLong(); int rl = leftRanks.get(item); int rr = rightRanks.get(item); double s1 = rankToScore(rl, nl); double s2 = rankToScore(rr, nr); double score = weight * s1 + (1.0-weight) * s2; accum.add(new RankBlendResult(item, score, rl >= 0 ? left.get(rl) : null, rl, rr >= 0 ? right.get(rr) : null, rl)); } return accum.finish(); }
@Test public void testDotVectors() { for (Map<Long,Double> map: someMaps(longs(), doubles(-1000, 1000))) { Long2DoubleMap m = new Long2DoubleOpenHashMap(map); assertThat(Vectors.dotProduct(m, m), equalTo(Vectors.sumOfSquares(m))); if (!m.isEmpty()) { long k1 = m.keySet().iterator().nextLong(); double v1 = m.get(k1); Long2DoubleMap m2 = new Long2DoubleOpenHashMap(m); m2.remove(k1); long k2 = k1; // find a key we haven't seen yet while (m2.containsKey(k2) || k2 == k1) { k2++; } m2.put(k2, v1); // and test that it is missing from the dot product assertThat(Vectors.dotProduct(m, m2), closeTo(Vectors.sumOfSquares(m) - v1 * v1, 1.0e-6)); } } }
@Test public void testDotSortedVectors() { for (Map<Long,Double> map: someMaps(longs(), doubles(-1000, 1000))) { Long2DoubleMap m = new Long2DoubleSortedArrayMap(map); assertThat(Vectors.dotProduct(m, m), equalTo(Vectors.sumOfSquares(m))); if (!m.isEmpty()) { long k1 = m.keySet().iterator().nextLong(); double v1 = m.get(k1); Long2DoubleMap m2 = new Long2DoubleOpenHashMap(m); m2.remove(k1); long k2 = k1; // find a key we haven't seen yet while (m2.containsKey(k2) || k2 == k1) { k2++; } m2.put(k2, v1); m2 = new Long2DoubleSortedArrayMap(m2); // and test that it is missing from the dot product assertThat(Vectors.dotProduct(m, m2), closeTo(Vectors.sumOfSquares(m) - v1 * v1, 1.0e-6)); } } }