Requêtes de classification de nœud Gremlin dans Neptune ML - Amazon Neptune
Classification de nœud supplémentaireUtilisation de l'inférence inductive

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

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 IAM rôle correspondant ont été enregistrés dans le groupe de paramètres de votre cluster de base de données, une requête de classification de nœuds 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]