Consultas de clasificación de nodos de Gremlin en Neptune ML

Para la clasificación de nodos de Gremlin en Neptune ML:

• El modelo se entrena en una propiedad de los vértices. El conjunto de valores únicos de esta propiedad se denomina conjunto de clases de nodos o, simplemente, clases.

• La clase de nodo o el valor de la propiedad categórica de la propiedad de un vértice se pueden inferir del modelo de clasificación de nodos. Esto es útil cuando esta propiedad aún no está asociada al vértice.

• Para obtener una o varias clases de un modelo de clasificación de nodos, debe usar el paso with() con el predicado Neptune#ml.classification para configurar el paso properties(). El formato de salida es similar al que cabría esperar si se trataran de propiedades de vértices.

nota

La clasificación de nodos solo funciona con valores de propiedades de cadena. Esto significa que no se admiten valores de propiedades numéricas como 0 o 1, aunque sí se admiten los equivalentes de cadena "0" y "1". Del mismo modo, los valores de la propiedad Boolean true y false no funcionan, pero sí lo hacen "true" y "false".

Este es un ejemplo de una consulta de clasificación de nodos:

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 salida de esta consulta sería similar a la siguiente:

==>vp[genre->Action]
==>vp[genre->Crime]
==>vp[genre->Comedy]

En la consulta anterior, los pasos V() y properties() se utilizan de la siguiente manera:

El paso V() incluye el conjunto de vértices para el que desea obtener las clases del modelo de clasificación de nodos:

 .V( "movie_1", "movie_2", "movie_3" )

El paso properties() incluye la clave en la que se entrenó el modelo, así como el valor .with("Neptune#ml.classification") para indicar que se trata de una consulta de inferencia de ML de clasificación de nodos.

Por el momento, no se admiten varias claves de propiedad en un paso properties().with("Neptune#ml.classification"). Por ejemplo, la siguiente consulta da lugar a una excepción:

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

Para obtener información sobre el mensaje de error específico, consulte la lista de excepciones de Neptune ML.

Se puede usar un paso properties().with("Neptune#ml.classification") en combinación con cualquiera de los pasos siguientes:

• value()

• value().is()

• hasValue()

• has(value,"")

• key()

• key().is()

• hasKey()

• has(key,"")

• path()

Otras consultas de clasificación de nodos

Si tanto el punto de conexión de inferencia como el correspondiente rol de IAM se han guardado en el grupo de parámetros del clúster de base de datos, una consulta de clasificación de nodos puede ser tan sencilla como esta:

g.V("movie_1", "movie_2", "movie_3").properties("genre").with("Neptune#ml.classification")

Puede combinar las propiedades y las clases de los vértices en una consulta mediante el paso 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")
 )

También puede realizar una consulta ilimitada como la siguiente:

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

Puede recuperar las clases de nodos junto con los vértices mediante el paso select() junto con el paso 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")

También puede filtrar por clases de nodos, tal y como se muestra en estos ejemplos:

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

Puede obtener una puntuación de confianza en la clasificación de nodos mediante el predicado 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 respuesta sería similar a:

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

Uso de la inferencia inductiva en una consulta de clasificación de nodos

Supongamos que tuviera que añadir un nuevo nodo a un gráfico existente, en un cuaderno de Jupyter, de la siguiente manera:

%%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')

A continuación, podría usar una consulta de inferencia inductiva para obtener un género y una puntuación de confianza que reflejaran el nuevo nodo:

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

Sin embargo, si ejecutara la consulta varias veces, es posible que obtuviera resultados algo diferentes:

# First time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]

# Second time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.21365921]

Podría hacer que la misma consulta fuera determinista:

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

En ese caso, los resultados serían aproximadamente los mismos cada vez:

# First time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]