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 inferência no Neptune ML
É possível usar o Gremlin ou o SPARQL para consultar um endpoint de inferência do Neptune ML. No entanto, a [inferência indutiva em tempo real](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) no momento só é aceita para consultas do Gremlin.
# Consultas de inferência do Gremlin no Neptune ML
Conforme descrito em [Capacidades do Neptune ML](machine-learning.md#machine-learning-capabilities), o Neptune ML é compatível com modelos de treinamento que podem realizar os seguintes tipos de tarefa de inferência:
+ **Classificação de nós**: prevê o atributo categórico de uma propriedade de vértice.
+ **Regressão de nós**: prevê uma propriedade numérica de um vértice.
+ **Classificação de bordas**: prevê o atributo categórico de uma propriedade de borda.
+ **Regressão de nós**: prevê uma propriedade numérica de uma borda.
+ **Previsão de links**: prevê nós de destino considerando-se um nó de origem e uma borda de saída, ou nós de origem considerando-se um nó de destino e uma borda de entrada.
[Podemos ilustrar essas diferentes tarefas com exemplos que usam o [conjunto de dados de MovieLens 100 mil](https://grouplens.org/datasets/movielens/100k/) fornecido pela Research. GroupLens ](https://grouplens.org/datasets/movielens/) Esse conjunto de dados consiste em filmes, usuários e avaliações dos filmes feitas pelos usuários, a partir das quais criamos um grafo de propriedades como este:
![\[Exemplo de gráfico de propriedades do filme usando o conjunto de MovieLens dados 100k\]](http://docs.aws.amazon.com/pt_br/neptune/latest/userguide/images/movie_property_graph_example.png)
**Classificação de nós**: no conjunto de dados acima, `Genre` é um tipo de vértice conectado ao tipo de vértice `Movie` por borda `included_in`. No entanto, se ajustarmos o conjunto de dados para tornar `Genre` um atributo [categórico](https://en.wikipedia.org/wiki/Categorical_variable) para o tipo de vértice `Movie`, o problema de inferir `Genre` para novos filmes adicionados ao nosso grafo de conhecimento poderá ser resolvido usando modelos de classificação de nós.
**Regressão de nós**: se considerarmos o tipo de vértice `Rating`, que tem propriedades, como `timestamp` e `score`, o problema de inferir o valor numérico `Score` para um `Rating` pode ser resolvido usando modelos de regressão de nós.
**Classificação de arestas**: Da mesma forma, para uma `Rated` aresta, se tivermos uma propriedade `Scale` que pode ter um dos valores,`Love`,,`Like`,`Dislike`,`Neutral`,`Hate`, então o problema de inferir a `Rated` aresta `Scale` para novos movies/ratings pode ser resolvido usando modelos de classificação de arestas.
**Regressão de bordas**: da mesma forma, para a mesma borda `Rated`, se tivermos uma propriedade `Score` que contém um valor numérico para a classificação, isso pode ser inferido a partir de modelos de regressão de bordas.
**Previsão de links**: problemas, por exemplo, encontrar os dez principais usuários com maior probabilidade de avaliar um determinado filme ou encontrar os dez melhores filmes que um determinado usuário tem maior probabilidade de avaliar se enquadram na previsão de links.
**nota**
Para casos de uso do Neptune ML, temos um conjunto muito rico de cadernos projetados para oferecer uma compreensão prática de cada caso de uso. Você pode criar esses notebooks junto com seu cluster Neptune ao usar o modelo Neptune ML para criar um cluster [Neptune CloudFormation ML](machine-learning-quick-start.md). Esses cadernos também estão disponíveis no [github](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks/04-Machine-Learning).
**Topics**
+ [Predicados do Neptune ML usados em consultas de inferência do Gremlin](machine-learning-gremlin-inference-query-predicates.md)
+ [Consultas de classificação de nós do Gremlin no Neptune ML](machine-learning-gremlin-vertex-classification-queries.md)
+ [Consultas de regressão de nós do Gremlin no Neptune ML](machine-learning-gremlin-vertex-regression-queries.md)
+ [Consultas de classificação de bordas do Gremlin no Neptune ML](machine-learning-gremlin-edge-classification-queries.md)
+ [Consultas de regressão de bordas do Gremlin no Neptune ML](machine-learning-gremlin-edge-regression.md)
+ [Consultas de previsão de links do Gremlin usando modelos de previsão de links no Neptune ML](machine-learning-gremlin-link-prediction-queries.md)
+ [Lista de exceções para consultas de inferência do Gremlin no Neptune ML](machine-learning-gremlin-exceptions.md)
# Predicados do Neptune ML usados em consultas de inferência do Gremlin
## `Neptune#ml.deterministic`
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`
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`
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`
`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\$1ml.inductiveInference
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`
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`
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`
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`
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`
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`
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).
# Consultas de classificação de nós do Gremlin no Neptune ML
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
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
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]
```
# Consultas de regressão de nós do Gremlin no Neptune ML
A regressão de nós é semelhante à classificação de nós, exceto que o valor inferido do modelo de regressão para cada nó é numérico. É possível usar as mesmas consultas do Gremlin para regressão e classificação de nós, exceto pelas seguintes diferenças:
+ Novamente, no Neptune ML, os nós se referem a vértices.
+ A etapa `properties()` assume a forma `properties().with("Neptune#ml.regression")` em vez de `properties().with("Neptune#ml.classification")`.
+ Os predicados `"Neptune#ml.limit` e `"Neptune#ml.threshold"` não são aplicáveis.
+ Ao filtrar o valor, você precisa especificar um valor numérico.
Veja a seguir um exemplo de consulta de classificação de vértices:
```
g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1","movie_2","movie_3")
.properties("revenue").with("Neptune#ml.regression")
```
Você pode filtrar o valor inferido usando um modelo de regressão, conforme ilustrado nos seguintes exemplos:
```
g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1","movie_2","movie_3")
.properties("revenue").with("Neptune#ml.regression")
.value().is(P.gte(1600000))
g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1","movie_2","movie_3")
.properties("revenue").with("Neptune#ml.regression")
.hasValue(P.lte(1600000D))
```
## Usar inferência indutiva em uma consulta de regressão de nós
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ê pode usar uma consulta de inferência indutiva para obter uma classificação que leve em conta o novo nó:
```
%%gremlin
g.with("Neptune#ml.endpoint", "nr-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('101').properties("rating")
.with("Neptune#ml.regression")
.with("Neptune#ml.inductiveInference")
```
Como a consulta não é determinística, ela poderá gerar resultados um pouco diferentes se você a executar várias vezes, com base na vizinhança:
```
# First time
==>vp[rating->9.1]
# Second time
==>vp[rating->8.9]
```
Se precisar de resultados mais consistentes, você poderá tornar a consulta determinística:
```
%%gremlin
g.with("Neptune#ml.endpoint", "nc-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('101').properties("rating")
.with("Neptune#ml.regression")
.with("Neptune#ml.inductiveInference")
.with("Neptune#ml.deterministic")
```
Agora, os resultados serão praticamente os mesmos todas as vezes:
```
# First time
==>vp[rating->9.1]
# Second time
==>vp[rating->9.1]
```
# Consultas de classificação de bordas do Gremlin no Neptune ML
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
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
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]
```
# Consultas de regressão de bordas do Gremlin no Neptune ML
A regressão de bordas é semelhante à classificação de bordas, exceto que o valor inferido do modelo de ML é numérico. Para regressão de bordas, o Neptune ML é compatível com as mesmas consultas de classificação.
Os principais pontos a serem observados são:
+ Você precisa usar o predicado de ML `"Neptune#ml.regression"` para configurar a etapa `properties()` para esse caso de uso.
+ Os predicados `"Neptune#ml.limit"` e `"Neptune#ml.threshold"` não são aplicáveis nesse caso de uso.
+ Para filtrar o valor, você precisa especificar o valor como numérico.
## Sintaxe de uma consulta de regressão de bordas do Gremlin
Para um grafo simples em que `User` está o nó principal, `Movie` o nó final e `Rated` é a borda que os conecta, aqui está um exemplo de consulta de regressão de bordas que encontra o valor da classificação numérica, chamado de pontuação aqui, da borda `Rated`:
```
g.with("Neptune#ml.endpoint","edge-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.E("rating_1","rating_2","rating_3")
.properties("score").with("Neptune#ml.regression")
```
Também é possível filtrar por um valor inferido do modelo de regressão de ML. Para as bordas `Rated` existentes (de `User` a `Movie`) identificadas por `"rating_1"`, `"rating_2"` e `"rating_3"`, em que a propriedade de borda `Score` não está presente para essas classificações, é possível usar uma consulta como a seguinte para inferir `Score` para as bordas em que ela é maior ou igual a 9:
```
g.with("Neptune#ml.endpoint","edge-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.E("rating_1","rating_2","rating_3")
.properties("score").with("Neptune#ml.regression")
.value().is(P.gte(9))
```
## Usar inferência indutiva em uma consulta de regressão de bordas
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ê pode usar uma consulta de inferência indutiva para obter uma pontuação que leve em conta a nova borda:
```
%%gremlin
g.with("Neptune#ml.endpoint", "er-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.E('e101').properties("score")
.with("Neptune#ml.regression")
.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
==>ep[score->96]
# Second time
==>ep[score->91]
```
Se precisar de resultados mais consistentes, você poderá tornar a consulta determinística:
```
%%gremlin
g.with("Neptune#ml.endpoint", "er-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.E('e101').properties("score")
.with("Neptune#ml.regression")
.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
==>ep[score->96]
# Second time
==>ep[score->96]
```
# Consultas de previsão de links do Gremlin usando modelos de previsão de links no Neptune ML
Os modelos de previsão de links podem resolver problemas, como os seguintes:
+ **Previsão do nó principal**: considerando um tipo de vértice e borda, a quais vértices esse vértice provavelmente se vinculará?
+ **Previsão do nó final**: considerando um rótulo de vértice e borda, a quais vértices esse vértice provavelmente se vinculará?
**nota**
A previsão de borda ainda não é aceita no Neptune ML.
Para os exemplos abaixo, considere um grafo simples com os vértices `User` e `Movie` que estão vinculados pela borda `Rated`.
Aqui está um exemplo de consulta de previsão do nó principal, usada para prever os cinco principais usuários com maior probabilidade de avaliar os filmes, `"movie_1"`, `"movie_2"` e `"movie_3"`.
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.with("Neptune#ml.limit", 5)
.V("movie_1", "movie_2", "movie_3")
.in("rated").with("Neptune#ml.prediction").hasLabel("user")
```
Aqui está uma similar para previsão de nó final, usada para prever os cinco principais filmes que o usuário `"user_1"` provavelmente avaliará:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1")
.out("rated").with("Neptune#ml.prediction").hasLabel("movie")
```
Tanto o rótulo da borda quanto o rótulo do vértice previsto são obrigatórios. Se um deles for omitido, uma exceção será lançada. Por exemplo, a seguinte consulta sem um rótulo de vértice previsto gera uma exceção:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1")
.out("rated").with("Neptune#ml.prediction")
```
Da mesma forma, a seguinte consulta sem um rótulo de borda gera uma exceção:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1")
.out().with("Neptune#ml.prediction").hasLabel("movie")
```
Para ver a mensagem de erro específica, consulte a [lista de exceções do Neptune ML](machine-learning-gremlin-exceptions.md).
## Outras consultas de previsão de links
Você pode usar a etapa `select()` com a etapa `as(`) para gerar os vértices previstos junto com os vértices de entrada:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1").as("source")
.in("rated").with("Neptune#ml.prediction").hasLabel("user").as("target")
.select("source","target")
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1").as("source")
.out("rated").with("Neptune#ml.prediction").hasLabel("movie").as("target")
.select("source","target")
```
É possível fazer consultas ilimitadas, como estas:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1")
.out("rated").with("Neptune#ml.prediction").hasLabel("movie")
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1")
.in("rated").with("Neptune#ml.prediction").hasLabel("user")
```
## Usar inferência indutiva em uma consulta de previsão de links
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('newV1')
.addV('label2').property(id,'102').as('newV2')
.V('1').as('oldV1')
.V('2').as('oldV2')
.addE('eLabel1').from('newV1').to('oldV1')
.addE('eLabel2').from('oldV2').to('newV2')
```
Você pode então usar uma consulta de inferência indutiva para prever o nó principal, levando em consideração o novo nó:
```
%%gremlin
g.with("Neptune#ml.endpoint", "lp-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('101').out("eLabel1")
.with("Neptune#ml.prediction")
.with("Neptune#ml.inductiveInference")
.hasLabel("label2")
```
Resultado:
```
==>V[2]
```
Da mesma forma, você pode usar uma consulta de inferência indutiva para prever o nó final, levando em consideração o novo nó:
```
%%gremlin
g.with("Neptune#ml.endpoint", "lp-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('102').in("eLabel2")
.with("Neptune#ml.prediction")
.with("Neptune#ml.inductiveInference")
.hasLabel("label1")
```
Resultado:
```
==>V[1]
```
# Lista de exceções para consultas de inferência do Gremlin no Neptune ML
Essa é uma lista abrangente de exceções que podem ocorrer ao executar consultas de inferência do Neptune ML Gremlin. Essas exceções abrangem uma série de problemas, desde problemas com o endpoint ou perfil do IAM especificado até etapas incompatíveis do Gremlin e limitações no número de consultas de inferência de ML por consulta. Cada entrada inclui uma mensagem detalhada descrevendo o problema.
+ **`BadRequestException`**: as credenciais do perfil fornecido não podem ser carregadas.
*Mensagem*: `Unable to load credentials for role: the specified IAM Role ARN.`
+ **`BadRequestException`**— A função do IAM especificada não está autorizada a invocar o endpoint de SageMaker IA.
*Mensagem*: `User: the specified IAM Role ARN is not authorized to perform: sagemaker:InvokeEndpoint on resource: the specified endpoint.`
+ **`BadRequestException`**: o endpoint especificado não existe.
*Mensagem*: `Endpoint the specified endpoint not found.`
+ **`InternalFailureException`**: não é possível obter metadados de inferência indutiva em tempo real do Neptune ML do Amazon S3.
*Mensagem*: `Unable to fetch Neptune ML - Real-Time Inductive Inference metadata from S3. Check the permissions of the S3 bucket or if the Neptune instance can connect to S3.`
+ **`InternalFailureException`**: o Neptune ML não consegue encontrar o arquivo de metadados para inferência indutiva em tempo real no Amazon S3.
*Mensagem*: `Neptune ML cannot find the metadata file for Real-Time Inductive Inference in S3.`
+ **`InvalidParameterException`**: o endpoint especificado não é sintaticamente válido.
*Mensagem*: `Invalid endpoint provided for external service query.`
+ **`InvalidParameterException`**— O ARN da função IAM de SageMaker execução especificada não é sintaticamente válido.
*Mensagem*: `Invalid IAM role ARN provided for external service query.`
+ **`InvalidParameterException`**: várias chaves de propriedade são especificadas na etapa `properties()` de uma consulta.
*Mensagem*: `ML inference queries are currently supported for one property key.`
+ **`InvalidParameterException`**: vários rótulos de borda são especificados em uma consulta.
*Mensagem*: `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`**: várias restrições de rótulos de vértice são especificadas em uma consulta.
*Mensagem*: `ML inference are currently supported only with one vertex label constraint.`
+ **`InvalidParameterException`**: os predicados `Neptune#ml.classification` e `Neptune#ml.regression` estão presentes na mesma consulta.
*Mensagem*: `Both regression and classification ML predicates cannot be specified in the query.`
+ **`InvalidParameterException`**: mais de um rótulo de borda foi especificado na etapa `in()` ou `out()` em uma consulta de previsão de links.
*Mensagem*: `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`**: mais de uma chave de propriedade foi especificada com Neptune\$1ml.score.
*Mensagem*: `Neptune ML inference queries are currently supported for one property key and one Neptune#ml.score property key.`
+ **`MissingParameterException`**: o endpoint não foi especificado na consulta nem como um parâmetro de cluster de banco de dados.
*Mensagem*: `No endpoint provided for external service query.`
+ **``MissingParameterException**— A função IAM de execução da SageMaker IA não foi especificada na consulta ou como um parâmetro de cluster de banco de dados.
*Mensagem*: `No IAM role ARN provided for external service query.`
+ **`MissingParameterException`**: a chave da propriedade está ausente na etapa `properties()` de uma consulta.
*Mensagem*: `Property key needs to be specified using properties() step for ML inference queries.`
+ **`MissingParameterException`**: nenhum rótulo de borda foi especificado na etapa `in()` ou `out()` em uma consulta de previsão de links.
*Mensagem*: `Edge label needs to be specified while using in() or out() step for ML inference queries.`
+ **`MissingParameterException`**: nenhuma chave de propriedade foi especificada com Neptune\$1ml.score.
*Mensagem*: `Property key needs to be specified along with Neptune#ml.score property key while using the properties() step for Neptune ML inference queries.`
+ **`UnsupportedOperationException`**: a etapa `both()` é usada em uma consulta de previsão de links.
*Mensagem*: `ML inference queries are currently not supported with both() step.`
+ **`UnsupportedOperationException`**: nenhum rótulo de vértice previsto foi especificado na etapa `has()` com a etapa `in()` ou `out()` em uma consulta de previsão de links.
*Mensagem*: `Predicted vertex label needs to be specified using has() step for ML inference queries.`
+ **`UnsupportedOperationException`**: no momento, as consultas de inferência indutiva de ML do Gremlin não são compatíveis com etapas não otimizadas.
*Mensagem*: `Neptune ML - Real-Time Inductive Inference queries are currently not supported with Gremlin steps which are not optimized for Neptune. Check the Neptune User Guide for a list of Neptune-optimized steps.`
+ **`UnsupportedOperationException`**: no momento, as consultas de inferência do Neptune ML não são aceitas em uma etapa `repeat`.
*Mensagem*: `Neptune ML inference queries are currently not supported inside a repeat step.`
+ **`UnsupportedOperationException`**: no momento, não há compatibilidade com mais de uma consulta de inferência do Neptune ML por consulta do Gremlin.
*Mensagem*: `Neptune ML inference queries are currently supported only with one ML inference query per gremlin query.`
# Consultas de inferência do SPARQL no Neptune ML
O Neptune ML associa o grafo do RDF a um grafo de propriedades para modelar a tarefa de ML. No momento, ele é compatível com os seguintes casos de uso:
+ **Classificação de objetos**: prevê o atributo categórico de um objeto.
+ **Regressão de objetos**: prevê uma propriedade numérica de um objeto.
+ **Previsão de objetos**: prevê um objeto considerando-se um assunto e um relacionamento.
+ **Previsão de assunto**: prevê um assunto considerando-se um objeto e um relacionamento.
**nota**
O Neptune ML não é compatível com casos de uso de classificação e regressão de assuntos com SPARQL.
# Predicados do Neptune ML usados em consultas de inferência do SPARQL
Os seguintes predicados são usados com inferência do SPARQL:
## Predicado `neptune-ml:timeout`
Especifica o tempo limite para conexão com o servidor remoto. Não deve ser confundido com o tempo limite da solicitação de consulta, que é o tempo máximo que o servidor pode levar para atender a uma solicitação.
Observe que, se o tempo limite da consulta ocorrer antes do tempo limite do serviço especificado pelo predicado `neptune-ml:timeout`, a conexão do serviço também será cancelada.
## Predicado `neptune-ml:outputClass`
O predicado `neptune-ml:outputClass` só é usado para definir a classe do objeto previsto para previsão de objetos ou do assunto previsto para a previsão do assunto.
## Predicado `neptune-ml:outputScore`
O predicado `neptune-ml:outputScore` é um número positivo que representa a probabilidade de que a saída de um modelo de machine learning esteja correta.
## Predicado `neptune-ml:modelType`
O predicado `neptune-ml:modelType` especifica o tipo de modelo de machine learning que está sendo treinado:
+ `OBJECT_CLASSIFICATION`
+ `OBJECT_REGRESSION`
+ `OBJECT_PREDICTION`
+ `SUBJECT_PREDICTION`
## Predicado `neptune-ml:input`
O predicado `neptune-ml:input` se refere à lista de URIs usados como entradas para o Neptune ML.
## Predicado `neptune-ml:output`
O predicado `neptune-ml:output` se refere à lista de conjuntos de vinculação em que o Neptune ML gera resultados.
## Predicado `neptune-ml:predicate`
O predicado `neptune-ml:predicate` é usado de forma diferente dependendo da tarefa que estiver sendo realizada:
+ Para **previsão de objetos ou assuntos**: define o tipo de predicado (o tipo de borda ou de relacionamento).
+ Para **classificação e regressão de objetos**: define o literal (propriedade) que queremos prever.
## Predicado `neptune-ml:batchSize`
O `neptune-ml:batchSize` especifica o tamanho da entrada para a chamada de serviço remoto.
# Exemplos de classificação de objetos do SPARQL
Para classificação de objetos do SPARQL no Neptune ML, o modelo é treinado em um dos valores de predicados. Isso é útil quando esse predicado ainda não está presente em um assunto específico.
Somente valores de predicados categóricos podem ser inferidos usando o modelo de classificação de objetos.
A seguinte consulta busca prever o valor do predicado para todas as entradas do tipo `foaf:Person`:
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:modelType 'OBJECT_CLASSIFICATION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output .
}
}
```
Essa consulta pode ser personalizada da seguinte forma:
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:endpoint 'node-prediction-account-balance-endpoint' ;
neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ;
neptune-ml:batchSize "40"^^xsd:integer ;
neptune-ml:timeout "1000"^^xsd:integer ;
neptune-ml:modelType 'OBJECT_CLASSIFICATION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output .
}
}
```
# Exemplos de regressão de objetos do SPARQL
A regressão de objetos é semelhante à classificação de objetos, exceto por um valor de predicado numérico inferido do modelo de regressão para cada nó. É possível usar as mesmas consultas do SPARQL para regressão de objetos e para classificação de objetos, com a exceção de que os predicados `the Neptune#ml.limit` e `Neptune#ml.threshold` não são aplicáveis.
A seguinte consulta busca prever o valor do predicado para todas as entradas do tipo `foaf:Person`:
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:modelType 'OBJECT_REGRESSION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output .
}
}
```
Essa consulta pode ser personalizada da seguinte forma:
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:endpoint 'node-prediction-account-balance-endpoint' ;
neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ;
neptune-ml:batchSize "40"^^xsd:integer ;
neptune-ml:timeout "1000"^^xsd:integer ;
neptune-ml:modelType 'OBJECT_REGRESSION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output .
}
}
```
# Exemplo de previsão de objetos do SPARQL
A *previsão de objetos* prevê o valor do objeto para um assunto e um predicado específicos.
A seguinte consulta de previsão de objetos busca prever de qual filme a entrada do tipo `foaf:Person` gostaria:
```
?x a foaf:Person .
?x ?m .
?m a .
## Query
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:modelType 'OBJECT_PREDICTION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output ;
neptune-ml:outputClass .
}
}
```
A consulta em si pode ser personalizada da seguinte forma:
```
SELECT * WHERE { ?input a foaf:Person .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:endpoint 'node-prediction-user-movie-prediction-endpoint' ;
neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ;
neptune-ml:limit "5"^^xsd:integer ;
neptune-ml:batchSize "40"^^xsd:integer ;
neptune-ml:threshold "0.1"^^xsd:double ;
neptune-ml:timeout "1000"^^xsd:integer ;
neptune-ml:outputScore ?score ;
neptune-ml:modelType 'OBJECT_PREDICTION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output ;
neptune-ml:outputClass .
}
}
```
# Exemplo de previsão de assuntos do SPARQL
A *previsão de assuntos* prevê o assunto considerando-se um predicado e um objeto.
Por exemplo, a seguinte consulta prevê quem (do tipo `foaf:User`) assistirá a determinado filme:
```
SELECT * WHERE { ?input (a foaf:Movie) .
SERVICE neptune-ml:inference {
neptune-ml:config neptune-ml:modelType 'SUBJECT_PREDICTION' ;
neptune-ml:input ?input ;
neptune-ml:predicate ;
neptune-ml:output ?output ;
neptune-ml:outputClass ; }
}
```
# Lista de exceções para consultas de inferência do SPARQL no Neptune ML
****
+ **`BadRequestException`**: *mensagem*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects at least 1 value for the parameter (parameter name), found zero.`
+ **`BadRequestException`**: *mensagem*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects at most 1 value for the parameter (parameter name), found (a number) values.`
+ **`BadRequestException`**: *mensagem*: `Invalid predicate (predicate name) provided for external service http://aws.amazon.com/neptune/vocab/v01/services/ml#inference query.`
+ **`BadRequestException`**: *mensagem*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the predicate (predicate name) to be defined`.
+ **`BadRequestException`**: *mensagem*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the value of (parameter) (parameter name) to be a variable, found: (type)"`
+ **`BadRequestException`**: *mensagem*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the input (parameter name) to be a constant, found: (type)`.
+ **`BadRequestException`**: *mensagem*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference is expected to return only 1 value`.
+ **`BadRequestException`**: *mensagem*: `"The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference only allows StatementPatternNodes`.
+ **`BadRequestException`**: *mensagem*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference does not allow the predicate (predicate name)`.
+ **`BadRequestException`**: *mensagem*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference predicates cannot be variables, found: (type)`.
+ **`BadRequestException`**: *mensagem*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference predicates are expected to be part of the namespace (namespace name), found: (namespace name)`.