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-Inferenzabfragen in Neptune ML
Gremlin-Inferenzabfragen

Wie in [Neptune-ML-Fähigkeiten](machine-learning.md#machine-learning-capabilities) beschrieben, unterstützt Neptune ML Trainingsmodelle, die die folgenden Arten von Inferenzaufgaben ausführen können:
+ **Knotenklassifizierung**   –   Sagt das kategorische Feature einer Eckpunkteigenschaft vorher.
+ **Knotenregression**   –   Sagt eine numerische Eigenschaft eines Eckpunkts vorher.
+ **Kantenklassifizierung**   –   Sagt das kategorische Feature einer Kanteneigenschaft vorher.
+ **Kantenregression**   –   Sagt eine numerische Eigenschaft eines Eckpunkts vorher.
+ **Linkvorhersage**   –   Sagt anhand eines Quellknotens und einer ausgehenden Kante Zielknoten oder anhand eines Zielknotens und einer eingehenden Kante Quellknoten voraus.

Wir können diese verschiedenen Aufgaben anhand von Beispielen veranschaulichen, die den von [GroupLens Research](https://grouplens.org/datasets/movielens/) bereitgestellten [MovieLens 100.000 Datensatz](https://grouplens.org/datasets/movielens/100k/) verwenden. Dieser Datensatz besteht aus Filmen, Benutzern und Bewertungen der Filme durch die Benutzer. Aus diesen Daten haben wir das folgende Eigenschaftsdiagramm erstellt: 

![\[Beispiel für ein Diagramm mit Filmeigenschaften unter Verwendung des MovieLens 100.000 Datensatzes\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/images/movie_property_graph_example.png)


**Knotenklassifizierung**: Im Datensatz oben ist `Genre` ein Eckpunkttyp, der über die Kante `included_in` mit dem Eckpunkttyp `Movie` verbunden ist. Wenn der Datensatz jedoch so angepasst wird, dass `Genre` zum [kategorischen](https://en.wikipedia.org/wiki/Categorical_variable) Feature für den Eckpunkttyp `Movie` wird, kann das Problem der Ableitung des Werts für `Genre` für neue, zum Wissensdiagramm hinzugefügte Filme mit Knotenklassifizierungsmodellen gelöst werden.

**Knotenregression**: Bei Betrachtung des Eckpunkttyps `Rating`, der Eigenschaften wie `timestamp` und `score` besitzt, kann das Problem der Ableitung des numerischen Werts für `Score` für `Rating` mit Knotenregressionsmodellen gelöst werden.

**Kantenklassifizierung**: Wenn wir bei einer `Rated` Kante über eine Eigenschaft verfügen, `Scale` die einen der Werte,,,,, haben kann `Love` `Like` `Dislike` `Neutral``Hate`, das Problem der Rückschlüsse auf die Kante `Scale` für eine neue `Rated` movies/ratings Kante ebenfalls mithilfe von Kantenklassifizierungsmodellen gelöst werden.

**Kantenregression**: Ähnlich kann für die gleiche `Rated`-Kante mit einer Eigenschaft `Score`, die einen numerischen Wert für die Bewertung enthält, kann dies anhand von Kantenregressionsmodellen abgeleitet werden.

**Linkvorhersage**: Probleme wie die Suche nach den zehn Benutzern, die einen bestimmten Film am wahrscheinlichsten bewerten werden, oder der Suche nach den zehn Filmen, die ein bestimmter Benutzer am wahrscheinlichsten bewerten wird, werden mit Linkvorhersagen gelöst.

**Anmerkung**  
Für Neptune-ML-Anwendungsfälle gibt es einen sehr umfangreichen Satz von Notebooks, die Ihnen ein praktisches Verständnis jedes Anwendungsfalls vermitteln sollen. Sie können diese Notizbücher zusammen mit Ihrem Neptune-Cluster erstellen, wenn Sie die Neptune [CloudFormation ML-Vorlage verwenden, um einen Neptune-ML-Cluster](machine-learning-quick-start.md) zu erstellen. Diese Notebooks sind auch auf [github](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks/04-Machine-Learning) verfügbar.

**Topics**
+ [

# In Gremlin-Inferenzabfragen verwendete Neptune-ML-Prädikate
](machine-learning-gremlin-inference-query-predicates.md)
+ [

# Gremlin-Knotenklassifizierungsabfragen in Neptune ML
](machine-learning-gremlin-vertex-classification-queries.md)
+ [

# Gremlin-Abfragen zur Knotenregression in Neptune ML
](machine-learning-gremlin-vertex-regression-queries.md)
+ [

# Gremlin-Kantenklassifizierungsabfragen in Neptune ML
](machine-learning-gremlin-edge-classification-queries.md)
+ [

# Gremlin-Abfragen zur Kantenregression in Neptune ML
](machine-learning-gremlin-edge-regression.md)
+ [

# Gremlin-Linkvorhersageabfragen mit Linkvorhersagemodellen in Neptune ML
](machine-learning-gremlin-link-prediction-queries.md)
+ [

# Liste der Ausnahmen für Neptune-ML-Gremlin-Inferenzabfragen
](machine-learning-gremlin-exceptions.md)

# In Gremlin-Inferenzabfragen verwendete Neptune-ML-Prädikate
Prädikate für Inferenzabfragen

## `Neptune#ml.deterministic`
`Neptune#ml.deterministic`

Dieses Prädikat ist eine Option für induktive Inferenzabfragen, d. h. für Abfragen, die das Prädikat [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference) enthalten.

Bei Verwendung der induktiven Inferenz erstellt die Neptune-Engine das entsprechende Unterdiagramm zur Auswertung des trainierten GNN-Modells. Die Anforderungen dieses Unterdiagramms sind von den Parametern des endgültigen Modells abhängig. Insbesondere bestimmt der Parameter `num-layer` die Anzahl der Traversierungs-Hops von den Zielknoten oder -kanten. Der Parameter `fanouts` gibt an, wie viele Nachbarn bei jedem Hop abgefragt werden sollen (siehe [HPO-Parameter](machine-learning-customizing-hyperparams.md)).

Standardmäßig werden induktive Inferenzabfragen nicht deterministisch ausgeführt, d. h. Neptune erstellt die Nachbarschaft in randomisierter Weise. Diese normalen Abfragen randomisierter Nachbarschaften führen manchmal zu unterschiedlichen Vorhersagen.

Wenn Sie `Neptune#ml.deterministic` in eine induktive Inferenzabfrage einfügen, versucht die Neptune-Engine, Nachbarn deterministisch abzufragen, sodass mehrere Aufrufe derselben Abfrage jedes Mal dieselben Ergebnisse zurückgeben. Es kann jedoch nicht garantiert werden, dass die Ergebnisse vollständig deterministisch sind, da Änderungen des zugrunde liegenden Diagramms und Artefakte verteilter Systeme weiter zu Schwankungen führen können.

Sie fügen das Prädikat `Neptune#ml.deterministic` in eine Abfrage wie die folgende ein:

```
.with("Neptune#ml.deterministic")
```

Wenn das Prädikat `Neptune#ml.deterministic` in einer Abfrage enthalten ist, die nicht auch `Neptune#ml.inductiveInference` enthält, wird es einfach ignoriert.

## `Neptune#ml.disableInductiveInferenceMetadataCache`
`Neptune#ml.disableInductiveInferenceMetadataCache `

Dieses Prädikat ist eine Option für induktive Inferenzabfragen, d. h. für Abfragen, die das Prädikat [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference) enthalten.

Für induktive Inferenzabfragen verwendet Neptune eine in Amazon S3 gespeicherte Metadatendatei, um bei der Erstellung der Nachbarschaft die Anzahl der Hops und den Fanout zu bestimmen. Neptune speichert diese Modellmetadaten normalerweise im Cache, um zu vermeiden, dass die Datei wiederholt aus Amazon S3 abgerufen wird. Das Caching kann durch Einfügen des Prädikats `Neptune#ml.disableInductiveInferenceMetadataCache` deaktiviert werden. Obwohl es für Neptune langsamer sein kann, die Metadaten direkt von Amazon S3 abzurufen, ist es nützlich, wenn der SageMaker KI-Endpunkt nach einem erneuten Training oder einer Transformation aktualisiert wurde und der Cache veraltet ist.

Sie fügen das Prädikat `Neptune#ml.disableInductiveInferenceMetadataCache` in eine Abfrage wie folgt ein:

```
.with("Neptune#ml.disableInductiveInferenceMetadataCache")
```

Dies ist ein Beispielabfrage in einem Jupyter-Notebook:

```
%%gremlin
g.with("Neptune#ml.endpoint", "ep1")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .with("Neptune#ml.disableInductiveInferenceMetadataCache")
 .V('101').properties("rating")
 .with("Neptune#ml.regression")
 .with("Neptune#ml.inductiveInference")
```

## `Neptune#ml.endpoint`
Neptune\$1ml.endpoint

Das Prädikat `Neptune#ml.endpoint` wird in einem `with()`-Schritt verwendet, um den Inferenzendpunkt anzugeben, wenn notwendig:

```
 .with("Neptune#ml.endpoint", "the model's SageMaker AI inference endpoint")
```

Sie können den Endpunkt anhand der `id` oder der URL identifizieren. Beispiel:

```
 .with( "Neptune#ml.endpoint", "node-classification-movie-lens-endpoint" )
```

Oder:

```
 .with( "Neptune#ml.endpoint", "https://runtime.sagemaker.us-east-1.amazonaws.com/endpoints/node-classification-movie-lens-endpoint/invocations" )
```

**Anmerkung**  
Wenn Sie [den Parameter`neptune_ml_endpoint`](machine-learning-cluster-setup.md#machine-learning-set-inference-endpoint-cluster-parameter) in Ihrer Neptune-DB-Cluster-Parametergruppe auf den Endpunkt `id` oder die URL festlegen, müssen Sie das Prädikat `Neptune#ml.endpoint` nicht in jede Abfrage einfügen.

## `Neptune#ml.iamRoleArn`
Neptune \$1ml. iamRoleArn

`Neptune#ml.iamRoleArn`wird in einem `with()` Schritt verwendet, um den ARN der SageMaker AI-Ausführungs-IAM-Rolle anzugeben, falls erforderlich:

```
 .with("Neptune#ml.iamRoleArn", "the ARN for the SageMaker AI execution IAM role")
```

Informationen zum Erstellen der IAM-Rolle für die SageMaker AI-Ausführung finden Sie unter. [Erstellen Sie eine benutzerdefinierte Rolle NeptuneSageMaker IAMRole](machine-learning-manual-setup.md#ml-manual-setup-sm-role)

**Anmerkung**  
Wenn Sie [den `neptune_ml_iam_role` Parameter](machine-learning-cluster-setup.md#machine-learning-enabling-create-param-group) in Ihrer Neptune DB-Cluster-Parametergruppe auf den ARN Ihrer IAM-Rolle für die SageMaker KI-Ausführung festlegen, müssen Sie das `Neptune#ml.iamRoleArn` Prädikat nicht in jede Abfrage aufnehmen.

## Neptune\$1ml.inductiveInference
Neptune\$1ml.inductiveInference

Die transduktive Inferenz ist in Gremlin standardmäßig aktiviert. Um eine [induktive Inferenzabfrage in Echtzeit](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) zu erstellen, fügen Sie das Prädikat `Neptune#ml.inductiveInference` wie folgt hinzu:

```
.with("Neptune#ml.inductiveInference")
```

Wenn Ihr Diagramm dynamisch ist, ist die induktive Inferenz häufig die beste Wahl. Wenn Ihr Diagramm jedoch statisch ist, ist die transduktive Inferenz schneller und effizienter.

## `Neptune#ml.limit`
Neptune\$1ml.limit

Das Prädikat `Neptune#ml.limit` begrenzt optional die Anzahl der Ergebnisse, die pro Entität zurückgegeben werden:

```
 .with( "Neptune#ml.limit", 2 )
```

Standardmäßig ist der Grenzwert 1. Die maximale Anzahl, die festgelegt werden kann, ist 100.

## `Neptune#ml.threshold`
Neptune\$1ml.threshold

Das Prädikat `Neptune#ml.threshold` legt optional einen Mindestwert für Ergebniswerte fest:

```
 .with( "Neptune#ml.threshold", 0.5D )
```

So werden alle Ergebnisse verworfen, deren Werte unter dem angegebenen Schwellenwert liegen.

## `Neptune#ml.classification`
Neptune\$1ml.classification

Das `Neptune#ml.classification` Prädikat wird an den `properties()` Schritt angehängt, um festzulegen, dass die Eigenschaften vom SageMaker KI-Endpunkt des Knotenklassifikationsmodells abgerufen werden müssen:

```
 .properties( "property key of the node classification model" ).with( "Neptune#ml.classification" )
```

## `Neptune#ml.regression`
Neptune\$1ml.regression

Das `Neptune#ml.regression` Prädikat wird an den `properties()` Schritt angehängt, um festzulegen, dass die Eigenschaften vom SageMaker KI-Endpunkt des Knotenregressionsmodells abgerufen werden müssen:

```
 .properties( "property key of the node regression model" ).with( "Neptune#ml.regression" )
```

## `Neptune#ml.prediction`
Neptune\$1ml.prediction

Das Prädikat `Neptune#ml.prediction` wird an die Schritte `in()` und `out()` angefügt, um festzulegen, dass es sich um eine Linkvorhersage-Abfrage handelt:

```
 .in("edge label of the link prediction model").with("Neptune#ml.prediction").hasLabel("target node label")
```

## `Neptune#ml.score`
Neptune\$1ml.score

Das Prädikat `Neptune#ml.score` wird in Abfragen zur Klassifizierung von Gremlin-Knoten oder -Kanten verwendet, um Machine-Learning-Konfidenzwerte abzurufen. Das Prädikat `Neptune#ml.score` sollte zusammen mit dem Abfrageprädikat im Schritt `properties()` übergeben werden, um ML-Konfidenzwerte für Abfragen zur Klassifizierung von Knoten oder Kanten zu erhalten.

Sie finden ein Beispiel für die Knotenklassifizierung mit [weiteren Beispielen für die Knotenklassifizierung](machine-learning-gremlin-vertex-classification-queries.md#machine-learning-gremlin-node-class-other-queries) und ein Beispiel für die Kantenklassifizierung im Abschnitt für die [Kantenklassifizierung](machine-learning-gremlin-edge-classification-queries.md).

# Gremlin-Knotenklassifizierungsabfragen in Neptune ML
Knotenklassifizierung

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](machine-learning-gremlin-exceptions.md).

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
Weitere Knotenklassifizierungsabfragen

Wenn sowohl der Inferenzendpunkt als auch die entsprechende IAM-Rolle in der DB-Cluster-Parametergruppe gespeichert wurden, kann eine Knotenklassifizierungsabfrage so einfach wie die folgende 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
Verwenden der induktiven Inferenz

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]
```

# Gremlin-Abfragen zur Knotenregression in Neptune ML
Knotenregression

Die Knotenregression ist der Knotenklassifizierung ähnlich. Der aus dem Regressionsmodell für jeden Knoten abgeleitete Wert ist jedoch numerisch. Sie können für die Knotenregression die gleichen Gremlin-Abfragen wie für die Knotenklassifizierung verwenden, mit einigen Unterschieden:
+ In Neptune ML beziehen sich Knoten auf Eckpunkte.
+ Der Schritt `properties()` hat statt `properties().with("Neptune#ml.regression")` das Format `properties().with("Neptune#ml.classification")`.
+ Die Prädikate `"Neptune#ml.limit` und `"Neptune#ml.threshold"` sind nicht anwendbar.
+ Wenn Sie nach dem Wert filtern, müssen Sie einen numerischen Wert angeben.

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

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

Sie können mithilfe eines Regressionsmodells nach dem abgeleiteten Wert filtern, wie in den folgenden Beispielen gezeigt:

```
g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("movie_1","movie_2","movie_3")
 .properties("revenue").with("Neptune#ml.regression")
 .value().is(P.gte(1600000))

g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("movie_1","movie_2","movie_3")
 .properties("revenue").with("Neptune#ml.regression")
 .hasValue(P.lte(1600000D))
```

## Verwenden der induktiven Inferenz in einer Knotenregressionsabfrage
Verwenden der induktiven Inferenz

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 eine Bewertung zu erhalten, die den neuen Knoten berücksichtigt:

```
%%gremlin
g.with("Neptune#ml.endpoint", "nr-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .V('101').properties("rating")
 .with("Neptune#ml.regression")
 .with("Neptune#ml.inductiveInference")
```

Da die Abfrage nicht deterministisch ist, kann sie je nach Nachbarschaft zu etwas anderen Ergebnissen führen, wenn Sie sie mehrmals ausführen:

```
# First time
==>vp[rating->9.1]

# Second time
==>vp[rating->8.9]
```

Wenn Sie konsistentere Ergebnisse benötigen, können Sie die Abfrage deterministisch gestalten:

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

Jetzt werden die Ergebnisse jedes Mal ungefähr gleich sein:

```
# First time
==>vp[rating->9.1]

# Second time
==>vp[rating->9.1]
```

# Gremlin-Kantenklassifizierungsabfragen in Neptune ML
Kantenklassifizierung

Für die Gremlin-Kantenklassifizierung in Neptune ML:
+ Das Modell wird anhand einer einzelnen Eigenschaft der Kanten trainiert. Der Satz der eindeutigen Werte dieser Eigenschaft wird als Satz von Klassen bezeichnet.
+ Der Klassen- oder kategorische Eigenschaftswert einer Kante kann aus dem Kantenklassifizierungsmodell abgeleitet werden. Dies ist nützlich, wenn diese Eigenschaft noch nicht mit der Kante verknüpft ist.
+ Um eine oder mehrere Klassen aus einem Kantenklassifikationsmodell 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 Kanteneigenschaften ähnlich.

**Anmerkung**  
Die Kantenklassifizierung 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 Kantenklassifizierung, bei der mithilfe des Prädikats `Neptune#ml.score` ein Konfidenzwert angefordert wird:

```
g.with("Neptune#ml.endpoint","edge-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .E("relationship_1","relationship_2","relationship_3")
 .properties("knows_by", "Neptune#ml.score").with("Neptune#ml.classification")
```

Die Antwort würde wie folgt aussehen:

```
==>p[knows_by->"Family"]
==>p[Neptune#ml.score->0.01234567]
==>p[knows_by->"Friends"]
==>p[Neptune#ml.score->0.543210]
==>p[knows_by->"Colleagues"]
==>p[Neptune#ml.score->0.10101]
```

## Syntax einer Gremlin-Kantenklassifizierungsabfrage
Kantenklassifizierungssyntax

Für ein einfaches Diagramm, in dem `User` der Kopf- und Endknoten ist und `Relationship` die Kante ist, die sie verbindet, wäre dies beispielsweise eine Abfrage zur Kantenklassifizierung:

```
g.with("Neptune#ml.endpoint","edge-classification-social-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .E("relationship_1","relationship_2","relationship_3")
 .properties("knows_by").with("Neptune#ml.classification")
```

Die Ausgabe dieser Abfrage sieht ähnlich wie folgt aus:

```
==>p[knows_by->"Family"]
==>p[knows_by->"Friends"]
==>p[knows_by->"Colleagues"]
```

In der Abfrage oben werden die Schritte `E()` und `properties()` wie folgt verwendet:
+ Der Schritt `E()` enthält den Satz von Kanten, für die Sie die Klassen aus dem Kantenklassifizierungsmodell abrufen möchten:

  ```
  .E("relationship_1","relationship_2","relationship_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 Kantenklassifizierung handelt.

Der Schritt `properties().with("Neptune#ml.classification")` unterstützt zurzeit mehrere Eigenschaftsschlüssel nicht. Die folgende Abfrage löst beispielsweise eine Ausnahme aus:

```
g.with("Neptune#ml.endpoint","edge-classification-social-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .E("relationship_1","relationship_2","relationship_3")
 .properties("knows_by", "other_label").with("Neptune#ml.classification")
```

Spezifische Fehlermeldungen finden Sie unter [Liste der Ausnahmen für Neptune-ML-Gremlin-Inferenzabfragen](machine-learning-gremlin-exceptions.md).

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()`

## Verwenden der induktiven Inferenz in einer Abfrage zur Kantenklassifizierung
Verwenden der induktiven Inferenz

Angenommen, Sie fügen einem vorhandenen Diagramm in einem Jupyter-Notebook eine neue Kante wie folgt hinzu:

```
%%gremlin
g.V('1').as('fromV')
.V('2').as('toV')
.addE('eLabel1').from('fromV').to('toV').property(id, 'e101')
```

Sie könnten dann eine induktive Inferenzabfrage verwenden, um eine Skala zu erhalten, die die neue Kante berücksichtigt:

```
%%gremlin
g.with("Neptune#ml.endpoint", "ec-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .E('e101').properties("scale", "Neptune#ml.score")
 .with("Neptune#ml.classification")
 .with("Neptune#ml.inductiveInference")
```

Da die Abfrage nicht deterministisch ist, kann sie je nach randomisierter Nachbarschaft zu etwas anderen Ergebnissen führen, wenn sie mehrmals ausgeführt wird:

```
# First time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]

# Second time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.21365921]
```

Wenn Sie konsistentere Ergebnisse benötigen, können Sie die Abfrage deterministisch gestalten:

```
%%gremlin
g.with("Neptune#ml.endpoint", "ec-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .E('e101').properties("scale", "Neptune#ml.score")
 .with("Neptune#ml.classification")
 .with("Neptune#ml.inductiveInference")
 .with("Neptune#ml.deterministic")
```

Jetzt sind die Ergebnisse bei jeder Ausführung der Abfrage mehr oder weniger gleich:

```
# First time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]

# Second time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]
```

# Gremlin-Abfragen zur Kantenregression in Neptune ML
Kantenregression

Die Kantenregression ist der Kantenklassifizierung ähnlich. Der aus dem ML-Modell abgeleitete Wert ist jedoch numerisch. Neptune ML unterstützt für die Kantenregression dieselben Abfragen wie für die Klassifizierung.

Wichtige Punkte, die beachtet werden müssen, sind:
+ Sie müssen das ML-Prädikat `"Neptune#ml.regression"` verwenden, um den Schritt `properties()` für diesen Anwendungsfall zu konfigurieren.
+ Die Prädikate `"Neptune#ml.limit"` und `"Neptune#ml.threshold"` sind in diesem Anwendungsfall nicht anwendbar.
+ Um nach dem Wert zu filtern, müssen Sie den Wert als numerisch angeben.

## Syntax einer Gremlin-Kantenregressionsabfrage
Kantenregressionssyntax

Für ein einfaches Diagramm, bei dem `User` der Kopfknoten, `Movie` der Endknoten und `Rated` die Kante ist, die diese verbindet, wäre dies ein Beispiel für eine Kantenregressionsabfrage, die den numerischen Wert der Bewertung (hier als Punktzahl bezeichnet) für die Kante `Rated` sucht:

```
g.with("Neptune#ml.endpoint","edge-regression-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .E("rating_1","rating_2","rating_3")
 .properties("score").with("Neptune#ml.regression")
```

Sie können auch nach einem Wert filtern, der aus dem ML-Regressionsmodell abgeleitet wurde. Für die vorhandenen `Rated`-Kanten (von `User` bis`Movie`), identifiziert durch`"rating_1"`, `"rating_2"` und `"rating_3"`, wobei die Kanteneigenschaft `Score` für diese Bewertungen nicht vorhanden ist, können Sie eine Abfrage wie die folgende verwenden, um `Score` für die Kanten abzuleiten, deren Wert größer oder gleich 9 ist:

```
g.with("Neptune#ml.endpoint","edge-regression-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .E("rating_1","rating_2","rating_3")
 .properties("score").with("Neptune#ml.regression")
 .value().is(P.gte(9))
```

## Verwenden der induktiven Inferenz in einer Kantenregressionsabfrage
Verwenden der induktiven Inferenz

Angenommen, Sie fügen einem vorhandenen Diagramm in einem Jupyter-Notebook eine neue Kante wie folgt hinzu:

```
%%gremlin
g.V('1').as('fromV')
.V('2').as('toV')
.addE('eLabel1').from('fromV').to('toV').property(id, 'e101')
```

Sie könnten dann eine induktive Inferenzabfrage verwenden, um eine Punktzahl zu erhalten, die die neue Kante berücksichtigt:

```
%%gremlin
g.with("Neptune#ml.endpoint", "er-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .E('e101').properties("score")
 .with("Neptune#ml.regression")
 .with("Neptune#ml.inductiveInference")
```

Da die Abfrage nicht deterministisch ist, kann sie je nach randomisierter Nachbarschaft zu etwas anderen Ergebnissen führen, wenn sie mehrmals ausgeführt wird:

```
# First time
==>ep[score->96]

# Second time
==>ep[score->91]
```

Wenn Sie konsistentere Ergebnisse benötigen, können Sie die Abfrage deterministisch gestalten:

```
%%gremlin
g.with("Neptune#ml.endpoint", "er-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .E('e101').properties("score")
 .with("Neptune#ml.regression")
 .with("Neptune#ml.inductiveInference")
 .with("Neptune#ml.deterministic")
```

Jetzt sind die Ergebnisse bei jeder Ausführung der Abfrage mehr oder weniger gleich:

```
# First time
==>ep[score->96]

# Second time
==>ep[score->96]
```

# Gremlin-Linkvorhersageabfragen mit Linkvorhersagemodellen in Neptune ML
Linkvorhersage

Modelle zur Linkvorhersage können Probleme wie die folgenden lösen:
+ **Vorhersage des Kopfknotens**: Mit welchen Eckpunkten ist ein bestimmter Eckpunkt wahrscheinlich verbunden, wenn ein Eckpunkt und ein Kantentyp vorhanden sind?
+ **Vorhersage des Endknotens**: Mit welchen Eckpunkten ist ein bestimmter Eckpunkt wahrscheinlich verbunden, wenn ein Eckpunkt und eine Kantenbezeichnung vorhanden sind?

**Anmerkung**  
Die Kantenvorhersage wird in Neptune ML noch nicht unterstützt.

Stellen Sie sich für die folgenden Beispiele ein einfaches Diagramm mit den Eckpunkten `User` und `Movie` vor, die durch die Kante `Rated` verbunden sind.

Dies ist ein Beispiel für eine Abfrage zur Vorhersage des Kopfknotens, um die fünf Benutzer vorherzusagen, die die Filme `"movie_1"`, `"movie_2"` und `"movie_3"` am wahrscheinlichsten bewerten werden:

```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .with("Neptune#ml.limit", 5)
 .V("movie_1", "movie_2", "movie_3")
 .in("rated").with("Neptune#ml.prediction").hasLabel("user")
```

Dies ist eine ähnliche Abfrage zur Vorhersage des Endknotens, um die fünf Filme vorherzusagen, die der Benutzer `"user_1"` wahrscheinlich bewerten wird:

```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("user_1")
 .out("rated").with("Neptune#ml.prediction").hasLabel("movie")
```

Sowohl die Kantenbezeichnung als auch die vorhergesagte Eckpunktbezeichnung sind erforderlich. Wird eins von beiden ausgelassen, wird eine Ausnahme ausgelöst. Beispielsweise löst die folgende Abfrage ohne vorhergesagte Eckpunktbezeichnung eine Ausnahme aus:

```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("user_1")
 .out("rated").with("Neptune#ml.prediction")
```

In ähnlicher Weise löst die folgende Abfrage ohne Kantenbezeichnung eine Ausnahme aus:

```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("user_1")
 .out().with("Neptune#ml.prediction").hasLabel("movie")
```

Die spezifische, von diesen Ausnahmen zurückgegebene Fehlermeldung finden Sie in der [Liste der Neptune-ML-Ausnahmen](machine-learning-gremlin-exceptions.md).

## Weitere Abfragen zur Linkvorhersage
Weitere Linkvorhersagen

Sie können Schritt `select()` mit Schritt `as(`) verwenden, um die vorhergesagten Eckpunkte zusammen mit den eingegebenen Eckpunkten auszugeben:

```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("movie_1").as("source")
 .in("rated").with("Neptune#ml.prediction").hasLabel("user").as("target")
 .select("source","target")

g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("user_1").as("source")
 .out("rated").with("Neptune#ml.prediction").hasLabel("movie").as("target")
 .select("source","target")
```

Sie können unbegrenzte Abfragen wie die folgenden erstellen:

```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("user_1")
 .out("rated").with("Neptune#ml.prediction").hasLabel("movie")

g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V("movie_1")
 .in("rated").with("Neptune#ml.prediction").hasLabel("user")
```

## Verwenden der induktiven Inferenz in einer Linkvorhersageabfrage
Verwenden der induktiven Inferenz

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('newV1')
 .addV('label2').property(id,'102').as('newV2')
 .V('1').as('oldV1')
 .V('2').as('oldV2')
 .addE('eLabel1').from('newV1').to('oldV1')
 .addE('eLabel2').from('oldV2').to('newV2')
```

Sie könnten dann eine induktive Inferenzabfrage verwenden, um den Kopfknoten unter Berücksichtigung des neuen Knotens vorherzusagen:

```
%%gremlin
g.with("Neptune#ml.endpoint", "lp-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .V('101').out("eLabel1")
 .with("Neptune#ml.prediction")
 .with("Neptune#ml.inductiveInference")
 .hasLabel("label2")
```

Ergebnis:

```
==>V[2]
```

Sie könnten dann auf ähnliche Weise mit einer induktiven Inferenzabfrage den Endknoten unter Berücksichtigung des neuen Knotens vorhersagen:

```
%%gremlin
g.with("Neptune#ml.endpoint", "lp-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .V('102').in("eLabel2")
 .with("Neptune#ml.prediction")
 .with("Neptune#ml.inductiveInference")
 .hasLabel("label1")
```

Ergebnis:

```
==>V[1]
```

# Liste der Ausnahmen für Neptune-ML-Gremlin-Inferenzabfragen
Ausnahmen sind vorhanden.

 Dies ist eine umfassende Liste von Ausnahmen, die bei der Ausführung von Neptune ML Gremlin-Inferenzabfragen auftreten können. Diese Ausnahmen decken eine Reihe von Problemen ab, von Problemen mit der angegebenen IAM-Rolle oder dem angegebenen Endpunkt bis hin zu nicht unterstützten Gremlin-Schritten und Einschränkungen bei der Anzahl der ML-Inferenzabfragen pro Abfrage. Jeder Eintrag enthält eine ausführliche Meldung, in der das Problem beschrieben wird. 
+ **`BadRequestException`**   –   Die Anmeldeinformationen für die angegebene Rolle können nicht geladen werden.

  *Meldung*: `Unable to load credentials for role: the specified IAM Role ARN.`
+ **`BadRequestException`**— Die angegebene IAM-Rolle ist nicht berechtigt, den SageMaker KI-Endpunkt aufzurufen.

  *Meldung*: `User: the specified IAM Role ARN is not authorized to perform: sagemaker:InvokeEndpoint on resource: the specified endpoint.`
+ **`BadRequestException`**   –   Der angegebene Endpunkt ist nicht vorhanden.

  *Meldung*: `Endpoint the specified endpoint not found.`
+ **`InternalFailureException`**   –   Es können keine Neptune-ML-Metadaten für induktive Inferenzen in Echtzeit aus Amazon S3 abgerufen werden.

  *Meldung*: `Unable to fetch Neptune ML - Real-Time Inductive Inference metadata from S3. Check the permissions of the S3 bucket or if the Neptune instance can connect to S3.`
+ **`InternalFailureException`**   –   Neptune ML kann die Metadatendatei für induktive Inferenzen in Echtzeit nicht in Amazon S3 finden.

  *Meldung*: `Neptune ML cannot find the metadata file for Real-Time Inductive Inference in S3.`
+ **`InvalidParameterException`**   –   Die Syntax des angegebenen Endpunkts ist nicht gültig.

  *Meldung*: `Invalid endpoint provided for external service query.`
+ **`InvalidParameterException`**— Der angegebene SageMaker Ausführungs-IAM-Rollen-ARN ist syntaktisch nicht gültig.

  *Meldung*: `Invalid IAM role ARN provided for external service query.`
+ **`InvalidParameterException`**   –   In Schritt `properties()` einer Abfrage sind mehrere Eigenschaftsschlüssel angegeben.

  *Meldung*: `ML inference queries are currently supported for one property key.`
+ **`InvalidParameterException`**   –   In einer Abfrage sind mehrere Kantenbezeichnungen angegeben.

  *Meldung*: `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`**   –   In einer Abfrage sind mehrere Einschränkungen für Eckpunktbezeichnungen angegeben.

  *Meldung*: `ML inference are currently supported only with one vertex label constraint.`
+ **`InvalidParameterException`**   –   In derselben Abfrage sind sowohl das Prädikat `Neptune#ml.classification` als auch das Prädikat `Neptune#ml.regression` vorhanden.

  *Meldung*: `Both regression and classification ML predicates cannot be specified in the query.`
+ **`InvalidParameterException`**   –   In Schritt `in()` oder `out()` einer Abfrage zur Linkvorhersage wurde mehr als eine Kantenbezeichnung angegeben.

  *Meldung*: `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`**   –   Es wurde mehr als ein Eigenschaftsschlüssel mit Neptune\$1ml.score angegeben.

  *Meldung*: `Neptune ML inference queries are currently supported for one property key and one Neptune#ml.score property key.`
+ **`MissingParameterException`**   –   Der Endpunkt wurde weder in der Abfrage noch als DB-Cluster-Parameter angegeben.

  *Meldung*: `No endpoint provided for external service query.`
+ **``MissingParameterException**— Die IAM-Rolle für die SageMaker AI-Ausführung wurde weder in der Abfrage noch als DB-Cluster-Parameter angegeben.

  *Meldung*: `No IAM role ARN provided for external service query.`
+ **`MissingParameterException`**   –   In Schritt `properties()` einer Abfrage fehlt der Eigenschaftsschlüssel.

  *Meldung*: `Property key needs to be specified using properties() step for ML inference queries.`
+ **`MissingParameterException`**   –   In Schritt `in()` oder `out()` einer Abfrage zur Linkvorhersage wurde keine Kantenbezeichnung angegeben.

  *Meldung*: `Edge label needs to be specified while using in() or out() step for ML inference queries.`
+ **`MissingParameterException`**   –   Es wurde kein Eigenschaftsschlüssel mit Neptune\$1ml.score angegeben.

  *Meldung*: `Property key needs to be specified along with Neptune#ml.score property key while using the properties() step for Neptune ML inference queries.`
+ **`UnsupportedOperationException`**   –   In einer Abfrage zur Linkvorhersage wird Schritt `both()` verwendet.

  *Meldung*: `ML inference queries are currently not supported with both() step.`
+ **`UnsupportedOperationException`**   –   In Schritt `has()` mit Schritt `in()` oder `out()` einer Abfrage zur Linkvorhersage-Abfrage wurde keine vorhergesagte Eckpunktbezeichnung angegeben.

  *Meldung*: `Predicted vertex label needs to be specified using has() step for ML inference queries.`
+ **`UnsupportedOperationException`**   –   Induktive Gremlin-ML-Inferenzabfragen werden zurzeit nicht mit nicht optimierten Schritten unterstützt.

  *Meldung*: `Neptune ML - Real-Time Inductive Inference queries are currently not supported with Gremlin steps which are not optimized for Neptune. Check the Neptune User Guide for a list of Neptune-optimized steps.`
+ **`UnsupportedOperationException`**   –   Neptune-ML-Inferenzabfragen werden zurzeit nicht innerhalb des Schritts `repeat` unterstützt.

  *Meldung*: `Neptune ML inference queries are currently not supported inside a repeat step.`
+ **`UnsupportedOperationException`**   –   Zurzeit wird nur eine Neptune-ML-Inferenzabfrage pro Gremlin-Abfrage unterstützt.

  *Meldung*: `Neptune ML inference queries are currently supported only with one ML inference query per gremlin query.`