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.
# Requêtes d'inférence dans Neptune ML
Vous pouvez utiliser Gremlin ou SPARQL pour interroger un point de terminaison d'inférence Neptune ML. Toutefois, l'[inférence inductive en temps réel](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) n'est actuellement prise en charge que pour les requêtes Gremlin.
# Requêtes d'inférence Gremlin dans Neptune ML
Comme décrit dans [Fonctionnalités de Neptune ML](machine-learning.md#machine-learning-capabilities), Neptune ML prend en charge les modèles d'entraînement qui peuvent effectuer les types de tâches d'inférence suivants :
+ **Classification de nœud** : prédit la fonctionnalité catégorielle d'une propriété de sommet.
+ **Régression de nœud** : prédit une propriété numérique d'un sommet.
+ **Classification d'arête** : prédit la fonctionnalité catégorielle d'une propriété d'arête.
+ **Régression d'arête** : prédit une propriété numérique d'une arête.
+ **Prédiction des liens** : prédit les nœuds de destination à partir d'un nœud source et d'une arête sortante, ou les nœuds sources à partir d'un nœud de destination et d'une arête entrante.
Nous pouvons illustrer ces différentes tâches à l'aide d'exemples utilisant le jeu de [données de MovieLens 100 000 unités](https://grouplens.org/datasets/movielens/100k/) fourni par [GroupLens Research](https://grouplens.org/datasets/movielens/). Ce jeu de données comprend des films, des utilisateurs et des évaluations de ces films par les utilisateurs, à partir desquels nous avons créé un graphe de propriétés comme celui-ci :
![\[Exemple de graphique des propriétés d'un film à l'aide du jeu de MovieLens données de 100 000\]](http://docs.aws.amazon.com/fr_fr/neptune/latest/userguide/images/movie_property_graph_example.png)
**Classification de nœud** : dans le jeu de données ci-dessus, `Genre` est un type de sommet connecté au type de sommet `Movie` par l'arête `included_in`. Toutefois, si nous modifions le jeu de données pour faire de `Genre` une fonctionnalité [catégorielle](https://en.wikipedia.org/wiki/Categorical_variable) du type de sommet `Movie`, le problème de la déduction de `Genre` pour les nouveaux films ajoutés au graphe de connaissances peut être résolu à l'aide de modèles de classification de nœud.
**Régression de nœud** : si nous considérons le type de sommet `Rating`, qui possède des propriétés telles que `timestamp` et `score`, le problème de l'inférence de la valeur numérique `Score` pour un élément `Rating` peut être résolu à l'aide de modèles de régression de nœud.
**Classification des arêtes** : De même, pour une `Rated` arête, si nous avons une propriété `Scale` qui peut avoir l'une des valeurs,,,,,`Love`,,`Like`,`Dislike`,, `Neutral``Hate`, alors le problème de la déduction de l'`Rated`arête `Scale` pour une nouvelle movies/ratings peut être résolu à l'aide de modèles de classification des arêtes.
**Régression d'arête** : de façon similaire, pour la même arête `Rated`, si une propriété `Score` contient une valeur numérique pour l'évaluation, celle-ci peut être déduite à partir des modèles de régression d'arête.
**Prédiction des liens** : des problèmes tels que la recherche des dix utilisateurs susceptibles d'évaluer le mieux un film donné ou la recherche des dix films qu'un utilisateur donné a le plus de chance d'évaluer relèvent de la prédiction des liens.
**Note**
Pour les cas d'utilisation de Neptune ML, nous disposons d'un ensemble très complet de blocs-notes conçus pour favoriser la compréhension pratique de chaque cas d'utilisation. Vous pouvez créer ces blocs-notes avec votre cluster Neptune en utilisant le modèle [Neptune CloudFormation ML pour créer un cluster Neptune ML](machine-learning-quick-start.md). Ces blocs-notes sont également disponibles sur [github](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks/04-Machine-Learning).
**Topics**
+ [Prédicats Neptune ML utilisés dans les requêtes d'inférence Gremlin](machine-learning-gremlin-inference-query-predicates.md)
+ [Requêtes de classification de nœud Gremlin dans Neptune ML](machine-learning-gremlin-vertex-classification-queries.md)
+ [Requêtes de régression de nœud Gremlin dans Neptune ML](machine-learning-gremlin-vertex-regression-queries.md)
+ [Requêtes de classification d'arête Gremlin dans Neptune ML](machine-learning-gremlin-edge-classification-queries.md)
+ [Requêtes de régression d'arête Gremlin dans Neptune ML](machine-learning-gremlin-edge-regression.md)
+ [Requêtes de prédiction de lien Gremlin utilisant des modèles de prédiction de lien dans Neptune ML](machine-learning-gremlin-link-prediction-queries.md)
+ [Liste des exceptions pour les requêtes d'inférence Gremlin de Neptune ML](machine-learning-gremlin-exceptions.md)
# Prédicats Neptune ML utilisés dans les requêtes d'inférence Gremlin
## `Neptune#ml.deterministic`
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`
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`
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`
`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
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`
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`
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`
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`
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`
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`
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).
# Requêtes de classification de nœud Gremlin dans Neptune ML
Pour la classification de nœud Gremlin dans Neptune ML :
+ Le modèle est entraîné sur une seule propriété des sommets. L'ensemble des valeurs uniques de cette propriété est appelé « ensemble de classes de nœuds », ou simplement « classes ».
+ La classe de nœuds ou la valeur de propriété catégorielle de la propriété d'un sommet peut être déduite du modèle de classification de nœud. Ceci est utile lorsque cette propriété n'est pas déjà attachée au sommet.
+ Pour extraire une ou plusieurs classes d'un modèle de classification de nœud, vous devez utiliser l'étape `with()` avec le prédicat `Neptune#ml.classification` pour configurer l'étape `properties()`. Le format de sortie est similaire à ce à quoi vous vous attendriez s'il s'agissait de propriétés de sommet.
**Note**
La classification de nœud ne fonctionne qu'avec les valeurs de propriété de type string. Cela signifie que des valeurs de propriété numériques telles que `0` ou `1` ne sont pas prises en charge, alors que les valeurs équivalentes de type string `"0"` et `"1"` le sont. De même, les valeurs de propriété booléenne `true` et `false` ne fonctionnent pas, mais `"true"` et `"false"` fonctionnent.
Voici un exemple de requête de classification de nœud :
```
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")
```
La sortie de cette requête ressemble à ce qui suit :
```
==>vp[genre->Action]
==>vp[genre->Crime]
==>vp[genre->Comedy]
```
Dans la requête ci-dessus, les étapes `V()` et `properties()` sont utilisées comme suit :
L'étape `V()` contient l'ensemble de sommets pour lequel vous souhaitez extraire les classes du modèle de classification de nœud :
```
.V( "movie_1", "movie_2", "movie_3" )
```
L'étape `properties()` contient la clé sur laquelle le modèle a été entraîné et contient `.with("Neptune#ml.classification")` pour indiquer qu'il s'agit d'une requête d'inférence ML de classification de nœud.
Les clés de propriété multiples ne sont actuellement pas prises en charge dans une étape `properties().with("Neptune#ml.classification")`. Par exemple, la requête suivante lève une exception :
```
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")
```
Pour le message d'erreur spécifique, consultez la [liste des exceptions de Neptune ML](machine-learning-gremlin-exceptions.md).
Une étape `properties().with("Neptune#ml.classification")` peut être utilisée en combinaison avec l'une quelconque des étapes suivantes :
+ `value()`
+ `value().is()`
+ `hasValue()`
+ `has(value,"")`
+ `key()`
+ `key().is()`
+ `hasKey()`
+ `has(key,"")`
+ `path()`
## Autres requêtes de classification de nœud
Si le point de terminaison d'inférence et le rôle IAM correspondant ont tous les deux été enregistrés dans le groupe de paramètres de votre cluster de bases de données, une requête de classification de nœud peut être aussi simple que ceci :
```
g.V("movie_1", "movie_2", "movie_3").properties("genre").with("Neptune#ml.classification")
```
Vous pouvez mélanger des propriétés et des classes de sommets dans une requête en utilisant l'étape `union()` :
```
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")
)
```
Vous pouvez également effectuer une requête illimitée telle que celle-ci :
```
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")
```
Vous pouvez récupérer les classes de nœuds ainsi que les sommets en utilisant l'étape `select()` associée à l'étape `as()` :
```
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")
```
Vous pouvez également filtrer les classes de nœuds, comme illustré dans ces exemples :
```
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"))
```
Vous pouvez obtenir un score de confiance pour la classification de nœud en utilisant le prédicat `Neptune#ml.score` :
```
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")
```
La réponse ressemble alors à ceci :
```
==>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]
```
## Utilisation de l'inférence inductive dans une requête de classification de nœud
Supposons que vous ajoutiez un nouveau nœud à un graphe existant, dans un bloc-notes Jupyter, comme suit :
```
%%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')
```
Vous pouvez ensuite utiliser une requête d'inférence inductive pour obtenir un genre et un score de confiance reflétant le nouveau nœud :
```
%%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")
```
Toutefois, si vous exécutez la requête plusieurs fois, vous pouvez obtenir des résultats quelque peu différents :
```
# First time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.21365921]
```
Vous pouvez rendre la même requête déterministe :
```
%%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")
```
Dans ce cas, les résultats sont à peu près les mêmes à chaque fois :
```
# First time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]
```
# Requêtes de régression de nœud Gremlin dans Neptune ML
La régression de nœud est similaire à la classification de nœud, si ce n'est que la valeur déduite du modèle de régression pour chaque nœud est numérique. Vous pouvez utiliser les mêmes requêtes Gremlin pour la régression de nœud que pour la classification de nœud, à l'exception des différences suivantes :
+ Encore une fois, dans Neptune ML, les nœuds font référence à des sommets.
+ L'étape `properties()` prend la forme `properties().with("Neptune#ml.regression")` à la place de `properties().with("Neptune#ml.classification")`.
+ Les prédicats `"Neptune#ml.limit`" et `"Neptune#ml.threshold"` ne sont pas applicables.
+ Quand vous filtrez sur la valeur, vous devez spécifier une valeur numérique.
Voici un exemple de requête de classification de sommet :
```
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")
```
Vous pouvez filtrer sur la valeur déduite à l'aide d'un modèle de régression, comme illustré dans les exemples suivants :
```
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))
```
## Utilisation de l'inférence inductive dans une requête de régression de nœud
Supposons que vous ajoutiez un nouveau nœud à un graphe existant, dans un bloc-notes Jupyter, comme suit :
```
%%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')
```
Vous pouvez ensuite utiliser une requête d'inférence inductive pour obtenir une évaluation prenant en compte le nouveau nœud :
```
%%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")
```
La requête n'étant pas déterministe, elle peut renvoyer des résultats légèrement différents si vous l'exécutez plusieurs fois, en fonction du voisinage :
```
# First time
==>vp[rating->9.1]
# Second time
==>vp[rating->8.9]
```
Si vous avez besoin de résultats plus cohérents, vous pouvez rendre la requête déterministe :
```
%%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")
```
Désormais, les résultats sont quasiment les mêmes à chaque fois :
```
# First time
==>vp[rating->9.1]
# Second time
==>vp[rating->9.1]
```
# Requêtes de classification d'arête Gremlin dans Neptune ML
Pour la classification d'arête Gremlin dans Neptune ML :
+ Le modèle est entraîné sur une seule propriété des arêtes. L'ensemble des valeurs uniques de cette propriété est appelé « ensemble de classes ».
+ La classe ou la valeur de propriété catégorielle d'une arête peut être déduite du modèle de classification d'arête, ce qui est utile quand cette propriété n'est pas encore attachée à l'arête.
+ Pour extraire une ou plusieurs classes d'un modèle de classification d'arête, vous devez utiliser l'étape `with()` avec le prédicat `"Neptune#ml.classification"` pour configurer l'étape `properties()`. Le format de sortie est similaire à celui auquel vous vous attendriez s'il s'agissait de propriétés d'arête.
**Note**
La classification d'arête ne fonctionne qu'avec les valeurs de propriété de type string. Cela signifie que des valeurs de propriété numériques telles que `0` ou `1` ne sont pas prises en charge, alors que les valeurs équivalentes de type string `"0"` et `"1"` le sont. De même, les valeurs de propriété booléenne `true` et `false` ne fonctionnent pas, mais `"true"` et `"false"` fonctionnent.
Voici un exemple de requête de classification d'arête qui demande un score de confiance en utilisant le prédicat `Neptune#ml.score` :
```
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")
```
La réponse ressemble alors à ceci :
```
==>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]
```
## Syntaxe d'une requête de classification d'arête Gremlin
Pour un graphe simple où `User` représente le nœud de tête et le nœud de queue, et où `Relationship` est l'arête qui les relie, voici un exemple de requête de classification d'arête :
```
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")
```
La sortie de cette requête ressemble à ce qui suit :
```
==>p[knows_by->"Family"]
==>p[knows_by->"Friends"]
==>p[knows_by->"Colleagues"]
```
Dans la requête ci-dessus, les étapes `E()` et `properties()` sont utilisées comme suit :
+ L'étape `E()` contient l'ensemble des arêtes pour lesquelles vous souhaitez extraire les classes du modèle de classification d'arête :
```
.E("relationship_1","relationship_2","relationship_3")
```
+ L'étape `properties()` contient la clé sur laquelle le modèle a été entraîné et contient `.with("Neptune#ml.classification")` pour indiquer qu'il s'agit d'une requête d'inférence ML de classification d'arête.
Les clés de propriété multiples ne sont actuellement pas prises en charge dans une étape `properties().with("Neptune#ml.classification")`. Par exemple, la requête suivante lève une exception :
```
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")
```
Pour des messages d'erreur spécifiques, consultez [Liste des exceptions pour les requêtes d'inférence Gremlin de Neptune ML](machine-learning-gremlin-exceptions.md).
Une étape `properties().with("Neptune#ml.classification")` peut être utilisée en combinaison avec l'une quelconque des étapes suivantes :
+ `value()`
+ `value().is()`
+ `hasValue()`
+ `has(value,"")`
+ `key()`
+ `key().is()`
+ `hasKey()`
+ `has(key,"")`
+ `path()`
## Utilisation de l'inférence inductive dans une requête de classification d'arête
Supposons que vous ajoutiez une nouvelle arête à un graphe existant, dans un bloc-notes Jupyter, comme suit :
```
%%gremlin
g.V('1').as('fromV')
.V('2').as('toV')
.addE('eLabel1').from('fromV').to('toV').property(id, 'e101')
```
Vous pouvez ensuite utiliser une requête d'inférence inductive pour obtenir une échelle prenant en compte la nouvelle arête :
```
%%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")
```
La requête n'étant pas déterministe, elle peut renvoyer des résultats légèrement différents si vous l'exécutez plusieurs fois, en fonction du voisinage aléatoire :
```
# First time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.21365921]
```
Si vous avez besoin de résultats plus cohérents, vous pouvez rendre la requête déterministe :
```
%%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")
```
Désormais, les résultats sont plus ou moins les mêmes chaque fois que vous exécutez la requête :
```
# First time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]
```
# Requêtes de régression d'arête Gremlin dans Neptune ML
La régression d'arête est similaire à la classification d'arête, si ce n'est que la valeur déduite du modèle ML est numérique. Pour la régression d'arête, Neptune ML prend en charge les mêmes requêtes que pour la classification.
Les principaux points à noter sont les suivants :
+ Vous devez utiliser le prédicat ML `"Neptune#ml.regression"` pour configurer l'étape `properties()` correspondant à ce cas d'utilisation.
+ Les prédicats `"Neptune#ml.limit"` et `"Neptune#ml.threshold"` ne sont pas applicables dans ce cas d'utilisation.
+ Pour filtrer sur la valeur, vous devez spécifier la valeur sous forme numérique.
## Syntaxe d'une requête de régression d'arête Gremlin
Pour un graphe simple où `User` est le nœud de tête, `Movie` le nœud de queue et `Rated` l'arête qui les relie, voici un exemple de requête de régression d'arête qui recherche la valeur d'évaluation numérique, appelée score ici, pour l'arête `Rated` :
```
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")
```
Vous pouvez également filtrer sur une valeur déduite du modèle de régression ML. Pour les arêtes `Rated` existantes (de `User` à `Movie`) identifiées par `"rating_1"`, `"rating_2"` et `"rating_3"`, pour lesquelles la propriété d'arête `Score` n'est pas présente pour ces notations, vous pouvez utiliser une requête comme la suivante pour déduire `Score` pour les arêtes où elle est supérieure ou égale à 9 :
```
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))
```
## Utilisation de l'inférence inductive dans une requête de régression d'arête
Supposons que vous ajoutiez une nouvelle arête à un graphe existant, dans un bloc-notes Jupyter, comme suit :
```
%%gremlin
g.V('1').as('fromV')
.V('2').as('toV')
.addE('eLabel1').from('fromV').to('toV').property(id, 'e101')
```
Vous pouvez ensuite utiliser une requête d'inférence inductive pour obtenir un score prenant en compte la nouvelle arête :
```
%%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")
```
La requête n'étant pas déterministe, elle peut renvoyer des résultats légèrement différents si vous l'exécutez plusieurs fois, en fonction du voisinage aléatoire :
```
# First time
==>ep[score->96]
# Second time
==>ep[score->91]
```
Si vous avez besoin de résultats plus cohérents, vous pouvez rendre la requête déterministe :
```
%%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")
```
Désormais, les résultats sont plus ou moins les mêmes chaque fois que vous exécutez la requête :
```
# First time
==>ep[score->96]
# Second time
==>ep[score->96]
```
# Requêtes de prédiction de lien Gremlin utilisant des modèles de prédiction de lien dans Neptune ML
Les modèles de prédiction de lien peuvent résoudre des problèmes tels que les suivants :
+ **Prédiction de nœud de tête** : étant donné un sommet et un type d'arête, à partir de quels sommets est-il probable que ce sommet soit lié ?
+ **Prédiction de nœud de queue** : étant donné un sommet et une étiquette d'arête, à quels sommets est-il probable que ce sommet soit lié ?
**Note**
La prédiction d'arête n'est pas encore prise en charge dans Neptune ML.
Pour les exemples ci-dessous, considérez un graphe simple avec les sommets `User` et `Movie` liés par l'arête `Rated`.
Voici un exemple de requête de prédiction de nœud de tête, utilisé pour prédire les cinq utilisateurs qui ont le plus de chance d'évaluer les films `"movie_1"`, `"movie_2"` et `"movie_3"` :
```
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")
```
Voici un exemple similaire pour la prédiction de nœud de queue, utilisé pour prédire les cinq films qu'il est le plus probable que l'utilisateur `"user_1"` évalue :
```
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")
```
L'étiquette d'arête et l'étiquette de sommet prédit sont toutes deux obligatoires. Si l'une d'elles est omise, une exception est levée. Par exemple, la requête suivante sans étiquette de sommet prédit lève une exception :
```
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")
```
De façon similaire, la requête suivante sans étiquette d'arête lève une exception :
```
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")
```
Pour connaître les messages d'erreur spécifiques renvoyés par ces exceptions, consultez la [liste des exceptions de Neptune ML](machine-learning-gremlin-exceptions.md).
## Autres requêtes de prédiction de lien
Vous pouvez utiliser l'étape `select()` avec l'étape `as(`) pour générer les sommets prédits avec les sommets en entrée :
```
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")
```
Vous pouvez effectuer des requêtes illimitées, comme celles-ci :
```
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")
```
## Utilisation de l'inférence inductive dans une requête de prédiction de lien
Supposons que vous ajoutiez un nouveau nœud à un graphe existant, dans un bloc-notes Jupyter, comme suit :
```
%%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')
```
Vous pouvez alors utiliser une requête d'inférence inductive pour prédire le nœud de tête, en tenant compte du nouveau nœud :
```
%%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")
```
Résultat :
```
==>V[2]
```
De façon similaire, vous pouvez utiliser une requête d'inférence inductive pour prédire le nœud de queue, en tenant compte du nouveau nœud :
```
%%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")
```
Résultat :
```
==>V[1]
```
# Liste des exceptions pour les requêtes d'inférence Gremlin de Neptune ML
Il s'agit d'une liste complète des exceptions qui peuvent se produire lors de l'exécution de requêtes d'inférence Neptune ML Gremlin. Ces exceptions couvrent toute une série de problèmes, tels que les problèmes liés au rôle ou au point de terminaison IAM spécifié, aux étapes Gremlin non prises en charge et aux limitations du nombre de requêtes d'inférence ML par requête. Chaque entrée inclut un message détaillé décrivant le problème.
+ **`BadRequestException`** : les informations d'identification pour le rôle fourni ne peuvent pas être chargées.
*Message* : `Unable to load credentials for role: the specified IAM Role ARN.`
+ **`BadRequestException`**— Le rôle IAM spécifié n'est pas autorisé à invoquer le point de terminaison SageMaker AI.
*Message* : `User: the specified IAM Role ARN is not authorized to perform: sagemaker:InvokeEndpoint on resource: the specified endpoint.`
+ **`BadRequestException`** : le point de terminaison spécifié n'existe pas.
*Message* : `Endpoint the specified endpoint not found.`
+ **`InternalFailureException`** : impossible d'extraire les métadonnées d'inférence inductive en temps réel de Neptune ML depuis Amazon S3.
*Message* : `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 ne trouve pas le fichier de métadonnées pour l'inférence inductive en temps réel dans Amazon S3.
*Message* : `Neptune ML cannot find the metadata file for Real-Time Inductive Inference in S3.`
+ **`InvalidParameterException`** : le point de terminaison spécifié n'est pas valide syntaxiquement.
*Message* : `Invalid endpoint provided for external service query.`
+ **`InvalidParameterException`**— L'ARN du rôle IAM SageMaker d'exécution spécifié n'est pas syntaxiquement valide.
*Message* : `Invalid IAM role ARN provided for external service query.`
+ **`InvalidParameterException`** : plusieurs clés de propriété sont spécifiées à l'étape `properties()` d'une requête.
*Message* : `ML inference queries are currently supported for one property key.`
+ **`InvalidParameterException`** : plusieurs étiquettes d'arête sont spécifiées dans une requête.
*Message* : `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`** : plusieurs contraintes d'étiquette de sommet sont spécifiées dans une requête.
*Message* : `ML inference are currently supported only with one vertex label constraint.`
+ **`InvalidParameterException`** : les deux prédicats `Neptune#ml.classification` et `Neptune#ml.regression` sont présents dans la même requête.
*Message* : `Both regression and classification ML predicates cannot be specified in the query.`
+ **`InvalidParameterException`** : plusieurs étiquettes d'arête ont été spécifiées à l'étape `in()` ou `out()` dans une requête de prédiction de lien.
*Message* : `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`** : plusieurs clés de propriété ont été spécifiées avec Neptune\$1ml.score.
*Message* : `Neptune ML inference queries are currently supported for one property key and one Neptune#ml.score property key.`
+ **`MissingParameterException`** : le point de terminaison n'a pas été spécifié dans la requête ou en tant que paramètre de cluster de bases de données.
*Message* : `No endpoint provided for external service query.`
+ **``MissingParameterException**— Le rôle IAM d'exécution de l' SageMaker IA n'a pas été spécifié dans la requête ni en tant que paramètre de cluster de base de données.
*Message* : `No IAM role ARN provided for external service query.`
+ **`MissingParameterException`** : la clé de propriété est absente de l'étape `properties()` d'une requête.
*Message* : `Property key needs to be specified using properties() step for ML inference queries.`
+ **`MissingParameterException`** : aucune étiquette d'arête n'a été spécifiée à l'étape `in()` ou `out()` d'une requête de prédiction de lien.
*Message* : `Edge label needs to be specified while using in() or out() step for ML inference queries.`
+ **`MissingParameterException`** : aucune clé de propriété n'a été spécifiée avec Neptune\$1ml.score.
*Message* : `Property key needs to be specified along with Neptune#ml.score property key while using the properties() step for Neptune ML inference queries.`
+ **`UnsupportedOperationException`** : l'étape `both()` est utilisée dans une requête de prédiction de lien.
*Message* : `ML inference queries are currently not supported with both() step.`
+ **`UnsupportedOperationException`** : aucune étiquette de sommet prédit n'a été spécifiée à l'étape `has()` avec l'étape `in()` ou `out()` dans une requête de prédiction de lien.
*Message* : `Predicted vertex label needs to be specified using has() step for ML inference queries.`
+ **`UnsupportedOperationException`** : les requêtes d'inférence inductive ML Gremlin ne sont actuellement pas prises en charge avec des étapes non optimisées.
*Message* : `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`** : les requêtes d'inférence Neptune ML ne sont actuellement pas prises en charge dans une étape `repeat`.
*Message* : `Neptune ML inference queries are currently not supported inside a repeat step.`
+ **`UnsupportedOperationException`** : pas plus d'une seule requête d'inférence Neptune ML n'est actuellement prise en charge par requête Gremlin.
*Message* : `Neptune ML inference queries are currently supported only with one ML inference query per gremlin query.`
# Requêtes d'inférence SPARQL dans Neptune ML
Neptune ML mappe le graphe RDF dans un graphe de propriétés pour modéliser la tâche ML. Actuellement, il prend en charge les cas d'utilisation suivants :
+ **Classification d'objet** : prédit la fonctionnalité catégorielle d'un objet.
+ **Régression d'objet** : prédit une propriété numérique d'un objet.
+ **Prédiction d'objet** : prédit un objet en fonction d'un sujet et d'une relation.
+ **Prédiction de sujet** : prédit un sujet en fonction d'un objet et d'une relation.
**Note**
Neptune ML ne prend pas en charge les cas d'utilisation de régression et de classification de sujet avec SPARQL.
# Prédicats Neptune ML utilisés dans les requêtes d'inférence SPARQL
Les prédicats suivants sont utilisés avec l'inférence SPARQL :
## Prédicat `neptune-ml:timeout`
Spécifie le délai d'expiration de la connexion avec le serveur distant. À ne pas confondre avec le délai d'expiration de la demande de requête, qui est le temps maximal que le serveur peut mettre pour satisfaire une demande.
Notez que si le délai d'expiration de requête survient avant le délai d'expiration du service spécifié par le prédicat `neptune-ml:timeout`, la connexion au service est également annulée.
## Prédicat `neptune-ml:outputClass`
Le prédicat `neptune-ml:outputClass` est uniquement utilisé pour définir la classe de l'objet prédit pour la prédiction d'objet ou du sujet prédit pour la prédiction de sujet.
## Prédicat `neptune-ml:outputScore`
Le prédicat `neptune-ml:outputScore` est un nombre positif qui représente la probabilité que la sortie d'un modèle de machine learning soit correcte.
## Prédicat `neptune-ml:modelType`
Le prédicat `neptune-ml:modelType` indique le type de modèle de machine learning en cours d'entraînement :
+ `OBJECT_CLASSIFICATION`
+ `OBJECT_REGRESSION`
+ `OBJECT_PREDICTION`
+ `SUBJECT_PREDICTION`
## Prédicat `neptune-ml:input`
Le `neptune-ml:input` prédicat fait référence à la liste des entrées URIs utilisées pour Neptune ML.
## Prédicat `neptune-ml:output`
Le prédicat `neptune-ml:output` fait référence à la liste des ensembles de liaisons où Neptune ML renvoie les résultats.
## Prédicat `neptune-ml:predicate`
Le prédicat `neptune-ml:predicate` est utilisé différemment en fonction de la tâche exécutée :
+ Pour une **prédiction d'objet ou de sujet** : définit le type de prédicat (type d'arête ou de relation).
+ Pour une **classification et régression d'objet** : définit le littéral (propriété) que nous voulons prédire.
## Prédicat `neptune-ml:batchSize`
`neptune-ml:batchSize` spécifie la taille d'entrée pour l'appel de service à distance.
# Exemples de classification d'objet SPARQL
Pour une classification d'objet SPARQL dans Neptune ML, le modèle est entraîné sur l'une des valeurs de prédicat. Ceci est utile lorsque ce prédicat n'est pas déjà présent avec un sujet donné.
Seules les valeurs de prédicat catégorielles peuvent être déduites à l'aide du modèle de classification d'objet.
La requête suivante cherche à prédire la valeur de prédicat pour toutes les entrées de type `foaf:Person` :
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:modelType 'OBJECT_CLASSIFICATION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output .
}
}
```
Cette requête peut être personnalisée comme suit :
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:endpoint 'node-prediction-account-balance-endpoint' ;
neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ;
neptune-ml:batchSize "40"^^xsd:integer ;
neptune-ml:timeout "1000"^^xsd:integer ;
neptune-ml:modelType 'OBJECT_CLASSIFICATION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output .
}
}
```
# Exemples de régression d'objet SPARQL
La régression d'objet est similaire à la classification d'objet, si ce n'est qu'une valeur de prédicat numérique est déduite du modèle de régression pour chaque nœud. Vous pouvez utiliser les mêmes requêtes SPARQL pour la régression d'objet que pour la classification d'objet, à l'exception du fait que les prédicats `the Neptune#ml.limit` et `Neptune#ml.threshold` ne sont pas applicables.
La requête suivante cherche à prédire la valeur de prédicat pour toutes les entrées de type `foaf:Person` :
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:modelType 'OBJECT_REGRESSION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output .
}
}
```
Cette requête peut être personnalisée comme suit :
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:endpoint 'node-prediction-account-balance-endpoint' ;
neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ;
neptune-ml:batchSize "40"^^xsd:integer ;
neptune-ml:timeout "1000"^^xsd:integer ;
neptune-ml:modelType 'OBJECT_REGRESSION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output .
}
}
```
# Exemple de prédiction d'objet SPARQL
La *prédiction d'objet* prédit la valeur de l'objet pour un sujet et un prédicat donnés.
La requête de prédiction d'objet suivante cherche à prédire quel film l'entrée de type `foaf:Person` aimerait :
```
?x a foaf:Person .
?x ?m .
?m a .
## Query
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:modelType 'OBJECT_PREDICTION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output ;
neptune-ml:outputClass .
}
}
```
La requête elle-même peut être personnalisée comme suit :
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:endpoint 'node-prediction-user-movie-prediction-endpoint' ;
neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ;
neptune-ml:limit "5"^^xsd:integer ;
neptune-ml:batchSize "40"^^xsd:integer ;
neptune-ml:threshold "0.1"^^xsd:double ;
neptune-ml:timeout "1000"^^xsd:integer ;
neptune-ml:outputScore ?score ;
neptune-ml:modelType 'OBJECT_PREDICTION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output ;
neptune-ml:outputClass .
}
}
```
# Exemple de prédiction de sujet SPARQL
La *prédiction de sujet* prédit le sujet pour un prédicat et un objet donnés.
Par exemple, la requête suivante prédit qui (de type `foaf:User`) regardera un film donné :
```
SELECT * WHERE { ?input (a foaf:Movie) .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:modelType 'SUBJECT_PREDICTION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output ;
neptune-ml:outputClass ; }
}
```
# Liste des exceptions pour les requêtes d'inférence SPARQL de Neptune ML
****
+ **`BadRequestException`** – *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects at least 1 value for the parameter (parameter name), found zero.`
+ **`BadRequestException`** – *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects at most 1 value for the parameter (parameter name), found (a number) values.`
+ **`BadRequestException`** – *Message* : `Invalid predicate (predicate name) provided for external service http://aws.amazon.com/neptune/vocab/v01/services/ml#inference query.`
+ **`BadRequestException`** – *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the predicate (predicate name) to be defined`.
+ **`BadRequestException`** – *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the value of (parameter) (parameter name) to be a variable, found: (type)"`
+ **`BadRequestException`** – *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the input (parameter name) to be a constant, found: (type)`.
+ **`BadRequestException`** – *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference is expected to return only 1 value`.
+ **`BadRequestException`** – *Message* : `"The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference only allows StatementPatternNodes`.
+ **`BadRequestException`** – *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference does not allow the predicate (predicate name)`.
+ **`BadRequestException`** – *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference predicates cannot be variables, found: (type)`.
+ **`BadRequestException`** – *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference predicates are expected to be part of the namespace (namespace name), found: (namespace name)`.