Examples with ComputerResult org.apache.tinkerpop.gremlin.process.computer.ComputerResult used on opensource projects

Example 6 with ComputerResult

use of org.apache.tinkerpop.gremlin.process.computer.ComputerResult in project janusgraph by JanusGraph.

the class OLAPTest method testPageRank.

@Test
public void testPageRank() throws ExecutionException, InterruptedException {
    mgmt.makePropertyKey("distance").dataType(Integer.class).cardinality(Cardinality.SINGLE).make();
    mgmt.makeEdgeLabel("knows").multiplicity(Multiplicity.MULTI).make();
    mgmt.makeEdgeLabel("likes").multiplicity(Multiplicity.MULTI).make();
    finishSchema();
    final int branch = 6;
    final int diameter = 5;
    final double alpha = 0.85d;
    int numV = (int) ((Math.pow(branch, diameter + 1) - 1) / (branch - 1));
    JanusGraphVertex v = tx.addVertex();
    expand(v, 0, diameter, branch);
    clopen();
    assertCount(numV, tx.query().vertices());
    log.debug("PR test numV: {}", numV);
    newTx();
    // Precompute correct PR results:
    double[] correctPR = new double[diameter + 1];
    for (int i = diameter; i >= 0; i--) {
        double pr = (1.0D - alpha) / numV;
        if (i < diameter)
            pr += alpha * branch * correctPR[i + 1];
        log.debug("diameter={} pr={}", diameter, pr);
        correctPR[i] = pr;
    }
    double correctPRSum = 0;
    for (final JanusGraphVertex janusGraphVertex : tx.query().vertices()) {
        correctPRSum += correctPR[janusGraphVertex.<Integer>value("distance")];
    }
    final JanusGraphComputer computer = graph.compute();
    computer.resultMode(JanusGraphComputer.ResultMode.NONE);
    computer.workers(4);
    computer.program(PageRankVertexProgram.build().iterations(10).vertexCount(numV).dampingFactor(alpha).create(graph));
    computer.mapReduce(PageRankMapReduce.build().create());
    ComputerResult result = computer.submit().get();
    Iterator<KeyValue<Long, Double>> ranks = result.memory().get(PageRankMapReduce.DEFAULT_MEMORY_KEY);
    assertNotNull(ranks);
    int vertexCounter = 0;
    double computedPRSum = 0;
    correctPRSum = 0;
    final Set<Long> vertexIDs = new HashSet<>(numV);
    while (ranks.hasNext()) {
        final KeyValue<Long, Double> rank = ranks.next();
        final Long vertexID = rank.getKey();
        final Double computedPR = rank.getValue();
        assertNotNull(vertexID);
        assertNotNull(computedPR);
        final JanusGraphVertex u = getV(tx, vertexID);
        final int distance = u.<Integer>value("distance");
        vertexCounter++;
        // assertEquals("Incorrect PR on vertex #" + vertexCounter, correctPR[distance], computedPR, EPSILON);
        computedPRSum += computedPR;
        correctPRSum += correctPR[distance];
        assertFalse(vertexIDs.contains(vertexID));
        vertexIDs.add(vertexID);
        log.debug("vertexID={} computedPR={}", vertexID, computedPR);
    }
    assertEquals(numV, vertexCounter);
    assertEquals(correctPRSum, computedPRSum, 0.001);
}

Example 7 with ComputerResult

use of org.apache.tinkerpop.gremlin.process.computer.ComputerResult in project titan by thinkaurelius.

the class TitanPartitionGraphTest method testVertexPartitionOlap.

private void testVertexPartitionOlap(CommitMode commitMode) throws Exception {
    Object[] options = { option(GraphDatabaseConfiguration.IDS_FLUSH), false };
    clopen(options);
    //        int[] groupDegrees = {10,20,30};
    int[] groupDegrees = { 2 };
    int numVertices = setupGroupClusters(groupDegrees, commitMode);
    Map<Long, Integer> degreeMap = new HashMap<>(groupDegrees.length);
    for (int i = 0; i < groupDegrees.length; i++) {
        degreeMap.put(getOnlyVertex(tx.query().has("groupid", "group" + i)).longId(), groupDegrees[i]);
    }
    clopen(options);
    //Test OLAP works with partitioned vertices
    TitanGraphComputer computer = graph.compute(FulgoraGraphComputer.class);
    computer.resultMode(TitanGraphComputer.ResultMode.NONE);
    computer.workers(1);
    computer.program(new OLAPTest.DegreeCounter());
    computer.mapReduce(new OLAPTest.DegreeMapper());
    ComputerResult result = computer.submit().get();
    assertTrue(result.memory().exists(OLAPTest.DegreeMapper.DEGREE_RESULT));
    Map<Long, Integer> degrees = result.memory().get(OLAPTest.DegreeMapper.DEGREE_RESULT);
    assertNotNull(degrees);
    assertEquals(numVertices, degrees.size());
    final IDManager idManager = graph.getIDManager();
    for (Map.Entry<Long, Integer> entry : degrees.entrySet()) {
        long vid = entry.getKey();
        Integer degree = entry.getValue();
        if (idManager.isPartitionedVertex(vid)) {
            //                System.out.println("Partitioned: " + degree );
            assertEquals(degreeMap.get(vid), degree);
        } else {
            assertEquals(1, (long) degree);
        }
    }
}

Example 8 with ComputerResult

use of org.apache.tinkerpop.gremlin.process.computer.ComputerResult in project grakn by graknlabs.

the class TinkerComputeQueryRunner method run.

public ComputeJob<Map<String, Set<String>>> run(KCoreQuery query) {
    return runCompute(query, tinkerComputeQuery -> {
        long k = query.kValue();
        if (k < 2L)
            throw GraqlQueryException.kValueSmallerThanTwo();
        if (!tinkerComputeQuery.selectedTypesHaveInstance()) {
            return Collections.emptyMap();
        }
        ComputerResult result;
        Set<LabelId> subLabelIds = convertLabelsToIds(tinkerComputeQuery.subLabels());
        try {
            result = tinkerComputeQuery.compute(new KCoreVertexProgram(k), new ClusterMemberMapReduce(KCoreVertexProgram.K_CORE_LABEL), subLabelIds);
        } catch (NoResultException e) {
            return Collections.emptyMap();
        }
        return result.memory().get(ClusterMemberMapReduce.class.getName());
    });
}

Example 9 with ComputerResult

use of org.apache.tinkerpop.gremlin.process.computer.ComputerResult in project grakn by graknlabs.

the class TinkerComputeQueryRunner method run.

public ComputeJob<Map<Long, Set<String>>> run(CorenessQuery query) {
    return runCompute(query, tinkerComputeQuery -> {
        long k = query.minK();
        if (k < 2L)
            throw GraqlQueryException.kValueSmallerThanTwo();
        Set<Label> ofLabels;
        // Check if ofType is valid before returning emptyMap
        if (query.targetLabels().isEmpty()) {
            ofLabels = tinkerComputeQuery.subLabels();
        } else {
            ofLabels = query.targetLabels().stream().flatMap(typeLabel -> {
                Type type = tx.getSchemaConcept(typeLabel);
                if (type == null)
                    throw GraqlQueryException.labelNotFound(typeLabel);
                if (type.isRelationshipType())
                    throw GraqlQueryException.kCoreOnRelationshipType(typeLabel);
                return type.subs();
            }).map(SchemaConcept::getLabel).collect(Collectors.toSet());
        }
        Set<Label> subLabels = Sets.union(tinkerComputeQuery.subLabels(), ofLabels);
        if (!tinkerComputeQuery.selectedTypesHaveInstance()) {
            return Collections.emptyMap();
        }
        ComputerResult result;
        Set<LabelId> subLabelIds = convertLabelsToIds(subLabels);
        Set<LabelId> ofLabelIds = convertLabelsToIds(ofLabels);
        try {
            result = tinkerComputeQuery.compute(new CorenessVertexProgram(k), new DegreeDistributionMapReduce(ofLabelIds, CorenessVertexProgram.CORENESS), subLabelIds);
        } catch (NoResultException e) {
            return Collections.emptyMap();
        }
        return result.memory().get(DegreeDistributionMapReduce.class.getName());
    });
}

Example 10 with ComputerResult

use of org.apache.tinkerpop.gremlin.process.computer.ComputerResult in project grakn by graknlabs.

the class TinkerComputeQueryRunner method execWithMapReduce.

private <T, S, Q extends StatisticsQuery<?>> TinkerComputeJob<Optional<S>> execWithMapReduce(Q query, MapReduceFactory<T> mapReduceFactory, Function<T, S> operator) {
    return runStatistics(query, tinkerComputeQuery -> {
        AttributeType.DataType<?> dataType = tinkerComputeQuery.getDataTypeOfSelectedResourceTypes();
        if (!tinkerComputeQuery.selectedResourceTypesHaveInstance()) {
            return Optional.empty();
        }
        Set<LabelId> allSubLabelIds = convertLabelsToIds(tinkerComputeQuery.getCombinedSubTypes());
        Set<LabelId> statisticsResourceLabelIds = convertLabelsToIds(tinkerComputeQuery.statisticsResourceLabels());
        GraknMapReduce<T> mapReduce = mapReduceFactory.get(statisticsResourceLabelIds, dataType, DegreeVertexProgram.DEGREE);
        ComputerResult result = tinkerComputeQuery.compute(new DegreeStatisticsVertexProgram(statisticsResourceLabelIds), mapReduce, allSubLabelIds);
        Map<Serializable, T> map = result.memory().get(mapReduce.getClass().getName());
        LOG.debug("Result = " + map.get(MapReduce.NullObject.instance()));
        return Optional.of(operator.apply(map.get(MapReduce.NullObject.instance())));
    });
}