Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Consultas de inferencia en Neptune ML
<a name="machine-learning-inference-queries"></a>

Puede utilizar Gremlin o SPARQL para consular un punto de conexión de inferencia de Neptune ML. Sin embargo, la [inferencia inductiva en tiempo real](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) solo se admite actualmente para consultas de Gremlin.

# Consultas de inferencia de Gremlin en Neptune ML
<a name="machine-learning-gremlin-inference-queries"></a>

Tal y como se describe en [Capacidades de Neptune ML](machine-learning.md#machine-learning-capabilities), Neptune ML admite modelos de entrenamiento que pueden realizar los siguientes tipos de tareas de inferencia:
+ **Clasificación de nodos**: predice la característica categórica de una propiedad de vértice.
+ **Regresión de nodos**: predice una propiedad numérica de un vértice.
+ **Clasificación de bordes**: predice la característica categórica de una propiedad de borde.
+ **Regresión de bordes**: predice una propiedad numérica de un borde.
+ **Predicción de enlaces**: predice los nodos de destino con un nodo de origen y un borde de salida, o los nodos de origen con un nodo de destino y un borde de entrada.

Podemos ilustrar estas diferentes tareas con ejemplos que utilizan el [conjunto de datos de MovieLens 100 000](https://grouplens.org/datasets/movielens/100k/) proporcionado por [GroupLens Research](https://grouplens.org/datasets/movielens/). Este conjunto de datos consta de películas, usuarios y clasificaciones de las películas por parte de los usuarios, a partir de las cales, hemos creado un gráfico de propiedades como el siguiente: 

![\[Ejemplo de gráfico de propiedades de una película utilizando el conjunto de datos de MovieLens 100.000\]](http://docs.aws.amazon.com/es_es/neptune/latest/userguide/images/movie_property_graph_example.png)


**Clasificación de nodos**: en el conjunto de datos anterior, `Genre` es un tipo de vértice que está conectado al tipo de vértice `Movie` mediante el borde `included_in`. Sin embargo, si retocamos el conjunto de datos para que `Genre` sea una característica [categórica](https://en.wikipedia.org/wiki/Categorical_variable) para el tipo de vértice `Movie`, el problema de inferir `Genre` para las nuevas películas que se añadan a nuestro gráfico de conocimientos se puede resolver mediante modelos de clasificación de nodos.

**Regresión de nodos**: si tenemos en cuenta el tipo de vértice `Rating`, que tiene propiedades como `timestamp` y `score`, el problema de inferir el valor numérico `Score` para una `Rating` se puede resolver mediante modelos de regresión de nodos.

**Clasificación de aristas**: Del mismo modo, en el caso de una `Rated` arista, si tenemos una propiedad `Scale` que puede tener uno de los valores,,,`Love`,,`Like`,`Dislike`,`Neutral`,,`Hate`,, entonces el problema de inferir `Scale` la `Rated` arista si es nueva se movies/ratings puede resolver mediante modelos de clasificación de aristas.

**Regresión de bordes**: del mismo modo, para el mismo borde `Rated`, si tenemos una propiedad `Score` que incluye un valor numérico para la clasificación, esto se puede inferir de los modelos de regresión de bordes.

**Predicción de enlaces**: problemas, como encontrar los diez principales usuarios que tienen más probabilidades de puntuar una determinada película o encontrar las diez principales películas que un determinado usuario tiene más probabilidades de valorar, se consideran parte de la predicción de enlaces.

**nota**  
Para los casos de uso de Neptune ML, tenemos un conjunto muy completo de cuadernos diseñados para proporcionarle una comprensión práctica de cada caso de uso. Puede crear estos cuadernos junto con su clúster de Neptuno cuando utilice la plantilla [Neptune CloudFormation ML para crear un clúster de Neptune ML](machine-learning-quick-start.md). Estos cuadernos también están disponibles en [github](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks/04-Machine-Learning).

**Topics**
+ [Predicados de Neptune ML utilizados en las consultas de inferencia de Gremlin](machine-learning-gremlin-inference-query-predicates.md)
+ [Consultas de clasificación de nodos de Gremlin en Neptune ML](machine-learning-gremlin-vertex-classification-queries.md)
+ [Consultas de regresión de nodos de Gremlin en Neptune ML](machine-learning-gremlin-vertex-regression-queries.md)
+ [Consultas de clasificación de bordes de Gremlin en Neptune ML](machine-learning-gremlin-edge-classification-queries.md)
+ [Consultas de regresión de bordes de Gremlin en Neptune ML](machine-learning-gremlin-edge-regression.md)
+ [Consultas de predicción de enlaces de Gremlin mediante modelos de predicción de enlaces en Neptune ML](machine-learning-gremlin-link-prediction-queries.md)
+ [Lista de excepciones para las consultas de inferencia de Gremlin en Neptune ML](machine-learning-gremlin-exceptions.md)

# Predicados de Neptune ML utilizados en las consultas de inferencia de Gremlin
<a name="machine-learning-gremlin-inference-query-predicates"></a>

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

Este predicado es una opción para las consultas de inferencia inductiva, es decir, para las consultas que incluyen el predicado [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference).

Cuando se utiliza la inferencia inductiva, el motor de Neptune crea el subgráfico adecuado para evaluar el modelo GNN entrenado, y los requisitos de este subgráfico dependen de los parámetros del modelo final. En concreto, el parámetro `num-layer` determina el número de saltos de recorridos desde los nodos o bordes de destino, y el parámetro `fanouts` especifica el número de vecinos que hay que muestrear en cada salto (consulte [Parámetros de HPO](machine-learning-customizing-hyperparams.md)).

De forma predeterminada, las consultas de inferencia inductiva se ejecutan en modo no determinista, en el que Neptune crea la vecindad de forma aleatoria. Al realizar predicciones, este muestreo normal de vecinos aleatorios a veces da como resultado predicciones diferentes.

Cuando se incluye `Neptune#ml.deterministic` en una consulta de inferencia inductiva, el motor de Neptune intenta muestrear los vecinos de forma determinista para que las diversas invocaciones de la misma consulta devuelvan siempre los mismos resultados. Sin embargo, no se puede garantizar que los resultados sean completamente deterministas, ya que los cambios en el gráfico subyacente y los artefactos de los sistemas distribuidos aún pueden provocar fluctuaciones.

El predicado `Neptune#ml.deterministic` se incluye en una consulta de la siguiente manera:

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

Si el predicado `Neptune#ml.deterministic` se incluye en una consulta que no incluye también `Neptune#ml.inductiveInference`, simplemente se ignora.

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

Este predicado es una opción para las consultas de inferencia inductiva, es decir, para las consultas que incluyen el predicado [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference).

Para las consultas de inferencia inductiva, Neptune utiliza un archivo de metadatos almacenado en Amazon S3 para decidir el número de saltos y la distribución ramificada al crear el vecindario. Neptune normalmente almacena en caché los metadatos de este modelo para evitar tener que recuperar una y otra vez el archivo de Amazon S3. El almacenamiento en caché se puede deshabilitar si se incluye el predicado `Neptune#ml.disableInductiveInferenceMetadataCache` en la consulta. Si bien Neptune puede tardar más en obtener los metadatos directamente de Amazon S3, resulta útil cuando el punto final de la SageMaker IA se ha actualizado tras volver a entrenarse o transformarse y la caché está obsoleta.

El predicado `Neptune#ml.disableInductiveInferenceMetadataCache` se incluye en una consulta de la siguiente manera:

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

A continuación, se muestra cómo podría ser una consulta en un cuaderno de 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>

El predicado `Neptune#ml.endpoint` se utiliza en un paso `with()` para especificar el punto de conexión de inferencia, si es necesario:

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

Puede identificar el punto de conexión tanto por su `id` o como por su URL. Por ejemplo:

```
 .with( "Neptune#ml.endpoint", "node-classification-movie-lens-endpoint" )
```

O bien:

```
 .with( "Neptune#ml.endpoint", "https://runtime.sagemaker.us-east-1.amazonaws.com/endpoints/node-classification-movie-lens-endpoint/invocations" )
```

**nota**  
Si [establece el parámetro `neptune_ml_endpoint`](machine-learning-cluster-setup.md#machine-learning-set-inference-endpoint-cluster-parameter) en el grupo de parámetros del clúster de base de datos de Neptune en el `id` o la URL del punto de conexión, no necesita incluir el predicado `Neptune#ml.endpoint` en cada consulta.

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

`Neptune#ml.iamRoleArn`se utiliza en un `with()` paso para especificar el ARN de la función de IAM de ejecución de SageMaker IA, si es necesario:

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

Para obtener información sobre cómo crear la función de IAM de ejecución de SageMaker IA, consulte. [Cree un rol personalizado NeptuneSageMaker IAMRole](machine-learning-manual-setup.md#ml-manual-setup-sm-role)

**nota**  
Si [establece el `neptune_ml_iam_role` parámetro en el](machine-learning-cluster-setup.md#machine-learning-enabling-create-param-group) grupo de parámetros del clúster de base de datos de Neptune en el ARN de su función de IAM de ejecución de SageMaker IA, no necesita incluir el `Neptune#ml.iamRoleArn` predicado en cada consulta.

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

La inferencia transductiva está habilitada de forma predeterminada en Gremlin. Para realizar una consulta de [inferencia inductiva en tiempo real](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference), incluya el predicado `Neptune#ml.inductiveInference` de la siguiente manera:

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

Si el gráfico es dinámico, la inferencia inductiva suele ser la mejor opción, pero si el gráfico es estático, la inferencia transductiva es más rápida y eficaz.

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

El predicado `Neptune#ml.limit` es opcional y limita el número de resultados devueltos por la entidad:

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

De forma predeterminada, el límite es 1 y el número máximo que se puede establecer es 100.

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

El predicado `Neptune#ml.threshold` establece de forma opcional un umbral límite para las puntuaciones de los resultados:

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

Esto le permite descartar todos los resultados con puntuaciones por debajo del umbral especificado.

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

El `Neptune#ml.classification` predicado se adjunta al `properties()` paso para establecer que las propiedades deben obtenerse del punto final de SageMaker IA del modelo de clasificación de nodos:

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

El `Neptune#ml.regression` predicado se adjunta al `properties()` paso para establecer que las propiedades deben obtenerse del punto final de la SageMaker IA del modelo de regresión de nodos:

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

El predicado `Neptune#ml.prediction` se adjunta a los pasos `in()` y `out()` pasos para establecer que se trata de una consulta de predicción de enlaces:

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

El predicado `Neptune#ml.score` se utiliza en las consultas de clasificación de nodos o bordes de Gremlin para obtener una puntuación de confianza en el machine learning. El predicado `Neptune#ml.score` debe pasarse junto con el predicado de la consulta en el paso `properties()` para obtener una puntuación de confianza en el ML para las consultas de clasificación de nodos o bordes.

Puede encontrar un ejemplo de clasificación de nodos con [otros ejemplos de clasificación de nodos](machine-learning-gremlin-vertex-classification-queries.md#machine-learning-gremlin-node-class-other-queries) y un ejemplo de clasificación de bordes en la [sección Clasificación de bordes](machine-learning-gremlin-edge-classification-queries.md).

# Consultas de clasificación de nodos de Gremlin en Neptune ML
<a name="machine-learning-gremlin-vertex-classification-queries"></a>

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](machine-learning-gremlin-exceptions.md).

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
<a name="machine-learning-gremlin-node-class-other-queries"></a>

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
<a name="machine-learning-gremlin-node-class-inductive"></a>

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

# Consultas de regresión de nodos de Gremlin en Neptune ML
<a name="machine-learning-gremlin-vertex-regression-queries"></a>

La regresión de nodos es similar a la clasificación de nodos, excepto el valor inferido del modelo de regresión para cada nodo que es numérico. Puede utilizar las mismas consultas de Gremlin para la regresión de nodos que para la clasificación de nodos, excepto por las siguientes diferencias:
+ De nuevo, en Neptune ML, los nodos hacen referencia a vértices.
+ El paso `properties()` adopta el formato `properties().with("Neptune#ml.regression")` en lugar de `properties().with("Neptune#ml.classification")`.
+ Los predicados `"Neptune#ml.limit` y `"Neptune#ml.threshold"` no son aplicables.
+ Al filtrar el valor, debe especificar un valor numérico.

Este es un ejemplo de una consulta de clasificación 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")
```

Puede filtrar el valor inferido mediante un modelo de regresión, tal y como se muestra en los siguientes ejemplos:

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

## Uso de la inferencia inductiva en una consulta de regresión de nodos
<a name="machine-learning-gremlin-node-regress-inductive"></a>

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 una calificación que tuviera en cuenta el nuevo nodo:

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

Dado que la consulta no es determinista, es posible que arrojara resultados algo diferentes si la ejecutara varias veces, en función de la vecindad:

```
# First time
==>vp[rating->9.1]

# Second time
==>vp[rating->8.9]
```

Si necesitara resultados más coherentes, podría hacer que la consulta fuera determinista:

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

Ahora los resultados serán aproximadamente los mismos cada vez:

```
# First time
==>vp[rating->9.1]

# Second time
==>vp[rating->9.1]
```

# Consultas de clasificación de bordes de Gremlin en Neptune ML
<a name="machine-learning-gremlin-edge-classification-queries"></a>

Para la clasificación de bordes de Gremlin en Neptune ML:
+ El modelo se entrena en una propiedad de los bordes. El conjunto de valores únicos de esta propiedad se denomina conjunto de clases.
+ El valor de clase o propiedad categórica de un borde se puede inferir del modelo de clasificación de bordes, lo que resulta útil cuando esta propiedad aún no está asociada al borde.
+ Para obtener una o varias clases de un modelo de clasificación de bordes, 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 bordes.

**nota**  
La clasificación de bordes 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"`.

A continuación, se muestra un ejemplo de una consulta de clasificación de bordes que solicita una puntuación de confianza mediante el 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")
```

La respuesta sería similar a:

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

## Sintaxis de una consulta de clasificación de bordes de Gremlin
<a name="machine-learning-gremlin-edge-classification-syntax"></a>

En el caso de un gráfico sencillo en el que `User` es el nodo principal y final y `Relationship` es el borde que los conecta: un ejemplo de consulta de clasificación de bordes es:

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

La salida de esta consulta sería similar a la siguiente:

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

En la consulta anterior, los pasos `E()` y `properties()` se utilizan de la siguiente manera:
+ El paso `E()` incluye el conjunto de bordes para el que desea obtener las clases del modelo de clasificación de bordes:

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

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

Para ver mensajes de error específicos, consulte [Lista de excepciones para las consultas de inferencia de Gremlin en Neptune ML](machine-learning-gremlin-exceptions.md).

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

## Uso de la inferencia inductiva en una consulta de clasificación de bordes
<a name="machine-learning-gremlin-edge-class-inductive"></a>

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

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

A continuación, podría usar una consulta de inferencia inductiva para obtener una escala que tuviera en cuenta el nuevo borde:

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

Dado que la consulta no es determinista, los resultados variarían algo si se ejecutara varias veces, en función de la vecindad aleatoria:

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

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

Si necesitara resultados más coherentes, podría hacer que la consulta fuera determinista:

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

Ahora los resultados serán más o menos los mismos cada vez que ejecute la 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 regresión de bordes de Gremlin en Neptune ML
<a name="machine-learning-gremlin-edge-regression"></a>

La regresión de bordes es similar a la clasificación de bordes, excepto el valor inferido del modelo de ML que es numérico. En el caso de la regresión de bordes, Neptune ML admite las mismas consultas que para la clasificación.

Los puntos clave a tener en cuenta son:
+ Debe usar el predicado `"Neptune#ml.regression"` de ML para configurar el paso `properties()` para este caso de uso.
+ Los predicados `"Neptune#ml.limit"` y `"Neptune#ml.threshold"` no son aplicables en este caso de uso.
+ Para filtrar el valor, debe especificarlo como numérico.

## Sintaxis de una consulta de regresión de bordes de Gremlin
<a name="machine-learning-gremlin-edge-regression-syntax"></a>

En el caso de un gráfico sencillo en el que `User` es el nodo principal, `Movie` es el nodo final y `Rated` es el borde que los conecta: a continuación se muestra un ejemplo de consulta de regresión de bordes que encuentra el valor de clasificación numérica, denominado puntuación, para el borde `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")
```

También puede filtrar un valor inferido del modelo de regresión de ML. En el caso de los bordes `Rated` existentes (de `User` a `Movie`) identificadas por `"rating_1"`, `"rating_2"` y `"rating_3"`, donde la propiedad de borde `Score` esté presente para estas clasificaciones, puede utilizar una consulta como la siguiente para inferir `Score` para los bordes en los que es mayor o 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))
```

## Uso de la inferencia inductiva en una consulta de regresión de bordes
<a name="machine-learning-gremlin-edge-regression-inductive"></a>

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

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

A continuación, podría usar una consulta de inferencia inductiva para obtener una puntuación que tuviera en cuenta el nuevo borde:

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

Dado que la consulta no es determinista, los resultados variarían algo si se ejecutara varias veces, en función de la vecindad aleatoria:

```
# First time
==>ep[score->96]

# Second time
==>ep[score->91]
```

Si necesitara resultados más coherentes, podría hacer que la consulta fuera determinista:

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

Ahora los resultados serán más o menos los mismos cada vez que ejecute la consulta:

```
# First time
==>ep[score->96]

# Second time
==>ep[score->96]
```

# Consultas de predicción de enlaces de Gremlin mediante modelos de predicción de enlaces en Neptune ML
<a name="machine-learning-gremlin-link-prediction-queries"></a>

Los modelos de predicción de enlaces pueden resolver problemas como los siguientes:
+ **Predicción del nodo principal**: con un vértice y un tipo de borde, ¿desde qué vértices es probable que se enlace este vértice?
+ **Predicción del nodo final**: con un vértice y un tipo de borde, ¿desde qué vértices es probable que se enlace este vértice?

**nota**  
Aún no se admite la predicción de bordes en Neptune ML.

Para los ejemplos siguientes, supongamos que tenemos un gráfico sencillo con los vértices `User` y `Movie` que estén vinculados por el borde `Rated`.

Este es un ejemplo de consulta de predicción del nodo principal, que se utiliza para predecir cuáles son los cinco principales usuarios que tienen más probabilidades de valorar las películas `"movie_1"`, `"movie_2"` y `"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")
```

Esta es una similar para la predicción del nodo final, que se utiliza para predecir cuáles son las cinco principales películas que el usuario `"user_1"` tiene más probabilidades de valorar:

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

Se necesitan tanto la etiqueta de borde como la de vértice previsto. Si se omite alguna de ellas, se produce una excepción. Por ejemplo, la siguiente consulta sin una etiqueta de vértice previsto produce una excepción:

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

Del mismo modo, la siguiente consulta sin una etiqueta de borde genera una excepción:

```
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 obtener información sobre los mensajes de error específicos que generan estas excepciones, consulte la [lista de excepciones de Neptune ML](machine-learning-gremlin-exceptions.md).

## Otras consultas de predicción de enlaces
<a name="machine-learning-gremlin-other-link-prediction-queries"></a>

Puede usar el paso `select()` con el paso `as(` para generar los vértices previstos junto con los 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")
```

Puede realizar consultas ilimitadas, como, por ejemplo:

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

## Uso de la inferencia inductiva en una consulta de predicción de enlaces
<a name="machine-learning-gremlin-link-predict-inductive"></a>

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

A continuación, podría usar una consulta de inferencia inductiva para predecir el nodo principal, teniendo en cuenta el nuevo nodo:

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

Asimismo, podría usar una consulta de inferencia inductiva para predecir el nodo final, teniendo en cuenta el nuevo nodo:

```
%%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 excepciones para las consultas de inferencia de Gremlin en Neptune ML
<a name="machine-learning-gremlin-exceptions"></a>

 Esta es una lista completa de las excepciones que pueden producirse al ejecutar consultas de inferencia de Gremlin en Neptune ML. Estas excepciones abarcan una serie de problemas, desde los relacionados con el rol de IAM o punto de conexión especificado hasta los pasos de Gremlin no compatibles y las limitaciones en el número de consultas de inferencia de ML por consulta. Cada entrada incluye un mensaje detallado que describe el problema. 
+ **`BadRequestException`**: no se pueden cargar las credenciales del rol proporcionado.

  *Mensaje*: `Unable to load credentials for role: the specified IAM Role ARN.`
+ **`BadRequestException`**— La función de IAM especificada no está autorizada a invocar el punto final de la IA. SageMaker 

  *Mensaje*: `User: the specified IAM Role ARN is not authorized to perform: sagemaker:InvokeEndpoint on resource: the specified endpoint.`
+ **`BadRequestException`**: el punto de conexión especificado no existe.

  *Mensaje*: `Endpoint the specified endpoint not found.`
+ **`InternalFailureException`**: no se pueden obtener los metadatos de inferencia inductiva en tiempo real de Neptune ML desde Amazon S3.

  *Mensaje*: `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`**: Neptune ML no puede encontrar el archivo de metadatos de inferencia inductiva en tiempo real en Amazon S3.

  *Mensaje*: `Neptune ML cannot find the metadata file for Real-Time Inductive Inference in S3.`
+ **`InvalidParameterException`**: el punto de conexión especificado no es válido desde el punto de vista sintáctico.

  *Mensaje*: `Invalid endpoint provided for external service query.`
+ **`InvalidParameterException`**— El ARN del rol de IAM de SageMaker ejecución especificado no es válido sintácticamente.

  *Mensaje*: `Invalid IAM role ARN provided for external service query.`
+ **`InvalidParameterException`**: se especifican varias claves de propiedad en el paso `properties()` de una consulta.

  *Mensaje*: `ML inference queries are currently supported for one property key.`
+ **`InvalidParameterException`**: se especifican varias etiquetas de borde en una consulta.

  *Mensaje*: `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`**: se especifican varias restricciones de etiquetas de vértices en una consulta.

  *Mensaje*: `ML inference are currently supported only with one vertex label constraint.`
+ **`InvalidParameterException`**: los predicados `Neptune#ml.classification` y `Neptune#ml.regression` están presentes en la misma consulta.

  *Mensaje*: `Both regression and classification ML predicates cannot be specified in the query.`
+ **`InvalidParameterException`**: se ha especificado más de una etiqueta de borde en los pasos `in()` o `out()` de una consulta de predicción de enlaces.

  *Mensaje*: `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`**: se ha especificado más de una clave de propiedad con Neptune\$1ml.score.

  *Mensaje*: `Neptune ML inference queries are currently supported for one property key and one Neptune#ml.score property key.`
+ **`MissingParameterException`**: no se ha especificado el punto de conexión en la consulta ni como parámetro de clúster de base de datos.

  *Mensaje*: `No endpoint provided for external service query.`
+ **``MissingParameterException**— La función de IAM de ejecución de SageMaker IA no se especificó en la consulta ni como parámetro del clúster de base de datos.

  *Mensaje*: `No IAM role ARN provided for external service query.`
+ **`MissingParameterException`**: falta la clave de propiedad en el paso `properties()` de una consulta.

  *Mensaje*: `Property key needs to be specified using properties() step for ML inference queries.`
+ **`MissingParameterException`**: no se ha especificado ninguna etiqueta de borde en los pasos `in()` o `out()` de una consulta de predicción de enlaces.

  *Mensaje*: `Edge label needs to be specified while using in() or out() step for ML inference queries.`
+ **`MissingParameterException`**: no se ha especificado ninguna clave de propiedad con Neptune\$1ml.score.

  *Mensaje*: `Property key needs to be specified along with Neptune#ml.score property key while using the properties() step for Neptune ML inference queries.`
+ **`UnsupportedOperationException`**: el paso `both()` se utiliza en una consulta de predicción de enlaces.

  *Mensaje*: `ML inference queries are currently not supported with both() step.`
+ **`UnsupportedOperationException`**: no se ha especificado ninguna etiqueta de vértice prevista en el paso `has()` con los pasos `in()` o `out()` en una consulta de predicción de enlaces.

  *Mensaje*: `Predicted vertex label needs to be specified using has() step for ML inference queries.`
+ **`UnsupportedOperationException`**: las consultas de inferencia inductiva de ML de Gremlin no son compatibles actualmente con pasos no optimizados.

  *Mensaje*: `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`**: las consultas de inferencia de Neptune ML no son compatibles actualmente en un paso `repeat`.

  *Mensaje*: `Neptune ML inference queries are currently not supported inside a repeat step.`
+ **`UnsupportedOperationException`**: no se admite más de una consulta de inferencia de Neptune ML por consulta de Gremlin.

  *Mensaje*: `Neptune ML inference queries are currently supported only with one ML inference query per gremlin query.`

# Consultas de inferencia de SPARQL en Neptune ML
<a name="machine-learning-sparql-inference-queries"></a>

Neptune ML mapea el gráfico de RDF en un gráfico de propiedades para modelar la tarea de ML. Por el momento, admite los siguientes casos de uso:
+ **Clasificación de objetos**: predice la característica categórica de un objeto.
+ **Regresión de objetos**: predice una propiedad numérica de un objeto.
+ **Predicción de objetos**: predice un objeto a partir de un sujeto y una relación.
+ **Predicción de sujetos**: predice un sujeto a partir de un objeto y una relación.

**nota**  
Neptune ML no admite casos de uso de clasificación y regresión de sujetos con SPARQL.

# Predicados de Neptune ML utilizados en las consultas de inferencia de SPARQL
<a name="machine-learning-sparql-inference-query-predicates"></a>

Los siguientes predicados se utilizan con la inferencia de SPARQL:

## Predicado `neptune-ml:timeout`
<a name="machine-learning-sparql-inference-predicates-timeout"></a>

Especifica el tiempo de espera de la conexión con el servidor remoto. No debe confundirse con el tiempo de espera de la solicitud de consulta, que es el tiempo máximo que el servidor puede tardar en satisfacer una solicitud.

Tenga en cuenta que si el tiempo de espera de la consulta se produce antes de que se agote el tiempo de espera del servicio especificado por el predicado `neptune-ml:timeout`, la conexión del servicio también se cancelará.

## Predicado `neptune-ml:outputClass`
<a name="machine-learning-sparql-inference-predicates-outputClass"></a>

El predicado `neptune-ml:outputClass` solo se usa para definir la clase del objeto previsto para la predicción del objeto o del sujeto previsto para la predicción del sujeto.

## Predicado `neptune-ml:outputScore`
<a name="machine-learning-sparql-inference-predicates-outputScore"></a>

El predicado `neptune-ml:outputScore` es un número positivo que representa la probabilidad de que el resultado de un modelo de machine learning sea correcto.

## Predicado `neptune-ml:modelType`
<a name="machine-learning-sparql-inference-predicates-modelType"></a>

El predicado `neptune-ml:modelType` especifica el tipo de modelo de machine learning que se está entrenando:
+ `OBJECT_CLASSIFICATION`
+ `OBJECT_REGRESSION`
+ `OBJECT_PREDICTION`
+ `SUBJECT_PREDICTION`

## Predicado `neptune-ml:input`
<a name="machine-learning-sparql-inference-predicates-input"></a>

El predicado `neptune-ml:input` hace referencia a la lista de URI que se utilizan como entradas para Neptune ML.

## Predicado `neptune-ml:output`
<a name="machine-learning-sparql-inference-predicates-output"></a>

El predicado `neptune-ml:output` hace referencia a la lista de conjuntos de enlaces en los que Neptune ML devuelve resultados.

## Predicado `neptune-ml:predicate`
<a name="machine-learning-sparql-inference-predicates-predicate"></a>

El predicado `neptune-ml:predicate` se usa de manera diferente en función de la tarea que se esté realizando:
+ Para la **predicción de un objeto o un sujeto**: define el tipo de predicado (el tipo de borde o relación).
+ Para la **clasificación y regresión de objetos**: define el valor literal (propiedad) que queremos predecir.

## Predicado `neptune-ml:batchSize`
<a name="machine-learning-sparql-inference-predicates-batchSize"></a>

`neptune-ml:batchSize` especifica el tamaño de entrada para la llamada de servicio remoto.

# Ejemplos de clasificación de objetos de SPARQL
<a name="machine-learning-sparql-inference-object-classification"></a>

Para la clasificación de objetos de SPARQL en Neptune ML, el modelo se entrena en uno de los valores de los predicados. Esto es útil cuando ese predicado aún no está presente en un determinado sujeto.

Solo se pueden inferir valores de predicados categóricos con el modelo de clasificación de objetos.

La siguiente consulta busca predecir el valor del predicado <http://www.example.org/team> para todas las entradas del 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 <http://www.example.org/team> ;
                      neptune-ml:output ?output .
  }
}
```

Esta consulta se puede personalizar de la siguiente manera:

```
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 <http://www.example.org/team> ;
                      neptune-ml:output ?output .
  }
}
```

# Ejemplos de regresión de objetos de SPARQL
<a name="machine-learning-sparql-inference-object-regression"></a>

La regresión de objetos es similar a la clasificación de nodos, excepto el valor de predicado numérico inferido del modelo de regresión de cada nodo. Puede utilizar las mismas consultas de SPARQL para la regresión de objetos que para la clasificación de objetos, con la excepción de que los predicados `the Neptune#ml.limit` y `Neptune#ml.threshold` no son aplicables.

La siguiente consulta busca predecir el valor del predicado <http://www.example.org/accountbalance> para todas las entradas del 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 <http://www.example.org/accountbalance> ;
                      neptune-ml:output ?output .
  }
}
```

Esta consulta se puede personalizar de la siguiente manera:

```
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 <http://www.example.org/accountbalance> ;
                      neptune-ml:output ?output .
  }
}
```

# Ejemplo de predicción de objetos de SPARQL
<a name="machine-learning-sparql-inference-object-prediction"></a>

La *predicción de objetos* predice el valor del objeto para un sujeto y un predicado determinados.

La siguiente consulta de predicción de objetos busca predecir qué película le gustaría a la entrada del tipo `foaf:Person`:

```
?x a foaf:Person .
?x   <http://www.example.org/likes> ?m .
?m a <http://www.example.org/movie> .

## 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 <http://www.example.org/likes> ;
                      neptune-ml:output ?output ;
                      neptune-ml:outputClass <http://www.example.org/movie> .
  }
}
```

La consulta en sí misma se puede personalizar de la siguiente manera:

```
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 <http://www.example.org/likes> ;
                      neptune-ml:output ?output ;
                      neptune-ml:outputClass <http://www.example.org/movie> .
  }
}
```

# Ejemplo de predicción de sujetos de SPARQL
<a name="machine-learning-sparql-inference-subject-prediction"></a>

La *predicción de sujetos* predice el valor del sujetos para un objeto y un predicado determinados.

Por ejemplo, la siguiente consulta predice quién (del tipo `foaf:User`) verá una película determinada:

```
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 <http://aws.amazon.com/neptune/csv2rdf/object_Property/rated> ;
                          neptune-ml:output ?output ;
                          neptune-ml:outputClass <http://aws.amazon.com/neptune/csv2rdf/class/User> ;        }
}
```

# Lista de excepciones para las consultas de inferencia de SPARQL en Neptune ML
<a name="machine-learning-sparql-exceptions"></a>

****
+ **`BadRequestException`**: *Mensaje*: `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`**: *Mensaje*: `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`**: *Mensaje*: `Invalid predicate (predicate name) provided for external service http://aws.amazon.com/neptune/vocab/v01/services/ml#inference query.`
+ **`BadRequestException`**: *Mensaje*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the predicate (predicate name) to be defined`.
+ **`BadRequestException`**: *Mensaje*: `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`**: *Mensaje*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the input (parameter name) to be a constant, found: (type)`.
+ **`BadRequestException`**: *Mensaje*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference is expected to return only 1 value`.
+ **`BadRequestException`**: *Mensaje*: `"The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference only allows StatementPatternNodes`.
+ **`BadRequestException`**: *Mensaje*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference does not allow the predicate (predicate name)`.
+ **`BadRequestException`**: *Mensaje*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference predicates cannot be variables, found: (type)`.
+ **`BadRequestException`**: *Mensaje*: `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)`.