Gremlin-Knotenklassifizierungsabfragen in Neptune ML - Amazon Neptune
Weitere KnotenklassifizierungsabfragenVerwenden der induktiven Inferenz

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Gremlin-Knotenklassifizierungsabfragen in Neptune ML

Für die Gremlin-Knotenklassifizierung in Neptune ML:

  • Das Modell wird anhand einer einzelnen Eigenschaft der Eckpunkte trainiert. Der Satz der eindeutigen Werte dieser Eigenschaft wird als Satz von Knotenklassen oder einfach Klassen bezeichnet.

  • Die Knotenklasse oder der kategorische Eigenschaftswert einer Eckpunkteigenschaft kann aus dem Knotenklassifikationsmodell abgeleitet werden. Dies ist nützlich, wenn diese Eigenschaft dem Eckpunkt noch nicht angefügt ist.

  • Um eine oder mehrere Klassen aus einem Knotenklassifikationsmodell abzurufen, müssen Sie den Schritt with() mit dem Prädikat Neptune#ml.classification verwenden, um den Schritt properties() zu konfigurieren. Das Ausgabeformat ist dem Ausgabeformat für Eckpunkteigenschaften ähnlich.

Anmerkung

Die Knotenklassifizierung funktioniert nur mit Zeichenfolgen-Eigenschaftswerten. Das bedeutet, dass numerische Eigenschaftswerte wie 0 oder 1 nicht unterstützt werden, auch wenn die Zeichenfolgenäquivalente "0" und "1" unterstützt werden. Ähnlich funktionieren die booleschen Eigenschaftswerte true und false nicht, während "true" und "false" funktionieren.

Dies ist ein Beispiel für eine Abfrage zur Knotenklassifizierung:

g.with( "Neptune#ml.endpoint","node-classification-movie-lens-endpoint" )
 .with( "Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role" )
 .with( "Neptune#ml.limit", 2 )
 .with( "Neptune#ml.threshold", 0.5D )
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre").with("Neptune#ml.classification")

Die Ausgabe dieser Abfrage sieht ähnlich wie folgt aus:

==>vp[genre->Action]
==>vp[genre->Crime]
==>vp[genre->Comedy]

In der Abfrage oben werden die Schritte V() und properties() wie folgt verwendet:

Der Schritt V() enthält den Satz von Eckpunkten, für die Sie die Klassen aus dem Knotenklassifizierungsmodell abrufen möchten:

 .V( "movie_1", "movie_2", "movie_3" )

Der Schritt properties() enthält den Schlüssel, mit dem das Modell trainiert wurde, und besitzt .with("Neptune#ml.classification"), um anzugeben, dass es sich um eine ML-Inferenzabfrage zur Knotenklassifizierung handelt.

Der Schritt properties().with("Neptune#ml.classification") unterstützt zurzeit mehrere Eigenschaftsschlüssel nicht. Die folgende Abfrage führt beispielsweise zu einer Ausnahme:

g.with("Neptune#ml.endpoint", "node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre", "other_label").with("Neptune#ml.classification")

Die spezifische Fehlermeldung finden Sie in der Liste der Neptune-ML-Ausnahmen.

Der Schritt properties().with("Neptune#ml.classification") kann in Kombination mit einem der folgenden Schritte verwendet werden:

  • value()

  • value().is()

  • hasValue()

  • has(value,"")

  • key()

  • key().is()

  • hasKey()

  • has(key,"")

  • path()

Weitere Abfragen zur Knotenklassifizierung

Wenn sowohl der Inferenzendpunkt als auch die entsprechende IAM Rolle in Ihrer DB-Cluster-Parametergruppe gespeichert wurden, kann eine Abfrage zur Knotenklassifizierung so einfach sein:

g.V("movie_1", "movie_2", "movie_3").properties("genre").with("Neptune#ml.classification")

Mit dem Schritt union() können Sie Eckpunkteigenschaften und Klassen in einer Abfrage kombinieren:

g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .union(
   properties("genre").with("Neptune#ml.classification"),
   properties("genre")
 )

Sie können auch eine unbegrenzte Abfrage wie die folgende erstellen:

g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V()
 .properties("genre").with("Neptune#ml.classification")

Sie können die Knotenklassen zusammen mit Eckpunkten abrufen, indem Sie den Schritt select() zusammen mit dem Schritt as() ausführen:

g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" ).as("vertex")
 .properties("genre").with("Neptune#ml.classification").as("properties")
 .select("vertex","properties")

Sie können auch nach Knotenklassen filtern, wie in den folgenden Beispielen gezeigt:

g.with("Neptune#ml.endpoint", "node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre").with("Neptune#ml.classification")
 .has(value, "Horror")

g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre").with("Neptune#ml.classification")
 .has(value, P.eq("Action"))

g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre").with("Neptune#ml.classification")
 .has(value, P.within("Action", "Horror"))

Sie können mithilfe des Prädikats Neptune#ml.score einen Konfidenzwert für die Knotenklassifizierung abrufen:

 g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre", "Neptune#ml.score").with("Neptune#ml.classification")

Die Antwort würde wie folgt aussehen:

==>vp[genre->Action]
==>vp[Neptune#ml.score->0.01234567]
==>vp[genre->Crime]
==>vp[Neptune#ml.score->0.543210]
==>vp[genre->Comedy]
==>vp[Neptune#ml.score->0.10101]

Verwenden der induktiven Inferenz in einer Abfrage zur Knotenklassifizierung

Angenommen, Sie fügen einem vorhandenen Diagramm in einem Jupyter-Notebook einen neuen Knoten wie folgt hinzu:

%%gremlin
g.addV('label1').property(id,'101').as('newV')
 .V('1').as('oldV1')
 .V('2').as('oldV2')
 .addE('eLabel1').from('newV').to('oldV1')
 .addE('eLabel2').from('oldV2').to('newV')

Sie könnten dann eine induktive Inferenzabfrage verwenden, um ein Genre und einen Konfidenzwert abzurufen, die den neuen Knoten widerspiegeln:

%%gremlin
g.with("Neptune#ml.endpoint", "nc-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .V('101').properties("genre", "Neptune#ml.score")
 .with("Neptune#ml.classification")
 .with("Neptune#ml.inductiveInference")

Wenn Sie die Abfrage jedoch mehrmals ausgeführt haben, erhalten Sie möglicherweise etwas andere Ergebnisse:

# First time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]

# Second time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.21365921]

Sie könnten dieselbe Abfrage deterministisch machen:

%%gremlin
g.with("Neptune#ml.endpoint", "nc-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .V('101').properties("genre", "Neptune#ml.score")
 .with("Neptune#ml.classification")
 .with("Neptune#ml.inductiveInference")
 .with("Neptune#ml.deterministic")

In diesem Fall wären die Ergebnisse jedes Mal ungefähr gleich:

# First time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]