

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.

# Canalizaciones de inferencia de ML en Amazon OpenSearch Sin servidor

El `ml_inference` procesador en Amazon OpenSearch Serverless es un procesador de uso general que invoca un modelo de aprendizaje automático configurado y asigna las entradas y salidas del modelo a los campos de documentos o consultas. El mapeo se controla con el `input_map` y `output_map` parámetros, que especifican los campos del documento o consulta que proporcionan la entrada del modelo y los campos que reciben la salida del modelo.

A diferencia de los procesadores de aprendizaje automático diseñados específicamente, como `text_embedding`, `text_image_embedding`, y `sparse_encoding`, cada uno de los cuales admite un único tipo de modelo, el `ml_inference` el procesador funciona con cualquier modelo configurado. También se puede ejecutar tanto en las canalizaciones de ingesta como en las de búsqueda, por lo que puede aplicar la inferencia del modelo durante la indexación, antes de que se ejecute una consulta o después de que se devuelvan los resultados. Usa el `ml_inference` cuando necesite un modelo o un mapeo de entrada y salida que no proporcionan los procesadores diseñados específicamente. Para obtener la documentación conceptual completa, consulte [Procesador de inferencias de ML](https://docs.opensearch.org/latest/ingest-pipelines/processors/ml-inference/) en el *OpenSearch Documentación* sitio web.

Puedes usar el `ml_inference` procesador para admitir flujos de trabajo como los siguientes:
+ Búsqueda semántica
+ Retrieval-augmented generación (RAG)
+ Búsqueda multimodal
+ Resumen de resultados
+ Enriquecimiento de consultas

**Topics**
+ [Requisitos previos](#serverless-ml-inference-prerequisites)
+ [Ejemplo: configurar un modelo de incrustación de Amazon Titan](#serverless-ml-inference-model-setup)
+ [Haga coincidir el procesador con su modelo](#serverless-ml-inference-match-model)
+ [Uso de ml\_inference en una canalización de ingesta](#serverless-ml-inference-ingest)
+ [Uso de ml\_inference en una canalización de búsqueda](#serverless-ml-inference-search)
+ [Precios](#serverless-ml-inference-pricing)
+ [Permisos necesarios](#serverless-ml-inference-permissions)
+ [Resolución de problemas](#serverless-ml-inference-troubleshooting)
+ [Para obtener más información](#serverless-ml-inference-more-info)

## Requisitos previos
<a name="serverless-ml-inference-prerequisites"></a>

Antes de usar el `ml_inference` procesador, complete lo siguiente:
+ **Crea una colección de búsqueda vectorial.** OpenSearch Serverless es compatible con `ml_inference` procesador en colecciones de búsqueda vectorial (tipo `VECTORSEARCH`) en un NextGen grupo de colección. OpenSearch Serverless solo acepta modelos con un `function_name` de `remote`. Para crear el grupo de colecciones, consulte [Cree un grupo de recolección](serverless-collection-groups-procedures.md#collection-groups-create). Para crear la colección, consulte [Trabajo con colecciones de búsqueda vectorial](serverless-vector-search.md). Habilite las réplicas en espera tanto en el grupo de recopilación como en la colección.

  Lo siguiente AWS CLI el ejemplo crea un NextGen un grupo de colecciones y una colección de búsqueda vectorial en él. Reemplazar {{my-collection-group}} y {{my-collection}} con sus propios nombres.

  ```
  aws opensearchserverless create-collection-group \
      --name {{my-collection-group}} \
      --generation NEXTGEN \
      --standby-replicas ENABLED \
      --capacity-limits maxIndexingCapacityInOCU={{8}},maxSearchCapacityInOCU={{8}}
  
  aws opensearchserverless create-collection \
      --name {{my-collection}} \
      --type VECTORSEARCH \
      --collection-group-name {{my-collection-group}} \
      --standby-replicas ENABLED
  ```
+ **Configure e implemente un modelo remoto.** El procesador llama a un modelo remoto configurado e implementado, al que se hace referencia mediante su ID de modelo. Para ver un ejemplo en el que se configura un modelo de incrustación de Amazon Titan, consulte [Ejemplo: configurar un modelo de incrustación de Amazon Titan](#serverless-ml-inference-model-setup). Para obtener más información, consulte [Configuración de Machine Learning en Amazon OpenSearch Serverless](serverless-configure-machine-learning.md).
+ **Firme sus solicitudes.** Firma todas las solicitudes en el punto final de recolección con AWS Firma, versión 4, con el nombre del servicio `aoss`. Para obtener más información, consulte [Firma de solicitudes HTTP con otros clientes](serverless-clients.md#serverless-signing).

## Ejemplo: configurar un modelo de incrustación de Amazon Titan
<a name="serverless-ml-inference-model-setup"></a>

Los ejemplos de este tema utilizan un modelo Amazon Titan Text Embeddings V2 en Amazon Bedrock. Los pasos siguientes crean el conector y el modelo de su colección.

1. Cree un rol de IAM que OpenSearch Serverless asume que llama a Amazon Bedrock. La política de confianza del rol debe permitir que `ml.opensearchservice.amazonaws.com` principal del servicio, y la política de permisos del rol debe permitir `bedrock:InvokeModel` en el modelo. El director que crea el conector también necesita `iam:PassRole` en este rol.

1. Cree el conector de . Reemplazar {{region}} con el Región de AWS del modelo Amazon Bedrock, {{account-id}} con tu AWS ID de cuenta, y {{bedrock-role}} con el nombre del rol del paso anterior.

   ```
   POST /_plugins/_ml/connectors/_create
   {
     "name": "Amazon Bedrock Titan Text Embeddings V2",
     "description": "Connector for amazon.titan-embed-text-v2:0",
     "version": 1,
     "protocol": "aws_sigv4",
     "parameters": {
       "region": "{{region}}",
       "service_name": "bedrock",
       "model": "amazon.titan-embed-text-v2:0"
     },
     "credential": {
       "roleArn": "arn:aws:iam::{{account-id}}:role/{{bedrock-role}}"
     },
     "actions": [
       {
         "action_type": "predict",
         "method": "POST",
         "url": "https://bedrock-runtime.${parameters.region}.amazonaws.com/model/${parameters.model}/invoke",
         "headers": {
           "content-type": "application/json",
           "x-amz-content-sha256": "required"
         },
         "request_body": "{ \"inputText\": \"${parameters.inputText}\" }",
         "post_process_function": "connector.post_process.bedrock.embedding"
       }
     ]
   }
   ```

   La respuesta contiene el ID del conector. El `post_process_function` la configuración devuelve la incrustación en `$.inference_results[0].output[0].data`, que es la ruta que utilizan los ejemplos de este tema.

1. Registre el modelo con el conector. Reemplazar {{my-connector-id}} con el identificador del conector del paso anterior.

   ```
   POST /_plugins/_ml/models/_register
   {
     "name": "titan-embed-text-v2",
     "function_name": "remote",
     "description": "Amazon Titan Text Embeddings V2",
     "connector_id": "{{my-connector-id}}"
   }
   ```

   La respuesta contiene el identificador del modelo.

1. Implemente el modelo. Reemplazar {{my-model-id}} con el identificador del modelo del paso anterior.

   ```
   POST /_plugins/_ml/models/{{my-model-id}}/_deploy
   ```

1. Pruebe el modelo con la API de predicción, como se muestra en [Haga coincidir el procesador con su modelo](#serverless-ml-inference-match-model).

Estos pasos requieren los siguientes permisos en el `model` tipo de recurso: `aoss:CreateMLResource` para crear el conector y registrar el modelo, `aoss:UpdateMLResource` para desplegarlo, y `aoss:ExecuteMLResource` para llamar a la API de predicción. Para ver un ejemplo de política de acceso a datos que otorga estos permisos, consulte [Configurar permisos para Machine Learning](serverless-configure-machine-learning.md#serverless-configure-machine-learning-permissions).

## Haga coincidir el procesador con su modelo
<a name="serverless-ml-inference-match-model"></a>

El `ml_inference` el procesador no conoce la forma de su modelo. Lo cuentas con `input_map` y `output_map`. Si no coinciden con la API de predicción del modelo, el procesador falla o escribe un valor incorrecto. Primero, prueba el modelo con la API de predicción y, a continuación, copia los nombres de los parámetros y la ruta de salida en tu canalización.

En la siguiente tabla, se muestra el origen de cada parte del mapeo.


| Correspondencia | Con qué debe coincidir | 
| --- | --- | 
| Introduce input\_map | Un nombre de parámetro en la solicitud de predicción, que es ${parameters.{{name}}} marcador de posición en el conector request\_body. | 
| Valor en input\_map | El campo del documento o el campo de consulta que proporciona el valor. | 
| Introduce output\_map | El nombre del campo que recibe la salida del modelo. | 
| Valor en output\_map | Una ruta JSON hacia la respuesta de predicción, por ejemplo $.inference\_results[0].output[0].data. | 

El siguiente ejemplo llama a la API de predicción para un modelo de incrustación de texto. El `inputText` el parámetro es el mismo nombre que el ejemplo de canalización de ingesta usa como clave en `input_map`. Reemplazar {{my-model-id}} con el ID de su modelo desplegado.

```
POST /_plugins/_ml/models/{{my-model-id}}/_predict
{
  "parameters": {
    "inputText": "Example document text"
  }
}
```

El modelo devuelve una respuesta como la siguiente. El `data` la matriz se acorta para facilitar la lectura.

```
{
  "inference_results": [
    {
      "output": [
        {
          "name": "sentence_embedding",
          "data_type": "FLOAT32",
          "shape": [1024],
          "data": [0.0123, -0.0456, 0.0789]
        }
      ],
      "status_code": 200
    }
  ]
}
```

La incrustación está en `data` matriz de la primera salida. La ruta JSON `$.inference_results[0].output[0].data` lo selecciona. Esta es la ruta que utiliza el ejemplo de canalización de ingesta en `output_map`.

**nota**  
Esta forma de respuesta se aplica cuando el conector embebido Amazon Titan se establece `post_process_function` a `connector.post_process.bedrock.embedding`. Sin una función de posprocesamiento, el vector está en `$.inference_results[0].output[0].dataAsMap.embedding` en su lugar. Para ver la configuración del conector, consulte [Configuración de Machine Learning en Amazon OpenSearch Serverless](serverless-configure-machine-learning.md).

**importante**  
Los parámetros de la solicitud y la forma de la respuesta dependen del modelo y de su conector. Cuando utilice un modelo diferente, no vuelva a utilizar las rutas de los ejemplos de este tema. Ejecuta la API de predicción para tu modelo y lee las rutas de su respuesta.

Por ejemplo, un modelo de lenguaje grande que devuelve su respuesta sin procesar tiene una forma diferente. El texto está anidado dentro del `dataAsMap` y el parámetro que envíes lleva el nombre del marcador de posición del conector en lugar de `inputText`.

```
POST /_plugins/_ml/models/{{my-llm-model-id}}/_predict
{
  "parameters": {
    "messages": "[{\"role\":\"user\",\"content\":[{\"text\":\"Summarize: Example text\"}]}]"
  }
}
```

```
{
  "inference_results": [
    {
      "output": [
        {
          "name": "response",
          "dataAsMap": {
            "output": {
              "message": {
                "role": "assistant",
                "content": [
                  {
                    "text": "A short summary of the example text."
                  }
                ]
              }
            },
            "stopReason": "end_turn"
          }
        }
      ],
      "status_code": 200
    }
  ]
}
```

Para esta respuesta, la ruta JSON es `$.inference_results[0].output[0].dataAsMap.output.message.content[0].text`. La estructura exacta debajo `dataAsMap` es la respuesta de su proveedor de modelos, por lo que difiere entre los proveedores y los modelos.

Para cambiar el procesador a un modelo diferente, haga lo siguiente:

1. Busque los nombres de los parámetros en `request_body` del conector del modelo. Cada `${parameters.{{name}}}` el marcador de posición es un nombre que puedes usar como clave `input_map`.

1. Llame a la API de predicción con un valor de muestra para cada parámetro.

1. Lee la respuesta de predicción y escribe la ruta JSON del valor que deseas conservar.

1. Actualiza `model_id`, `input_map`, y `output_map` en trámite.

1. Ejecute el `_simulate` La API en un documento de muestra para confirmar que el campo de salida tiene el valor esperado.

**nota**  
La API de predicción requiere la `aoss:ExecuteMLResource` permiso sobre el recurso del modelo. Para obtener más información, consulte [Configuración de Machine Learning en Amazon OpenSearch Serverless](serverless-configure-machine-learning.md).

## Uso de ml\_inference en una canalización de ingesta
<a name="serverless-ml-inference-ingest"></a>

En una canalización de ingesta, el `ml_inference` el procesador ejecuta la inferencia del modelo durante la indexación. Un uso común es generar incrustaciones vectoriales a partir de un campo de texto para poder realizar una búsqueda semántica en los datos. El `input_map` asigna un campo de documento a la entrada del modelo, y `output_map` escribe la salida del modelo en un campo nuevo.

El siguiente ejemplo crea una canalización que envía el `text` campo al modelo y escribe la incrustación devuelta en un `embedding` campo. Reemplazar {{my-pipeline}} con el nombre de su oleoducto y {{my-model-id}} con el ID de su modelo desplegado.

```
PUT _ingest/pipeline/{{my-pipeline}}
{
  "description": "Generates embeddings with a configured model",
  "processors": [
    {
      "ml_inference": {
        "model_id": "{{my-model-id}}",
        "full_response_path": true,
        "input_map": [
          {
            "inputText": "text"
          }
        ],
        "output_map": [
          {
            "embedding": "$.inference_results[0].output[0].data"
          }
        ]
      }
    }
  ]
}
```

La solicitud devuelve la siguiente respuesta:

```
{
  "acknowledged": true
}
```

La `output_map` el camino tiene sus raíces en `inference_results` porque `full_response_path` está configurado en `true`. Esta configuración evalúa la ruta de salida comparándola con la respuesta completa del modelo. Para obtener más información, consulte [Procesador de inferencias de ML](https://docs.opensearch.org/latest/ingest-pipelines/processors/ml-inference/) en el *OpenSearch Documentación* sitio web.

Antes de aplicar la canalización al tráfico en tiempo real, puede simularla comparándola con documentos de muestra con el `_simulate` punto final. Para ejecutar automáticamente la inferencia del modelo en cada documento que esté indexado en un índice, defina `index.default_pipeline` configuración al crear el índice. Como alternativa, especifique la canalización en una solicitud de indexación individual con `pipeline` parámetro de consulta. Para obtener más información sobre la creación, la simulación y la aplicación de canalizaciones de ingesta, consulte [Ingiera oleoductos en Amazon OpenSearch Sin servidor](serverless-ingest-pipelines.md).

En el siguiente ejemplo, se indexa un documento y se ejecuta la canalización. Reemplazar {{my-index}} con el nombre de su índice y {{my-pipeline}} con el nombre de su canalización.

```
POST {{my-index}}/_doc?pipeline={{my-pipeline}}
{
  "text": "Example document text"
}
```

La respuesta confirma que el documento se ha indexado:

```
{
  "_index": "my-index",
  "_id": "93VTg6EBtHTIBjFym5yW",
  "_version": 1,
  "result": "created",
  "_shards": {
    "total": 0,
    "successful": 0,
    "failed": 0
  },
  "_seq_no": 0,
  "_primary_term": 0
}
```

**nota**  
El índice de destino debe configurarse para la búsqueda vectorial. Habilitar `index.knn` y mapear el campo de salida (por ejemplo, `embedding`) como `knn_vector` campo con una dimensión que coincide con su modelo.

## Uso de ml\_inference en una canalización de búsqueda
<a name="serverless-ml-inference-search"></a>

En una canalización de búsqueda, el `ml_inference` el procesador ejecuta la inferencia del modelo como parte de una consulta. Un procesador de solicitudes de búsqueda transforma o reescribe la consulta antes de ejecutarla. Un procesador de respuestas de búsqueda enriquece los resultados antes de que los recibas. Para ejecutar una canalización de búsqueda, envía la solicitud con el `search_pipeline` parámetro de consulta. Reemplazar {{my-index}} con el nombre de su índice y {{my-pipeline}} con el nombre de su canalización.

```
POST {{my-index}}/_search?search_pipeline={{my-pipeline}}
```

Para crear o actualizar una canalización de búsqueda, envía el cuerpo de la canalización a `_search/pipeline` punto final, como muestran los ejemplos de las siguientes secciones.

**nota**  
Una canalización de búsqueda recién creada puede tardar unos minutos en surtir efecto, incluso después de que se devuelva la solicitud de creación `"acknowledged": true`. Hasta entonces, las solicitudes de búsqueda que hacen referencia a la canalización fallan con un `Pipeline {{my-pipeline}} is not defined` error. Vuelva a intentar la solicitud tras una breve espera.

### Procesador de solicitudes de búsqueda
<a name="serverless-ml-inference-search-request"></a>

Antes utilizabas un procesador de solicitudes de búsqueda para reescribir una consulta entrante OpenSearch Serverless lo ejecuta. El siguiente ejemplo toma el texto de un `match` consulta, genera un vector a partir de ella con un modelo configurado y reescribe la solicitud para convertirla en una consulta k-nn con `query_template` parámetro. OpenSearch Serverless reemplaza al `${query_vec}` marcador de posición en la plantilla con la salida del modelo que `output_map` capturas. Reemplazar {{my-model-id}} con el ID de su modelo desplegado.

```
PUT /_search/pipeline/{{my-pipeline}}
{
  "request_processors": [
    {
      "ml_inference": {
        "model_id": "{{my-model-id}}",
        "full_response_path": true,
        "query_template": "{\"size\":2,\"_source\":[\"text\"],\"query\":{\"knn\":{\"embedding\":{\"vector\":${query_vec},\"k\":2}}}}",
        "input_map": [
          {
            "inputText": "query.match.text.query"
          }
        ],
        "output_map": [
          {
            "query_vec": "$.inference_results[0].output[0].data"
          }
        ],
        "ignore_missing": true
      }
    }
  ]
}
```

Establecer `full_response_path` a `true` para que el `output_map` La ruta JSON se resuelve en función de la respuesta completa del modelo. Esto le permite usar la misma ruta de salida que leyó en la respuesta de la API de predicción.

Establece `ignore_missing` a `true` cuando puede faltar el campo de origen. Una consulta que no contiene el campo mapeado, como `match_all` y, a continuación, pasa sin cambios en lugar de fallar. El procesador sigue reescribiendo las consultas que contienen el campo.

### Procesador de respuestas de búsqueda
<a name="serverless-ml-inference-search-response"></a>

Un procesador de respuestas de búsqueda se ejecuta cuando se devuelve una consulta, por lo que puedes enriquecer o resumir cada resultado. El siguiente ejemplo envía el `text` campo de cada visita a un modelo configurado y escribe la salida del modelo en un `text_vec` campo. Set `one_to_one` a `true` de modo que el procesador ejecute el modelo una vez por cada resultado de búsqueda. El valor predeterminado es `false`, que envía todas las visitas al modelo en una sola solicitud, y los modelos que esperan un único valor de entrada rechazan esa solicitud. Reemplazar {{my-model-id}} con el ID de su modelo desplegado.

```
PUT /_search/pipeline/{{my-pipeline}}
{
  "response_processors": [
    {
      "ml_inference": {
        "model_id": "{{my-model-id}}",
        "full_response_path": true,
        "input_map": [
          {
            "inputText": "text"
          }
        ],
        "output_map": [
          {
            "text_vec": "$.inference_results[0].output[0].data"
          }
        ],
        "one_to_one": true
      }
    }
  ]
}
```

Para resumir los resultados con un modelo lingüístico extenso, añada un `model_config` objeto que contiene la solicitud del modelo y el conjunto `one_to_one` a `true` de modo que el procesador resuma cada resultado de búsqueda por separado. El mensaje puede hacer referencia a la entrada mapeada mediante un parámetro de plantilla como `${parameters.context}`. El `output_map` la ruta de este ejemplo coincide con un modelo que devuelve su respuesta sin procesar. Para obtener más información, consulte [Haga coincidir el procesador con su modelo](#serverless-ml-inference-match-model). Reemplazar {{my-model-id}} con el ID de su modelo desplegado.

```
PUT /_search/pipeline/{{my-pipeline}}
{
  "response_processors": [
    {
      "ml_inference": {
        "model_id": "{{my-model-id}}",
        "full_response_path": true,
        "input_map": [
          {
            "context": "text"
          }
        ],
        "output_map": [
          {
            "summary": "$.inference_results[0].output[0].dataAsMap.output.message.content[0].text"
          }
        ],
        "model_config": {
          "messages": "[{\"role\":\"user\",\"content\":[{\"text\":\"Summarize the following text: ${parameters.context}\"}]}]"
        },
        "one_to_one": true
      }
    }
  ]
}
```

## Precios
<a name="serverless-ml-inference-pricing"></a>

El `ml_inference` el procesador se ejecuta en la computadora que procesa las solicitudes de tu colección. En una canalización de ingesta, su procesamiento se tiene en cuenta para la indexación OpenSearch Unidades de cálculo (OCU) para tu colección. En una canalización de búsqueda, su procesamiento se tiene en cuenta para las OCU de búsqueda, del mismo modo que cualquier otra actividad de indexación y búsqueda. Las canalizaciones con más procesadores o con procesadores con un uso intensivo de cómputos consumen más capacidad que las canalizaciones simples. Para obtener más información sobre cómo se escala y se factura la capacidad, consulte [Gestión de los límites de capacidad de Amazon OpenSearch Sin servidor](serverless-scaling.md) y [Amazon OpenSearch Precios de los servicios](https://aws.amazon.com/opensearch-service/pricing/).

El procesador también invoca el modelo remoto que configuró y el proveedor del modelo factura la inferencia del modelo por separado.

## Permisos necesarios
<a name="serverless-ml-inference-permissions"></a>

Administrar las canalizaciones de búsqueda e ingesta que contienen un `ml_inference` el procesador se asigna a lo siguiente OpenSearch Permisos de política de acceso a datos sin servidor. Los permisos se aplican a `collection` tipo de recurso.
+ `aoss:CreateCollectionItems` — Crear o actualizar una canalización.
+ `aoss:DescribeCollectionItems` — Obtenga, enumere y simule tuberías.
+ `aoss:DeleteCollectionItems` — Eliminar una canalización.

El procesador también llama al modelo que configuró. Para conocer los permisos de la política de acceso a los datos que un principal necesita para crear y ejecutar modelos, consulte [Configuración de Machine Learning en Amazon OpenSearch Serverless](serverless-configure-machine-learning.md).

**importante**  
El director que envía una solicitud a través de la canalización necesita el `aoss:ExecuteMLResource` permiso sobre el modelo. Esto se aplica a la indexación de documentos, en ejecución `_simulate`, y realizar búsquedas. Sin este permiso, estas solicitudes fallan con un `Forbidden` error que no nombra el permiso que falta.

El siguiente ejemplo de política de acceso a los datos otorga a un principal permiso para administrar las canalizaciones de una colección y ejecutar los modelos de esa colección. Reemplazar {{collection-name}} con el nombre de tu colección, {{account-id}} con tu AWS ID de cuenta, y {{role-name}} con el nombre de la función de IAM que administra y usa las canalizaciones.

```
[
    {
        "Description": "Manage pipelines and run models",
        "Rules": [
            {
                "ResourceType": "collection",
                "Resource": ["collection/{{collection-name}}"],
                "Permission": [
                    "aoss:CreateCollectionItems",
                    "aoss:DescribeCollectionItems",
                    "aoss:DeleteCollectionItems"
                ]
            },
            {
                "ResourceType": "model",
                "Resource": ["model/{{collection-name}}/*"],
                "Permission": [
                    "aoss:ExecuteMLResource"
                ]
            }
        ],
        "Principal": [
            "arn:aws:iam::{{account-id}}:role/{{role-name}}"
        ]
    }
]
```

Para el mapeo completo de OpenSearch Operaciones de API para OpenSearch Permisos sin servidor, consulte [Operaciones y complementos compatibles en Amazon OpenSearch Serverless](serverless-genref.md).

## Resolución de problemas
<a name="serverless-ml-inference-troubleshooting"></a>

Si una solicitud que utiliza un `ml_inference` la canalización falla con un `Forbidden` error, compruebe las siguientes causas comunes:
+ El director que llama no tiene `aoss:ExecuteMLResource` en el modelo. Añada un `model` regla a la política de acceso a datos, como se muestra en [Permisos necesarios](#serverless-ml-inference-permissions).
+ La política de acceso a los datos no otorga al director los permisos de indexación o recopilación para la operación, como escribir documentos, realizar búsquedas o crear canalizaciones.
+ La solicitud se firma con el nombre del servicio `es` en lugar de `aoss`.
+ La política de red de la recopilación no permite el acceso desde la fuente de la solicitud.

Si una solicitud de búsqueda falla con un `Pipeline {{my-pipeline}} is not defined` se produce un error justo después de crear la canalización, espera unos minutos y vuelve a intentarlo. Para obtener más información, consulte [Uso de ml\_inference en una canalización de búsqueda](#serverless-ml-inference-search).

## Para obtener más información
<a name="serverless-ml-inference-more-info"></a>

Para obtener más información acerca de `ml_inference` procesador, consulte lo siguiente:
+ Para obtener información sobre el procesador de canalización de entrada, consulte [Procesador de inferencias de ML](https://docs.opensearch.org/latest/ingest-pipelines/processors/ml-inference/) en el *OpenSearch Documentación* sitio web.
+ Para ver la referencia del procesador de solicitudes de búsqueda, consulte [Procesador de solicitudes de búsqueda por inferencia de ML](https://docs.opensearch.org/latest/search-plugins/search-pipelines/ml-inference-search-request/) en el *OpenSearch Documentación* sitio web.
+ Para obtener información de referencia sobre el procesador de respuestas de búsqueda, consulte [Procesador de respuestas de búsqueda por inferencia de ML](https://docs.opensearch.org/latest/search-plugins/search-pipelines/ml-inference-search-response/) en el *OpenSearch Documentación* sitio web.
+ Para ver un ejemplo práctico de resumen de reseñas y búsqueda semántica, consulte [Introducción a los procesadores de inferencia de ML en OpenSearch: revisión, resumen y búsqueda semántica](https://opensearch.org/blog/introduction-to-ml-inference-processors-in-opensearch-review-summarization-and-semantic-search/) en el *OpenSearch* blog.