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

# Predicados do Neptune ML usados em consultas de inferência do Gremlin
<a name="machine-learning-gremlin-inference-query-predicates"></a>

## `Neptune#ml.deterministic`
<a name="machine-learning-gremlin-inference-neptune-ml-deterministic-predicate"></a>

Esse predicado é uma opção para consultas de inferência indutiva, ou seja, para consultas que incluem o predicado [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference).

Ao usar a inferência indutiva, o mecanismo do Neptune cria o subgrafo apropriado para avaliar o modelo de GNN treinado, e os requisitos desse subgrafo dependem dos parâmetros do modelo final. Especificamente, o parâmetro `num-layer` determina o número de saltos transversais dos nós ou das bordas de destino, e o parâmetro `fanouts` especifica quantos vizinhos devem ser incluídos na amostra em cada salto (consulte os parâmetros do [HPO](machine-learning-customizing-hyperparams.md)).

Por padrão, as consultas de inferência indutiva são executadas no modo não determinístico, no qual o Neptune constrói a vizinhança aleatoriamente. Ao fazer previsões, essa amostragem normal de vizinhos aleatórios às vezes gera previsões diferentes.

Quando você inclui `Neptune#ml.deterministic` em uma consulta de inferência indutiva, o mecanismo do Neptune tenta realizar uma amostra de vizinhos de forma determinística para que várias invocações da mesma consulta retornem sempre os mesmos resultados. No entanto, não se pode garantir que os resultados sejam completamente determinísticos, pois as alterações no grafo e nos artefatos subjacentes dos sistemas distribuídos ainda podem introduzir flutuações.

Você inclui o predicado `Neptune#ml.deterministic` em uma consulta como esta:

```
.with("Neptune#ml.deterministic")
```

Se o predicado `Neptune#ml.deterministic` for incluído em uma consulta que também não inclua `Neptune#ml.inductiveInference`, ele será simplesmente ignorado.

## `Neptune#ml.disableInductiveInferenceMetadataCache`
<a name="machine-learning-gremlin-disableInductiveInferenceMetadataCache-predicate"></a>

Esse predicado é uma opção para consultas de inferência indutiva, ou seja, para consultas que incluem o predicado [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference).

Para consultas de inferência indutiva, o Neptune usa um arquivo de metadados armazenado no Amazon S3 para decidir o número de saltos e o fanout ao construir a vizinhança. O Neptune normalmente armazena em cache esses metadados do modelo para evitar a busca repetida do arquivo no Amazon S3. O armazenamento em cache pode ser desativado incluindo o predicado `Neptune#ml.disableInductiveInferenceMetadataCache` na consulta. Embora possa ser mais lento para o Neptune buscar os metadados diretamente do Amazon S3, isso é útil SageMaker quando o endpoint de IA é atualizado após um novo treinamento ou transformação e o cache está obsoleto.

Você inclui o predicado `Neptune#ml.disableInductiveInferenceMetadataCache` em uma consulta como esta:

```
.with("Neptune#ml.disableInductiveInferenceMetadataCache")
```

Veja um exemplo de consulta em um caderno 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`
<a name="machine-learning-gremlin-inference-neptune-ml-endpoint-predicate"></a>

O predicado `Neptune#ml.endpoint` é usado em uma etapa `with()` para especificar o endpoint de inferência, se necessário:

```
 .with("Neptune#ml.endpoint", "{{the model's SageMaker AI inference endpoint}}")
```

Você pode identificar o endpoint pelo `id` ou pelo URL. Por exemplo:

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

**nota**  
Se você [definir o parâmetro `neptune_ml_endpoint`](machine-learning-cluster-setup.md#machine-learning-set-inference-endpoint-cluster-parameter) no grupo de parâmetros do cluster de banco de dados do Neptune como o URL ou o `id` do endpoint, não precisará incluir o predicado `Neptune#ml.endpoint` em cada consulta.

## `Neptune#ml.iamRoleArn`
<a name="machine-learning-gremlin-inference-neptune-ml-iamRoleArn-predicate"></a>

`Neptune#ml.iamRoleArn`é usado em uma `with()` etapa para especificar o ARN da função IAM de execução da SageMaker IA, se necessário:

```
 .with("Neptune#ml.iamRoleArn", "{{the ARN for the SageMaker AI execution IAM role}}")
```

Para obter informações sobre como criar a função IAM de execução de SageMaker IA, consulte[Crie um NeptuneSageMaker IAMRole papel personalizado](machine-learning-manual-setup.md#ml-manual-setup-sm-role).

**nota**  
Se você [definir o `neptune_ml_iam_role` parâmetro](machine-learning-cluster-setup.md#machine-learning-enabling-create-param-group) no grupo de parâmetros do cluster do Neptune DB como o ARN da SageMaker sua função IAM de execução de IA, não precisará incluir `Neptune#ml.iamRoleArn` o predicado em cada consulta.

## Neptune\#ml.inductiveInference
<a name="machine-learning-gremlin-inference-neptune-ml-inductiveInference"></a>

A inferência transdutiva é habilitada por padrão no Gremlin. Para fazer uma consulta de [inferência indutiva em tempo real](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference), inclua o predicado `Neptune#ml.inductiveInference` desta forma:

```
.with("Neptune#ml.inductiveInference")
```

Se seu grafo for dinâmico, a inferência indutiva geralmente será a melhor escolha, mas se seu grafo for estático, a inferência transdutiva será mais rápida e eficiente.

## `Neptune#ml.limit`
<a name="machine-learning-gremlin-inference-neptune-ml-limit-predicate"></a>

Opcionalmente, o predicado `Neptune#ml.limit` limita o número de resultados gerados por entidade:

```
 .with( "Neptune#ml.limit", {{2}} )
```

Por padrão, o limite é 1 e o número máximo que pode ser definido é 100.

## `Neptune#ml.threshold`
<a name="machine-learning-gremlin-inference-neptune-ml-threshold-predicate"></a>

Opcionalmente, o predicado `Neptune#ml.threshold` estabelece um limite de corte para as pontuações dos resultados:

```
 .with( "Neptune#ml.threshold", {{0.5D}} )
```

Isso permite que você descarte todos os resultados com pontuações abaixo do limite especificado.

## `Neptune#ml.classification`
<a name="machine-learning-gremlin-inference-neptune-ml-classification-predicate"></a>

O `Neptune#ml.classification` predicado é anexado à `properties()` etapa para estabelecer que as propriedades precisam ser obtidas do endpoint de SageMaker IA do modelo de classificação de nós:

```
 .properties( "{{property key of the node classification model}}" ).with( "Neptune#ml.classification" )
```

## `Neptune#ml.regression`
<a name="machine-learning-gremlin-inference-neptune-ml-regression-predicate"></a>

O `Neptune#ml.regression` predicado é anexado à `properties()` etapa para estabelecer que as propriedades precisam ser obtidas do endpoint de SageMaker IA do modelo de regressão do nó:

```
 .properties( "{{property key of the node regression model}}" ).with( "Neptune#ml.regression" )
```

## `Neptune#ml.prediction`
<a name="machine-learning-gremlin-inference-neptune-ml-prediction-predicate"></a>

O predicado `Neptune#ml.prediction` é anexado às etapas `in()` e `out()` para estabelecer que se trata de uma consulta de previsão de links:

```
 .in("{{edge label of the link prediction model}}").with("Neptune#ml.prediction").hasLabel("{{target node label}}")
```

## `Neptune#ml.score`
<a name="machine-learning-gremlin-inference-neptune-ml-score-predicate"></a>

O predicado `Neptune#ml.score` é usado em consultas de classificação de nós ou bordas do Gremlin para obter uma pontuação de confiança de machine learning. O predicado `Neptune#ml.score` deve ser transmitido junto com o predicado da consulta na etapa `properties()` para obter uma pontuação de confiança de ML para consultas de classificação de nós ou bordas.

É possível encontrar um exemplo de classificação de nós com [outros exemplos de classificação de nós](machine-learning-gremlin-vertex-classification-queries.md#machine-learning-gremlin-node-class-other-queries) e um exemplo de classificação de bordas na [seção de classificação de bordas](machine-learning-gremlin-edge-classification-queries.md).