/** * Adjust clock values * @param taskToMatrixClocks taskId->(matrixId->clock) map */ public void adjustClocks(Int2ObjectOpenHashMap<Int2IntOpenHashMap> taskToMatrixClocks) { ObjectIterator<Int2ObjectMap.Entry<Int2IntOpenHashMap>> taskIter = taskToMatrixClocks.int2ObjectEntrySet().fastIterator(); Int2ObjectMap.Entry<Int2IntOpenHashMap> taskEntry = null; int taskId = 0; Int2IntOpenHashMap matrixIdToClockMap = null; ObjectIterator<Int2IntMap.Entry> matrixIter = null; Int2IntMap.Entry matrixEntry = null; while(taskIter.hasNext()) { taskEntry = taskIter.next(); taskId = taskEntry.getIntKey(); matrixIdToClockMap = taskEntry.getValue(); matrixIter = matrixIdToClockMap.int2IntEntrySet().fastIterator(); while (matrixIter.hasNext()) { matrixEntry = matrixIter.next(); updateClock(matrixEntry.getIntKey(), taskId, matrixEntry.getIntValue()); } } }
protected static Entry<Map<String, SimpleEnum<?>>, Int2ObjectMap<SimpleEnum<?>>> init(final Class<?> clazz, final int size) { Map<String, SimpleEnum<?>> byName = ASimpleEnum.byName.get(clazz); if (byName == null) { byName = new CaseInsensitiveMap<>(size, SMALL_LOAD_FACTOR); ASimpleEnum.byName.put(clazz, byName); } Int2ObjectMap<SimpleEnum<?>> byID = ASimpleEnum.byOrdinal.get(clazz); if (byID == null) { byID = new Int2ObjectOpenHashMap<>(size, SMALL_LOAD_FACTOR); ASimpleEnum.byOrdinal.put(clazz, byID); } return new SimpleEntry<>(byName, byID); }
private static double predict(final int user, final int itemI, @Nonnull final Int2ObjectMap<Int2FloatMap> knnItems, final int excludeIndex, @Nonnull final FloatMatrix weightMatrix) { final Int2FloatMap kNNu = knnItems.get(user); if (kNNu == null) { return 0.d; } double pred = 0.d; for (Int2FloatMap.Entry e : Fastutil.fastIterable(kNNu)) { final int itemK = e.getIntKey(); if (itemK == excludeIndex) { continue; } float ruk = e.getFloatValue(); pred += ruk * weightMatrix.get(itemI, itemK, 0.d); } return pred; }
private void replayTrain(@Nonnull final ByteBuffer buf) { final int itemI = buf.getInt(); final int knnSize = buf.getInt(); final Int2ObjectMap<Int2FloatMap> knnItems = new Int2ObjectOpenHashMap<>(1024); final IntSet pairItems = new IntOpenHashSet(); for (int i = 0; i < knnSize; i++) { int user = buf.getInt(); int ruSize = buf.getInt(); Int2FloatMap ru = new Int2FloatOpenHashMap(ruSize); ru.defaultReturnValue(0.f); for (int j = 0; j < ruSize; j++) { int itemK = buf.getInt(); pairItems.add(itemK); float ruk = buf.getFloat(); ru.put(itemK, ruk); } knnItems.put(user, ru); } for (int itemJ : pairItems) { train(itemI, knnItems, itemJ); } }
@Nonnull private static Int2ObjectMap<Int2FloatMap> kNNentries(@Nonnull final Object kNNiObj, @Nonnull final MapObjectInspector knnItemsOI, @Nonnull final PrimitiveObjectInspector knnItemsKeyOI, @Nonnull final MapObjectInspector knnItemsValueOI, @Nonnull final PrimitiveObjectInspector knnItemsValueKeyOI, @Nonnull final PrimitiveObjectInspector knnItemsValueValueOI, @Nullable Int2ObjectMap<Int2FloatMap> knnItems, @Nonnull final MutableInt nnzKNNi) { if (knnItems == null) { knnItems = new Int2ObjectOpenHashMap<>(1024); } else { knnItems.clear(); } int numElementOfKNNItems = 0; for (Map.Entry<?, ?> entry : knnItemsOI.getMap(kNNiObj).entrySet()) { int user = PrimitiveObjectInspectorUtils.getInt(entry.getKey(), knnItemsKeyOI); Int2FloatMap ru = int2floatMap(knnItemsValueOI.getMap(entry.getValue()), knnItemsValueKeyOI, knnItemsValueValueOI); knnItems.put(user, ru); numElementOfKNNItems += ru.size(); } nnzKNNi.setValue(numElementOfKNNItems); return knnItems; }
public static Int2ObjectMap.Entry pairToEntry(final IntObjectPair pair) { return new Int2ObjectMap.Entry() { @Override public int getIntKey() { return pair.getFirstInt(); } @Override public Object getKey() { return pair.getFirst(); } @Override public Object getValue() { return pair.getSecond(); } @Override public Object setValue(Object value) { throw new UnsupportedOperationException("This entry is immutable"); } }; }
private int initialize(Int2ObjectMap<CustomTimeBucket> idToTimeBucket) { Preconditions.checkNotNull(idToTimeBucket); int tempId = Integer.MIN_VALUE; for (int timeBucketId : idToTimeBucket.keySet()) { tempId = Math.max(tempId, timeBucketId); CustomTimeBucket customTimeBucket = idToTimeBucket.get(timeBucketId); textToTimeBucket.put(customTimeBucket.getText(), customTimeBucket); Preconditions.checkNotNull(customTimeBucket); timeBucketToId.put(customTimeBucket, timeBucketId); } return tempId; }
protected void buildNonCompositeAggregatorIDMap(String aggregatorName, FieldsDescriptor inputDescriptor, IntArrayList aggIDList, Int2ObjectMap<FieldsDescriptor> inputMap, Int2ObjectMap<FieldsDescriptor> outputMap) { IncrementalAggregator incrementalAggregator = aggregatorRegistry.getNameToIncrementalAggregator().get( aggregatorName); //don't need to build OTF aggregate if (incrementalAggregator == null) { return; } int aggregatorID = aggregatorRegistry.getIncrementalAggregatorNameToID().get(aggregatorName); mergeAggregatorID(aggIDList, aggregatorID); inputMap.put(aggregatorID, inputDescriptor); outputMap.put(aggregatorID, AggregatorUtils.getOutputFieldsDescriptor(inputDescriptor, incrementalAggregator)); }
public IntMapGraph(Int2ObjectMap<IntSet> map) { this.map = map; if (map.defaultReturnValue() == null || !map.defaultReturnValue().equals(IntSets.EMPTY_SET)) { LOGGER.warn("It is necessary to set default return value of the map as the empty set."); map.defaultReturnValue(IntSets.EMPTY_SET); } int maxNodeIndex = 0, numArcs = 0; for (Entry<IntSet> x : map.int2ObjectEntrySet()) { if (x.getIntKey() > maxNodeIndex) maxNodeIndex = x.getIntKey(); for (int succ : x.getValue()) { if (succ > maxNodeIndex) maxNodeIndex = succ; numArcs++; } } this.numArcs = numArcs; this.numNodes = maxNodeIndex+1; }
public LatentMatrixEstimator(ImmutableGraph graph, Int2ObjectMap<IntSet> node2cat, String output, Matrix initialMatrix) { rnd = RandomSingleton.get(); pl = new ProgressLogger(LOGGER, "node couples"); this.graph = graph; this.node2cat = node2cat; if (graph.numNodes() != node2cat.size()) { LOGGER.warn("node2cat file and graph file have a different number of nodes: " + "respectively, " + node2cat.size() + " and " + graph.numNodes()); } numNodes = graph.numNodes(); classifier = new PAClassifier(initialMatrix); this.output = output; nArcsLearned = 0; }
public PooledDatasetChecker(GroundTruth evaluations, ImmutableGraph g, UnexpectednessScorer[] pool, Int2ObjectMap<String> id2name) throws IOException { this.graph = g; this.pool = pool; this.evaluations = evaluations; this.id2name = id2name; SummaryStatistics[] stats = new SummaryStatistics[pool.length]; for (int i = 0; i < stats.length; i++) stats[i] = new SummaryStatistics(); retriever2itsFraction = new Object2ObjectOpenHashMap<UnexpectednessScorer, SummaryStatistics>(pool, stats); for (int i = 0; i < stats.length; i++) stats[i] = new SummaryStatistics(); retriever2evaluatedTopResults = new Object2ObjectOpenHashMap<UnexpectednessScorer, SummaryStatistics>(pool, stats); unmatchStats = new SummaryStatistics(); System.out.println(evaluations.stats()); }
@Nullable public static <T> T getWeightedRandomReversed(Random random, Int2ObjectMap<T> choices) { long i = 0; IntSet ints = choices.keySet(); for (IntIterator iterator = ints.iterator(); iterator.hasNext(); ) { int x = iterator.nextInt(); i += x; } i = getRandomLong(random, 0, i); for (Int2ObjectMap.Entry<T> entry : choices.int2ObjectEntrySet()) { i -= entry.getIntKey(); if (i < 0) { return entry.getValue(); } } return null; }
public Vector get(int index) { int count = 0; ObjectIterator<Int2ObjectMap.Entry<LocalBlockVectorSet>> iter = localSets.int2ObjectEntrySet().iterator(); while (iter.hasNext()) { Int2ObjectMap.Entry<LocalBlockVectorSet> entry = iter.next(); LocalBlockVectorSet set = entry.getValue(); int size = set.size(); int newSize = count + size; if (newSize > index) { int localIndex = index - count; Vector pos = set.getIndex(localIndex); if (pos != null) { int pair = entry.getIntKey(); int cx = MathMan.unpairX(pair); int cz = MathMan.unpairY(pair); pos.mutX((cx << 11) + pos.getBlockX()); pos.mutZ((cz << 11) + pos.getBlockZ()); return pos; } } count += newSize; } return null; }
protected void calculateLayerArrays() { Int2ObjectOpenHashMap<char[]> colorLayerMap = new Int2ObjectOpenHashMap<>(); for (int i = 0; i < validBlockIds.length; i++) { int color = validColors[i]; int combined = validBlockIds[i]; if (hasAlpha(color)) { for (int j = 0; j < validBlockIds.length; j++) { int colorOther = validColors[j]; if (!hasAlpha(colorOther)) { int combinedOther = validBlockIds[j]; int combinedColor = combineTransparency(color, colorOther); colorLayerMap.put(combinedColor, new char[]{(char) combined, (char) combinedOther}); } } } } this.validLayerColors = new int[colorLayerMap.size()]; this.validLayerBlocks = new char[colorLayerMap.size()][]; int index = 0; for (Int2ObjectMap.Entry<char[]> entry : colorLayerMap.int2ObjectEntrySet()) { validLayerColors[index] = entry.getIntKey(); validLayerBlocks[index++] = entry.getValue(); } }
private Dependency makeDependency(JCas aJCas, int govId, int depId, String label, String flavor, Int2ObjectMap<Token> tokens, String[] word) { Dependency rel = new Dependency(aJCas); if (govId == 0) { rel.setGovernor(tokens.get(depId)); rel.setDependent(tokens.get(depId)); } else { rel.setGovernor(tokens.get(govId)); rel.setDependent(tokens.get(depId)); } rel.setDependencyType(label); // This is set via FSUtil because we still use the DKPro Core 1.7.0 JCas classes FSUtil.setFeature(rel, "flavor", flavor); rel.setBegin(rel.getDependent().getBegin()); rel.setEnd(rel.getDependent().getEnd()); rel.addToIndexes(); return rel; }
public void removeUselessNodes(Int2ObjectMap<Node> borderNodes, ProcessingTile tile) { int nodeCount = this.nodes.size(); for (int i=0; i<nodeCount; i++) { Node node = this.nodes.get(i); BoundingBox box = node.getBox(); if (box.getLeftX() > tile.getImageLeftX() && box.getTopY() > tile.getImageTopY() && box.getRightX() - 1 < tile.getImageRightX() && box.getBottomY() - 1 < tile.getImageBottomY()) { continue; } else if (!borderNodes.containsKey(node.getId())) { removeEdgeToUnstableNode(node); node.setExpired(true); } } removeExpiredNodes(); }
@Test public void testBuildBorderPixelMap() { int imageWidth = 10; int imageHeight = 10; int tileLeftX = 0; int tileTopY = 0; int tileSizeX = 3; int tileSizeY = 3; int tileMargin = 1; int tileCountX = (imageWidth / tileSizeX); int tileCountY = (imageHeight / tileSizeY); Graph graph = checkGraph(imageWidth); ProcessingTile tile = AbstractTileSegmenter.buildTile(tileLeftX, tileTopY, tileSizeX, tileSizeY, tileMargin, imageWidth, imageHeight); Int2ObjectMap<List<Node>> borderPixelMap = graph.buildBorderPixelMap(tile, 0, 0, tileCountX, tileCountY, imageWidth); assertNotNull(borderPixelMap); assertEquals(2, borderPixelMap.size()); }
@Test public void testRemoveDuplicatedNodes() { int imageWidth = 10; int imageHeight = 10; int tileLeftX = 0; int tileTopY = 0; int tileSizeX = 3; int tileSizeY = 3; int tileMargin = 1; int tileCountX = (imageWidth / tileSizeX); int tileCountY = (imageHeight / tileSizeY); Graph graph = checkGraph(imageWidth); ProcessingTile tile = AbstractTileSegmenter.buildTile(tileLeftX, tileTopY, tileSizeX, tileSizeY, tileMargin, imageWidth, imageHeight); Int2ObjectMap<List<Node>> borderPixelMap = graph.buildBorderPixelMap(tile, 0, 0, tileCountX, tileCountY, imageWidth); assertNotNull(borderPixelMap); assertEquals(2, borderPixelMap.size()); graph.removeDuplicatedNodes(borderPixelMap, imageWidth); assertEquals(3, graph.getNodeCount()); }
@Test public void testRemoveUselessNodes() { int imageWidth = 10; int imageHeight = 10; int tileLeftX = 0; int tileTopY = 0; int tileSizeX = 3; int tileSizeY = 3; int tileMargin = 1; Graph graph = checkGraph(imageWidth); ProcessingTile tile = AbstractTileSegmenter.buildTile(tileLeftX, tileTopY, tileSizeX, tileSizeY, tileMargin, imageWidth, imageHeight); Int2ObjectMap<Node> borderNodes = new Int2ObjectLinkedOpenHashMap<Node>(1); Node node = graph.getNodeAt(0); borderNodes.put(node.getId(), node); graph.removeUselessNodes(borderNodes, tile); assertEquals(1, graph.getNodeCount()); }
/** * Group all documents based on a dimension's value. * * @param startDocId Start document id of the range to be grouped * @param endDocId End document id (exclusive) of the range to be grouped * @param dimensionId Index of the dimension to group on * @return Map from dimension value to a pair of start docId and end docId (exclusive) */ public Int2ObjectMap<IntPair> groupOnDimension(int startDocId, int endDocId, int dimensionId) { int startDocIdOffset = startDocId - _startDocId; int endDocIdOffset = endDocId - _startDocId; Int2ObjectMap<IntPair> rangeMap = new Int2ObjectLinkedOpenHashMap<>(); int dimensionOffset = dimensionId * V1Constants.Numbers.INTEGER_SIZE; int currentValue = _dataBuffer.getInt(startDocIdOffset * _docSize + dimensionOffset); int groupStartDocId = startDocId; for (int i = startDocIdOffset + 1; i < endDocIdOffset; i++) { int value = _dataBuffer.getInt(i * _docSize + dimensionOffset); if (value != currentValue) { int groupEndDocId = i + _startDocId; rangeMap.put(currentValue, new IntPair(groupStartDocId, groupEndDocId)); currentValue = value; groupStartDocId = groupEndDocId; } } rangeMap.put(currentValue, new IntPair(groupStartDocId, endDocId)); return rangeMap; }
public FunctionalDependencyGenerator(FunctionalDependencyResultReceiver fdrr, String relationName, List<String> columnIdentifer, int numberOfThreads, Int2ObjectMap<List<OpenBitSet>> lhss) { super(numberOfThreads, "FunctionalDependencyGen"); this.fdrr = fdrr; this.relationName = relationName; this.columns = columnIdentifer; this.lhss = lhss; }
public PositionListIndex intersect(int[] otherPLI) { Int2ObjectMap<Int2ObjectMap<IntArrayList>> intersectMap = this.buildIntersectMap(otherPLI); List<IntArrayList> clusters = new ArrayList<>(); for (Int2ObjectMap<IntArrayList> cluster1 : intersectMap.values()) for (IntArrayList cluster2 : cluster1.values()) if (cluster2.size() > 1) clusters.add(cluster2); return new PositionListIndex(-1, clusters); }
private void saveCanonicalIds() { Int2ObjectOpenHashMap mappings = canonicalIdHolder.getAllMappings(); for (ObjectIterator<Int2ObjectMap.Entry<?>> i = mappings.int2ObjectEntrySet().fastIterator(); i .hasNext();) { Int2ObjectMap.Entry<?> entry = i.next(); writeCanonicalId(entry.getIntKey(), entry.getValue()); } }
private Collection<Alignment> bipartiteMatch(Int2ObjectMap<Entity> schema1, Int2ObjectMap<Entity> schema2, Mat m) { MunkRes munkRes = new MunkRes(m); double[] sim = m.sim(); final Collection<Alignment> alignmentSet = new ArrayList<>(); for(IntPair ip : munkRes.execute()) { if(m.contains(ip._1, ip._2)) { final String e1id = schema1.get(ip._1).id; final String e2id = schema2.get(ip._2).id; final double s = sim[m.ij2index(ip._1, ip._2)]; alignmentSet.add(new Alignment(e1id, e2id, Math.min(s,1.0))); } } System.err.printf("Produced %d matches from %d x %d\n", alignmentSet.size(), schema1.size(), schema2.size()); return alignmentSet; }
@Override public ColumnMajorDenseMatrix2d buildMatrix() { final double[][] data = new double[maxNumColumns][]; for (Int2ObjectMap.Entry<SparseDoubleArray> e : Fastutil.fastIterable(col2rows)) { int col = e.getIntKey(); SparseDoubleArray rows = e.getValue(); data[col] = rows.toArray(); } return new ColumnMajorDenseMatrix2d(data, row, nnz); }
private void train(final int itemI, @Nonnull final Int2FloatMap ri, @Nonnull final Int2ObjectMap<Int2FloatMap> kNNi, final int itemJ, @Nonnull final Int2FloatMap rj) { final FloatMatrix W = _weightMatrix; final int N = rj.size(); if (N == 0) { return; } double gradSum = 0.d; double rateSum = 0.d; double lossSum = 0.d; for (Int2FloatMap.Entry e : Fastutil.fastIterable(rj)) { int user = e.getIntKey(); double ruj = e.getFloatValue(); double rui = ri.get(user); // ri.getOrDefault(user, 0.f); double eui = rui - predict(user, itemI, kNNi, itemJ, W); gradSum += ruj * eui; rateSum += ruj * ruj; lossSum += eui * eui; } gradSum /= N; rateSum /= N; double wij = W.get(itemI, itemJ, 0.d); double loss = lossSum / N + 0.5d * l2 * wij * wij + l1 * wij; _cvState.incrLoss(loss); W.set(itemI, itemJ, getUpdateTerm(gradSum, rateSum, l1, l2)); }
private void train(final int itemI, @Nonnull final Int2ObjectMap<Int2FloatMap> knnItems, final int itemJ) { final FloatMatrix A = _dataMatrix; final FloatMatrix W = _weightMatrix; final int N = A.numColumns(itemJ); if (N == 0) { return; } final MutableDouble mutableGradSum = new MutableDouble(0.d); final MutableDouble mutableRateSum = new MutableDouble(0.d); final MutableDouble mutableLossSum = new MutableDouble(0.d); A.eachNonZeroInRow(itemJ, new VectorProcedure() { @Override public void apply(int user, double ruj) { double rui = A.get(itemI, user, 0.d); double eui = rui - predict(user, itemI, knnItems, itemJ, W); mutableGradSum.addValue(ruj * eui); mutableRateSum.addValue(ruj * ruj); mutableLossSum.addValue(eui * eui); } }); double gradSum = mutableGradSum.getValue() / N; double rateSum = mutableRateSum.getValue() / N; double wij = W.get(itemI, itemJ, 0.d); double loss = mutableLossSum.getValue() / N + 0.5 * l2 * wij * wij + l1 * wij; _cvState.incrLoss(loss); W.set(itemI, itemJ, getUpdateTerm(gradSum, rateSum, l1, l2)); }
@Nonnull public static <V> ObjectIterable<Int2ObjectMap.Entry<V>> fastIterable( @Nonnull final Int2ObjectMap<V> map) { final ObjectSet<Int2ObjectMap.Entry<V>> entries = map.int2ObjectEntrySet(); return entries instanceof Int2ObjectMap.FastEntrySet ? new ObjectIterable<Int2ObjectMap.Entry<V>>() { public ObjectIterator<Int2ObjectMap.Entry<V>> iterator() { return ((Int2ObjectMap.FastEntrySet<V>) entries).fastIterator(); } } : entries; }
/** * Returns a new DictionaryMap that is a deep copy of the original */ public DictionaryMap(DictionaryMap original) { for (Int2ObjectMap.Entry<String> entry : original.keyToValue.int2ObjectEntrySet()) { keyToValue.put(entry.getIntKey(), entry.getValue()); valueToKey.put(entry.getValue(), entry.getIntKey()); } valueToKey.defaultReturnValue(-1); }
LeftSegmentRandomEdgeAccessor( MultiSegmentReaderAccessibleInfo<T> readerAccessibleInfo, Int2ObjectMap<ReusableInternalIdToLongIterator> segmentInternalIdToLongIteratorMap, Int2ObjectMap<ReusableNodeRandomIntIterator> segmentNodeRandomIntIteratorMap) { super(readerAccessibleInfo, segmentInternalIdToLongIteratorMap, segmentNodeRandomIntIteratorMap); }
protected Int2ObjectMap<T> getSegments() { // Hopefully branch prediction should make this really cheap as it'll always be false! if (crossMemoryBarrier() == -1) { return null; } return multiSegmentReaderAccessibleInfoProvider .getMultiSegmentReaderAccessibleInfo().getSegments(); }
SegmentEdgeRandomAccessor( MultiSegmentReaderAccessibleInfo<T> readerAccessibleInfo, Int2ObjectMap<ReusableInternalIdToLongIterator> segmentInternalIdToLongIteratorMap, Int2ObjectMap<ReusableNodeRandomIntIterator> segmentNodeRandomIntIteratorMap) { super(readerAccessibleInfo); this.segmentInternalIdToLongIteratorMap = segmentInternalIdToLongIteratorMap; this.segmentNodeRandomIntIteratorMap = segmentNodeRandomIntIteratorMap; }
RightSegmentRandomEdgeAccessor( MultiSegmentReaderAccessibleInfo<BipartiteGraphSegment> readerAccessibleInfo, Int2ObjectMap<ReusableInternalIdToLongIterator> segmentInternalIdToLongIteratorMap, Int2ObjectMap<ReusableNodeRandomIntIterator> segmentNodeRandomIntIteratorMap) { super(readerAccessibleInfo, segmentInternalIdToLongIteratorMap, segmentNodeRandomIntIteratorMap); }
/** * A new instance is immediately visible to the readers due to publication safety. * * @param segments contains all the present segments * @param oldestSegmentId is the id of the oldest segment * @param liveSegmentId is the id of the live segment */ public MultiSegmentReaderAccessibleInfo( Int2ObjectMap<T> segments, int oldestSegmentId, int liveSegmentId) { this.segments = segments; this.oldestSegmentId = oldestSegmentId; this.liveSegmentId = liveSegmentId; }
public CustomTimeBucketRegistry(Int2ObjectMap<CustomTimeBucket> idToTimeBucket, int startingId) { int tempId = initialize(idToTimeBucket); Preconditions.checkArgument(tempId < startingId, "The statingId " + startingId + " must be larger than the largest ID " + tempId + " in the given idToTimeBucket mapping"); this.idToTimeBucket = Preconditions.checkNotNull(idToTimeBucket); this.currentId = startingId; }
@SuppressWarnings("unchecked") public LlamaFurScorer(String graphBasename, String matrixPath, String page2catPath, String name) throws ClassNotFoundException, IOException { this( ImmutableGraph.load(graphBasename), (Matrix) SerializationUtils.read(matrixPath), (Int2ObjectMap<IntSet>) SerializationUtils.read(page2catPath), name ); }
@CommandLine(argNames={"matrix", "graph", "page2cat", "negativeToPositiveRatio", "verbose"}) public TestMatrix(Matrix matrix, ImmutableGraph graph, Int2ObjectMap<IntSet> page2cat, double negativeToPositiveRatio, boolean verbose) { super(); this.matrix = matrix; this.graph = graph; this.page2cat = page2cat; this.negativeToPositiveRatio = negativeToPositiveRatio; this.verbose = verbose; numNodes = graph.numNodes(); classifier = new PAClassifier(matrix); }
@SuppressWarnings("unchecked") @CommandLine(argNames = { "poolSpecificationFile", "evaluationDataset", "name2id"}) public PrecisionRecallPlot(String poolSpecificationFile, String datasetPath, Object2IntMap<String> name2id) throws Exception { super( new PoolSpecification(poolSpecificationFile), GroundTruth.fromUTF8FilePath(datasetPath, name2id) ); this.checkEveryResultIsAnOutlinkInThisGraph = super.graph; groundtruth.checkAgreementWith(super.graph, (Int2ObjectMap<String>) MapUtils.invert(name2id)); }
@SuppressWarnings("unchecked") public static <T extends AbstractMeasure> void main(String[] args, Class<T> concreteMeasure) throws Exception { JsapResultsWithObject<T> jsapObj = JsapUtils .constructObject(concreteMeasure, args, "Compute " + concreteMeasure.getSimpleName(), new Parameter[] { new FlaggedOption("names", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.NOT_REQUIRED, 'n', "names", "if supplied, output will use names for each query instead of query id"), new FlaggedOption( "output", JSAP.STRING_PARSER, null, JSAP.NOT_REQUIRED, 'o', "output", "Output file path to save query-specific data." ), }); T measurer = jsapObj.getObject(); JSAPResult jsap = jsapObj.getJsapResult(); if (jsap.contains("names")) measurer.setQueryNames((Int2ObjectMap<String>) SerializationUtils .read(jsap.getString("names"))); if (jsap.contains("output")) measurer.setOutputPathTo(jsap.getString("output")); measurer.computeAll(); measurer.close(); }