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 bordas do Gremlin no Neptune ML
<a name="machine-learning-gremlin-edge-classification-queries"></a>

Para consultas de classificação de bordas do Gremlin no Neptune ML:
+ O modelo é treinado em uma propriedade das bordas. O conjunto de valores exclusivos dessa propriedade é chamado de conjunto de classes.
+ O valor da classe ou da propriedade categórica de uma borda pode ser inferido do modelo de classificação de bordas, o que é útil quando essa propriedade ainda não está anexada à borda.
+ Para buscar uma ou mais classes de um modelo de classificação de bordas, é necessário 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 borda.

**nota**  
A classificação de bordas 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.

Aqui está um exemplo de consulta de classificação de bordas que solicita uma pontuação de confiança usando o predicado `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")
```

A resposta seria semelhante a esta:

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

## Sintaxe de uma consulta de classificação de bordas do Gremlin
<a name="machine-learning-gremlin-edge-classification-syntax"></a>

Para um grafo simples em que `User` é o nó principal e final e `Relationship` é a borda que os conecta, um exemplo de consulta de classificação de bordas é:

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

O resultado dessa consulta seria algo semelhante ao seguinte:

```
==>p[knows_by->"Family"]
==>p[knows_by->"Friends"]
==>p[knows_by->"Colleagues"]
```

Na consulta acima, as etapas `E()` e `properties()` são usadas da seguinte forma:
+ A etapa `E()` contém o conjunto de bordas para os quais você deseja buscar as classes do modelo de classificação de bordas:

  ```
  .E("relationship_1","relationship_2","relationship_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 bordas.

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

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

Sobre mensagens de erro específicas, consulte [Lista de exceções para consultas de inferência do Gremlin no 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()`

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

Suponha que você adicione uma nova borda a um grafo existente, em um caderno Jupyter, da seguinte forma:

```
%%gremlin
g.V('1').as('fromV')
.V('2').as('toV')
.addE('eLabel1').from('fromV').to('toV').property(id, 'e101')
```

Depois, você poderia usar uma consulta de inferência indutiva para obter uma escala que levasse em conta a nova borda:

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

Como a consulta não é determinística, os resultados seriam um pouco diferentes se você a executasse várias vezes, com base na vizinhança aleatória:

```
# First time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]

# Second time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.21365921]
```

Se precisar de resultados mais consistentes, você poderá tornar a consulta determinística:

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

Agora, os resultados serão mais ou menos os mesmos toda vez que você executar a consulta:

```
# First time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]

# Second time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]
```