As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Consultas de classificação de nós do Gremlin no Neptune ML
<a name="machine-learning-gremlin-vertex-classification-queries"></a>

Para consultas de classificação de nós do Gremlin no Neptune ML:
+ O modelo é treinado em uma propriedade dos vértices. O conjunto de valores exclusivos dessa propriedade é chamado de conjunto de classes de nós ou, simplesmente, classes.
+ A classe do nó ou o valor da propriedade categórica da propriedade de um vértice pode ser inferido do modelo de classificação de nós. Isso é útil quando essa propriedade ainda não está anexada ao vértice.
+ Para buscar uma ou mais classes de um modelo de classificação de nós, você precisa usar a etapa `with()` com o predicado `Neptune#ml.classification` para configurar a etapa `properties()`. O formato de saída é semelhante ao esperado se essas fossem propriedades de vértice.

**nota**  
A classificação de nós só funciona com valores de propriedades de string. Isso significa que valores de propriedades numéricas, como `0` ou `1`, não são compatíveis, embora a string seja equivalente a `"0"` e `"1"`. Da mesma forma, os valores de propriedade booliana `true` e `false` não funcionam, mas `"true"` e `"false"` funcionam.

Veja a seguir um exemplo de consulta de classificação de nós:

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

O resultado dessa consulta seria algo semelhante ao seguinte:

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

Na consulta acima, as etapas `V()` e `properties()` são usadas da seguinte forma:

A etapa `V()` contém o conjunto de vértices para os quais você deseja buscar as classes do modelo de classificação de nós:

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

A etapa `properties()` contém a chave na qual o modelo foi treinado e tem `.with("Neptune#ml.classification")` para indicar que se trata de uma consulta de inferência de ML de classificação de nós.

Atualmente, não são aceitas várias chaves de propriedade em uma etapa `properties().with("Neptune#ml.classification")`. Por exemplo, a seguinte consulta gera uma exceção:

```
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 ver a mensagem de erro específica, consulte a [lista de exceções do Neptune ML](machine-learning-gremlin-exceptions.md).

Uma etapa `properties().with("Neptune#ml.classification")` pode ser usada em combinação com qualquer uma das seguintes etapas:
+ `value()`
+ `value().is()`
+ `hasValue()`
+ `has(value,"")`
+ `key()`
+ `key().is()`
+ `hasKey()`
+ `has(key,"")`
+ `path()`

## Outras consultas de classificação de nós
<a name="machine-learning-gremlin-node-class-other-queries"></a>

Se o endpoint de inferência e o perfil do IAM correspondente tiverem sido salvos no seu grupo de parâmetros do cluster de banco de dados, uma consulta de classificação de nós poderá ser tão simples quanto esta:

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

Você pode misturar propriedades e classes de vértices em uma consulta usando a etapa `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")
 )
```

Também é possível fazer uma consulta ilimitada, como esta:

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

Você pode recuperar as classes de nós junto com os vértices usando a etapa `select()` junto com a etapa `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")
```

Também é possível filtrar por classes de nós, conforme ilustrado nestes exemplos:

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

Você pode obter uma pontuação de confiança na classificação de nós usando o 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")
```

A resposta seria semelhante a esta:

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

## Usar inferência indutiva em uma consulta de classificação de nós
<a name="machine-learning-gremlin-node-class-inductive"></a>

Suponha que você adicione um novo nó a um grafo existente, em um caderno Jupyter, da seguinte forma:

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

Depois, você poderia usar uma consulta de inferência indutiva para obter um gênero e uma pontuação de confiança que refletissem o novo nó:

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

No entanto, se você executou a consulta várias vezes, poderá obter resultados um pouco diferentes:

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

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

Você pode tornar a mesma consulta determinística:

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

Nesse caso, os resultados seriam praticamente os mesmos todas as vezes:

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