Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Prédicats Neptune ML utilisés dans les requêtes d'inférence Gremlin
<a name="machine-learning-gremlin-inference-query-predicates"></a>

## `Neptune#ml.deterministic`
<a name="machine-learning-gremlin-inference-neptune-ml-deterministic-predicate"></a>

Ce prédicat est une option pour les requêtes d'inférence inductive, c'est-à-dire pour les requêtes qui incluent le prédicat [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference).

Lors de l'utilisation de l'inférence inductive, le moteur Neptune crée le sous-graphe approprié pour évaluer le modèle GNN entraîné, et les exigences de ce sous-graphe dépendent des paramètres du modèle final. Plus précisément, le paramètre `num-layer` détermine le nombre de sauts de traversée depuis les arêtes ou les nœuds cibles, et le paramètre `fanouts` spécifie le nombre de voisins à échantillonner à chaque saut (voir [Paramètres HPO](machine-learning-customizing-hyperparams.md)).

Par défaut, les requêtes d'inférence inductive s'exécutent en mode non déterministe, dans lequel Neptune construit le voisinage de manière aléatoire. Lors de la réalisation de prédictions, cet échantillonnage normal de voisins aléatoires fournit parfois des prédictions différentes.

Lorsque vous incluez `Neptune#ml.deterministic` dans une requête d'inférence inductive, le moteur Neptune tente d'échantillonner les voisins de manière déterministe afin que plusieurs invocations de la même requête renvoient les mêmes résultats à chaque fois. Il n'est toutefois pas possible de garantir des résultats totalement déterministes, car les modifications apportées au graphe sous-jacent et les artefacts des systèmes distribués peuvent toujours introduire des fluctuations.

Vous incluez le prédicat `Neptune#ml.deterministic` dans une requête comme suit :

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

Si le prédicat `Neptune#ml.deterministic` est inclus dans une requête qui n'inclut pas également `Neptune#ml.inductiveInference`, il est tout simplement ignoré.

## `Neptune#ml.disableInductiveInferenceMetadataCache`
<a name="machine-learning-gremlin-disableInductiveInferenceMetadataCache-predicate"></a>

Ce prédicat est une option pour les requêtes d'inférence inductive, c'est-à-dire pour les requêtes qui incluent le prédicat [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference).

Pour les requêtes d'inférence inductive, Neptune utilise un fichier de métadonnées stocké dans Amazon S3 pour décider du nombre de sauts et de la diffusion en éventail lors de la construction du voisinage. Neptune met normalement en cache les métadonnées de ce modèle pour éviter de récupérer le fichier à plusieurs reprises depuis Amazon S3. La mise en cache peut être désactivée en incluant le prédicat `Neptune#ml.disableInductiveInferenceMetadataCache` dans la requête. Bien que Neptune puisse être plus lent à récupérer les métadonnées directement depuis Amazon S3, cela est utile lorsque le point de terminaison SageMaker AI a été mis à jour après un réentraînement ou une transformation et que le cache est périmé.

Vous incluez le prédicat `Neptune#ml.disableInductiveInferenceMetadataCache` dans une requête comme suit :

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

Voici à quoi peut ressembler un exemple de requête dans un bloc-notes Jupyter :

```
%%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`
<a name="machine-learning-gremlin-inference-neptune-ml-endpoint-predicate"></a>

Le prédicat `Neptune#ml.endpoint` est utilisé dans une étape `with()` pour spécifier le point de terminaison d'inférence, si nécessaire :

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

Vous pouvez identifier le point de terminaison par son `id` ou son URL. Par exemple :

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

Ou:

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

**Note**  
Si vous [définissez le paramètre `neptune_ml_endpoint`](machine-learning-cluster-setup.md#machine-learning-set-inference-endpoint-cluster-parameter) dans votre groupe de paramètres de cluster de bases de données Neptune sur l'`id` ou l'URL du point de terminaison, vous n'avez pas besoin d'inclure le prédicat `Neptune#ml.endpoint` dans chaque requête.

## `Neptune#ml.iamRoleArn`
<a name="machine-learning-gremlin-inference-neptune-ml-iamRoleArn-predicate"></a>

`Neptune#ml.iamRoleArn`est utilisé dans une `with()` étape pour spécifier l'ARN du rôle IAM d'exécution de l' SageMaker IA, si nécessaire :

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

Pour plus d'informations sur la création du rôle IAM d'exécution de l' SageMaker IA, consultez[Création d'un NeptuneSageMaker IAMRole rôle personnalisé](machine-learning-manual-setup.md#ml-manual-setup-sm-role).

**Note**  
Si vous [définissez le `neptune_ml_iam_role` paramètre](machine-learning-cluster-setup.md#machine-learning-enabling-create-param-group) dans le groupe de paramètres de votre cluster de base de données Neptune sur l'ARN de votre rôle IAM d'exécution SageMaker AI, vous n'avez pas besoin d'inclure le `Neptune#ml.iamRoleArn` prédicat dans chaque requête.

## Neptune\$1ml.inductiveInference
<a name="machine-learning-gremlin-inference-neptune-ml-inductiveInference"></a>

L'inférence transductive est activée par défaut dans Gremlin. Pour effectuer une requête d'[inférence inductive en temps réel](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference), incluez le prédicat `Neptune#ml.inductiveInference` comme suit :

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

Si votre graphe est dynamique, l'inférence inductive est souvent le meilleur choix, mais si votre graphe est statique, l'inférence transductive est plus rapide et plus efficace.

## `Neptune#ml.limit`
<a name="machine-learning-gremlin-inference-neptune-ml-limit-predicate"></a>

Le prédicat `Neptune#ml.limit` limite éventuellement le nombre de résultats renvoyés par entité :

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

Par défaut, la limite est de 1 et le nombre maximal pouvant être défini est de 100.

## `Neptune#ml.threshold`
<a name="machine-learning-gremlin-inference-neptune-ml-threshold-predicate"></a>

Le prédicat `Neptune#ml.threshold` établit éventuellement un seuil limite pour les scores de résultat :

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

Cela vous permet de rejeter tous les résultats dont les scores sont inférieurs au seuil spécifié.

## `Neptune#ml.classification`
<a name="machine-learning-gremlin-inference-neptune-ml-classification-predicate"></a>

Le `Neptune#ml.classification` prédicat est attaché à l'`properties()`étape visant à établir que les propriétés doivent être extraites du point de terminaison SageMaker AI du modèle de classification des nœuds :

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

## `Neptune#ml.regression`
<a name="machine-learning-gremlin-inference-neptune-ml-regression-predicate"></a>

Le `Neptune#ml.regression` prédicat est attaché à l'`properties()`étape visant à établir que les propriétés doivent être extraites du point de terminaison SageMaker AI du modèle de régression des nœuds :

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

## `Neptune#ml.prediction`
<a name="machine-learning-gremlin-inference-neptune-ml-prediction-predicate"></a>

Le prédicat `Neptune#ml.prediction` est attaché aux étapes `in()` et `out()` pour établir qu'il s'agit d'une requête de prédiction de lien :

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

## `Neptune#ml.score`
<a name="machine-learning-gremlin-inference-neptune-ml-score-predicate"></a>

Le prédicat `Neptune#ml.score` est utilisé dans les requêtes de classification de nœud ou d'arête de Gremlin pour extraire un score de confiance de machine learning. Le prédicat `Neptune#ml.score` doit être transmis avec le prédicat de requête à l'étape `properties()` afin d'obtenir un score de confiance ML pour les requêtes de classification de nœud ou d'arête.

Vous pouvez trouver un exemple de classification de nœud avec [d'autres exemples de classification de nœud](machine-learning-gremlin-vertex-classification-queries.md#machine-learning-gremlin-node-class-other-queries), et un exemple de classification d'arête dans la section [Classification d'arête](machine-learning-gremlin-edge-classification-queries.md).