2016-05-24 23 views
0

Gibt es in GraphX ​​eine Möglichkeit zum Abrufen aller Knoten und Bögen, die sich auf einem Pfad mit einer bestimmten Länge befinden? Spezifischer: Ich möchte alle 10 Schritte Wege von A nach B bekommen. Für jeden Pfad möchte ich die Liste der Knoten und Bögen erhalten.GraphX ​​- Abrufen aller Knoten aus einem Pfad

dank

+0

Können Sie sich ein konkreteres Beispiel geben? Es ist nicht klar, was Sie fragen. Versuchen Sie beispielsweise, alle Knoten zu finden, die Teil eines 5-Knoten-Pfads sind? Teil eines bestimmten Weges? Am besten wäre es, wenn Sie einige Beispieldaten und die Ergebnisse, die Sie basierend auf diesen Daten sehen möchten. –

+0

Es gibt keine API, um dies zu tun, und es ist keine triviale Sache. Um es zu lösen, müssen Sie alle möglichen "Routen" durch das Diagramm berechnen. Es gibt APIs wie 'aggregateMessages' und/oder' pregel', mit denen Sie die Logik aufbauen können, aber wie ich schon sagte - keine triviale Sache. –

+0

Welche Umgebung wird meine Bedürfnisse erfüllen? Was ist mit Gremlin über Titan über Apache Spark? Kann Gremlin meine Anforderungen erfüllen? – Inbal

Antwort

1

Haftungsausschluss: Dies soll nur GraphFrames Pfad Filterfunktionen zeigen.

Nun, theoretisch ist es möglich. Sie können GraphFrames Muster verwenden, um Pfade zu finden. Nehmen wir an, Ihre Daten sieht wie folgt aus:

import org.graphframes.GraphFrame 

val nodes = "abcdefghij".map(c =>Tuple1(c.toString)).toDF("id") 

val edges = Seq(
    // Long path 
    ("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), 
    // and some random nodes 
    ("g", "h"), ("i", "j"), ("j", "i") 
).toDF("src", "dst") 

val gf = GraphFrame(nodes, edges) 

und Sie möchten alle Pfade mit mindestens 5 Knoten finden.

Sie können folgende Pfadstruktur konstruieren:

val path = (1 to 4).map(i => s"(n$i)-[e$i]->(n${i + 1})").mkString(";") 
// (n1)-[e1]->(n2);(n2)-[e2]->(n3);(n3)-[e3]->(n4);(n4)-[e4]->(n5) 

und Filter Ausdruck Zyklen zu vermeiden:

val expr = (1 to 5).map(i => s"n$i").combinations(2).map { 
    case Seq(i, j) => col(i) !== col(j) 
}.reduce(_ && _) 

Schließlich schnelle Überprüfung:

gf.find(path).where(expr).show 
// +-----+---+---+-----+---+-----+---+-----+---+ 
// | e1| n1| n2| e2| n3| e3| n4| e4| n5| 
// +-----+---+---+-----+---+-----+---+-----+---+ 
// |[a,b]|[a]|[b]|[b,c]|[c]|[c,d]|[d]|[d,e]|[e]| 
// |[b,c]|[b]|[c]|[c,d]|[d]|[d,e]|[e]|[e,f]|[f]| 
// +-----+---+---+-----+---+-----+---+-----+---+ 
Verwandte Themen