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

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.

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).

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.

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" )

Neptune#ml.iamRoleArn

Neptune#ml.iamRoleArnest 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, consultezCréation d'un NeptuneSageMaker IAMRole rôle personnalisé.

Neptune#ml.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, 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, et un exemple de classification d'arête dans la section Classification d'arête.