

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Pipeline di inferenza ML in Amazon OpenSearch Senza server

Il `ml_inference` processore in Amazon OpenSearch Serverless è un processore generico che richiama un modello di machine learning configurato e mappa gli input e gli output del modello nei campi di documenti o interrogazioni. Puoi controllare la mappatura con `input_map` e `output_map` parametri, che specificano i campi del documento o della query che forniscono l'input del modello e i campi che ricevono l'output del modello.

A differenza dei processori di machine learning appositamente progettati come `text_embedding`, `text_image_embedding`, e `sparse_encoding`, che supportano ciascuno un singolo tipo di modello, il `ml_inference` il processore funziona con qualsiasi modello configurato. Può anche essere eseguito sia nelle pipeline di ingest che nelle pipeline di ricerca, in modo da poter applicare l'inferenza del modello durante l'indicizzazione, prima dell'esecuzione di una query o dopo la restituzione dei risultati. Usa il `ml_inference` processore quando è necessario un modello o una mappatura di input e output che i processori appositamente progettati non forniscono. Per una documentazione concettuale completa, vedere [Processore di inferenza ML](https://docs.opensearch.org/latest/ingest-pipelines/processors/ml-inference/) sul *OpenSearch Documentazione* sito web.

Puoi usare `ml_inference` processore per supportare flussi di lavoro come i seguenti:
+ Ricerca semantica
+ Retrieval-augmented generazione (RAG)
+ Ricerca multimodale
+ Riepilogo dei risultati
+ Arricchimento delle query

**Topics**
+ [Prerequisiti](#serverless-ml-inference-prerequisites)
+ [Esempio: configura un modello di incorporamento di Amazon Titan](#serverless-ml-inference-model-setup)
+ [Abbina il processore al tuo modello](#serverless-ml-inference-match-model)
+ [Utilizzo di ml\_inference in una pipeline di ingest](#serverless-ml-inference-ingest)
+ [Usare ml\_inference in una pipeline di ricerca](#serverless-ml-inference-search)
+ [Prezzi](#serverless-ml-inference-pricing)
+ [Autorizzazioni richieste](#serverless-ml-inference-permissions)
+ [Risoluzione dei problemi](#serverless-ml-inference-troubleshooting)
+ [Ulteriori informazioni](#serverless-ml-inference-more-info)

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

Prima di utilizzare `ml_inference` processore, completare quanto segue:
+ **Crea una raccolta di ricerche vettoriali.** OpenSearch Serverless supporta `ml_inference` processore sulle raccolte di ricerca vettoriale (tipo `VECTORSEARCH`) in un NextGen gruppo di raccolta. OpenSearch Serverless accetta solo modelli con un `function_name` di `remote`. Per creare il gruppo di raccolta, vedi [Crea un gruppo di raccolta](serverless-collection-groups-procedures.md#collection-groups-create). Per creare la collezione, vedi [Lavorare con le raccolte di ricerca vettoriale](serverless-vector-search.md). Abilita le repliche in standby sia sul gruppo di raccolta che sulla raccolta.

  Quanto segue AWS CLI l'esempio crea un NextGen gruppo di raccolta e una raccolta di ricerca vettoriale al suo interno. Sostituisci {{my-collection-group}} e {{my-collection}} con i tuoi nomi.

  ```
  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
  ```
+ **Configura e implementa un modello remoto.** Il processore chiama un modello remoto configurato e distribuito, a cui si fa riferimento tramite l'ID del modello. Per un esempio che configura un modello di incorporamento di Amazon Titan, consulta [Esempio: configura un modello di incorporamento di Amazon Titan](#serverless-ml-inference-model-setup). Per ulteriori informazioni, consulta [Configurazione del Machine Learning su Amazon OpenSearch Serverless](serverless-configure-machine-learning.md).
+ **Firma le tue richieste.** Firma ogni richiesta all'endpoint di raccolta con AWS Signature Version 4 utilizzando il nome del servizio `aoss`. Per ulteriori informazioni, consulta [Firma delle richieste HTTP con altri client](serverless-clients.md#serverless-signing).

## Esempio: configura un modello di incorporamento di Amazon Titan
<a name="serverless-ml-inference-model-setup"></a>

Gli esempi in questo argomento utilizzano un modello Amazon Titan Text Embeddings V2 in Amazon Bedrock. I passaggi seguenti creano il connettore e il modello nella tua collezione.

1. Crea un ruolo IAM che OpenSearch Serverless presume di chiamare Amazon Bedrock. La politica di fiducia del ruolo deve consentire `ml.opensearchservice.amazonaws.com` responsabile del servizio e la politica delle autorizzazioni del ruolo devono consentire `bedrock:InvokeModel` sul modello. Anche il committente che crea il connettore deve `iam:PassRole` in questo ruolo.

1. Crea il connettore. Sostituisci {{region}} con il Regione AWS del modello Amazon Bedrock, {{account-id}} con il tuo AWS ID dell'account e {{bedrock-role}} con il nome del ruolo del passaggio precedente.

   ```
   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 risposta contiene l'ID del connettore. Il `post_process_function` l'impostazione restituisce l'incorporamento in `$.inference_results[0].output[0].data`, che è il percorso utilizzato dagli esempi in questo argomento.

1. Registrate il modello con il connettore. Sostituisci {{my-connector-id}} con l'ID del connettore del passaggio precedente.

   ```
   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 risposta contiene l'ID del modello.

1. Implementare il modello. Sostituisci {{my-model-id}} con l'ID del modello del passaggio precedente.

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

1. Testa il modello con l'API di previsione, come mostrato in [Abbina il processore al tuo modello](#serverless-ml-inference-match-model).

Questi passaggi richiedono le seguenti autorizzazioni su `model` tipo di risorsa: `aoss:CreateMLResource` per creare il connettore e registrare il modello, `aoss:UpdateMLResource` per distribuirlo e `aoss:ExecuteMLResource` per chiamare l'API predict. Per un esempio di politica di accesso ai dati che concede queste autorizzazioni, consulta [Configurare le autorizzazioni per il Machine Learning](serverless-configure-machine-learning.md#serverless-configure-machine-learning-permissions).

## Abbina il processore al tuo modello
<a name="serverless-ml-inference-match-model"></a>

Il `ml_inference` il processore non conosce la forma del modello. Lo racconti con `input_map` e `output_map`. Se non corrispondono all'API di previsione del modello, il processore non funziona o scrive il valore sbagliato. Prova prima il modello con l'API di previsione, quindi copia i nomi dei parametri e il percorso di output nella pipeline.

La tabella seguente mostra da dove proviene ogni parte della mappatura.


| Mapping | A cosa deve corrispondere | 
| --- | --- | 
| Digitare input\_map | Un nome di parametro nella richiesta di previsione, che è un ${parameters.{{name}}} segnaposto nel connettore request\_body. | 
| Valore in input\_map | Il campo del documento, o campo di interrogazione, che fornisce il valore. | 
| Digitare output\_map | Il nome del campo che riceve l'output del modello. | 
| Valore in output\_map | Un percorso JSON nella risposta prevista, ad esempio $.inference\_results[0].output[0].data. | 

L'esempio seguente chiama l'API predict per un modello di incorporamento del testo. Il `inputText` il parametro è lo stesso nome utilizzato dall'esempio di pipeline di ingest come chiave in `input_map`. Sostituire {{my-model-id}} con l'ID del modello distribuito.

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

Il modello restituisce una risposta come la seguente. La `data` l'array è abbreviato per motivi di leggibilità.

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

L'incorporamento è in `data` matrice della prima uscita. Il percorso JSON `$.inference_results[0].output[0].data` lo seleziona. Questo è il percorso utilizzato dall'esempio di pipeline di ingest in `output_map`.

**Nota**  
Questa forma di risposta si applica quando viene impostato il connettore di incorporamento di Amazon Titan `post_process_function` a `connector.post_process.bedrock.embedding`. Senza una funzione di post-elaborazione, il vettore è `$.inference_results[0].output[0].dataAsMap.embedding` invece. Per la configurazione del connettore, vedere [Configurazione del Machine Learning su Amazon OpenSearch Serverless](serverless-configure-machine-learning.md).

**Importante**  
I parametri della richiesta e la forma della risposta dipendono dal modello e dal relativo connettore. Quando utilizzate un modello diverso, non riutilizzate i percorsi degli esempi in questo argomento. Esegui l'API di previsione per il tuo modello e leggi i percorsi in base alla sua risposta.

Ad esempio, un modello linguistico di grandi dimensioni che restituisce la risposta non elaborata ha una forma diversa. Il testo è annidato all'interno di `dataAsMap` oggetto e il parametro inviato prende il nome dal segnaposto del connettore anziché `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
    }
  ]
}
```

Per questa risposta, il percorso JSON è `$.inference_results[0].output[0].dataAsMap.output.message.content[0].text`. La struttura esatta sotto `dataAsMap` è la risposta del fornitore del modello, quindi differisce tra fornitori e modelli.

Per passare al processore a un modello diverso, effettuate le seguenti operazioni:

1. Trovate i nomi dei parametri nel `request_body` del connettore del modello. Ciascuno `${parameters.{{name}}}` segnaposto è un nome che puoi usare come chiave `input_map`.

1. Chiama l'API di previsione con un valore di esempio per ogni parametro.

1. Leggi la risposta di predict e scrivi il percorso JSON del valore che desideri mantenere.

1. Aggiorna `model_id`, `input_map`, e `output_map` in cantiere.

1. Esegui il `_simulate` API su un documento di esempio per confermare che il campo di output ha il valore previsto.

**Nota**  
L'API predict richiede `aoss:ExecuteMLResource` autorizzazione sulla risorsa del modello. Per ulteriori informazioni, consulta [Configurazione del Machine Learning su Amazon OpenSearch Serverless](serverless-configure-machine-learning.md).

## Utilizzo di ml\_inference in una pipeline di ingest
<a name="serverless-ml-inference-ingest"></a>

In una pipeline di ingest, `ml_inference` il processore esegue l'inferenza del modello durante l'indicizzazione. Un uso comune è generare incorporamenti vettoriali da un campo di testo in modo da poter eseguire una ricerca semantica sui dati. Il `input_map` associa un campo del documento all'input del modello e `output_map` scrive l'output del modello in un nuovo campo.

L'esempio seguente crea una pipeline che invia `text` campo nel modello e scrive l'incorporamento restituito in un `embedding` campo. Sostituisci {{my-pipeline}} con il nome della tua pipeline e {{my-model-id}} con l'ID del modello distribuito.

```
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 richiesta restituisce la seguente risposta:

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

La `output_map` il percorso è radicato in `inference_results` perché `full_response_path` è impostato su `true`. Questa impostazione valuta il percorso di output rispetto alla risposta completa del modello. Per ulteriori informazioni, vedere [Processore di inferenza ML](https://docs.opensearch.org/latest/ingest-pipelines/processors/ml-inference/) sul *OpenSearch Documentazione* sito web.

Prima di applicare la pipeline al traffico in tempo reale, puoi simularla rispetto a documenti di esempio con `_simulate` endpoint. Per eseguire automaticamente l'inferenza del modello su ogni documento indicizzato in un indice, imposta il `index.default_pipeline` impostazione al momento della creazione dell'indice. In alternativa, specificate la pipeline su una singola richiesta di indicizzazione con il `pipeline` parametro di interrogazione. Per ulteriori informazioni sulla creazione, la simulazione e l'applicazione delle pipeline di ingest, vedere [Acquisisci pipeline in Amazon OpenSearch Senza server](serverless-ingest-pipelines.md).

L'esempio seguente indicizza un documento ed esegue la pipeline. Sostituisci {{my-index}} con il nome del tuo indice e {{my-pipeline}} con il nome della tua pipeline.

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

La risposta conferma che il documento è stato indicizzato:

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

**Nota**  
L'indice di destinazione deve essere configurato per la ricerca vettoriale. Abilita `index.knn` e mappare il campo di output (ad esempio `embedding`) come `knn_vector` campo con una dimensione che corrisponde al tuo modello.

## Usare ml\_inference in una pipeline di ricerca
<a name="serverless-ml-inference-search"></a>

In una pipeline di ricerca, `ml_inference` il processore esegue l'inferenza del modello come parte di una query. Un processore di richieste di ricerca trasforma o riscrive la query prima che venga eseguita. Un processore di risposta alla ricerca arricchisce i risultati prima che tu li riceva. Per eseguire una pipeline di ricerca, invia la richiesta con `search_pipeline` parametro di interrogazione. Sostituisci {{my-index}} con il nome del tuo indice e {{my-pipeline}} con il nome della tua pipeline.

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

Per creare o aggiornare una pipeline di ricerca, invia il corpo della pipeline a `_search/pipeline` endpoint, come mostrano gli esempi nelle sezioni seguenti.

**Nota**  
Una pipeline di ricerca appena creata può richiedere alcuni minuti per avere effetto, anche dopo la restituzione della richiesta di creazione `"acknowledged": true`. Fino ad allora, le richieste di ricerca che fanno riferimento alla pipeline hanno esito negativo con un `Pipeline {{my-pipeline}} is not defined` errore. Riprova la richiesta dopo una breve attesa.

### Processore delle richieste di ricerca
<a name="serverless-ml-inference-search-request"></a>

In precedenza si utilizza un processore di richieste di ricerca per riscrivere una query in arrivo OpenSearch Serverless lo esegue. L'esempio seguente prende il testo di un `match` query, ne genera un vettore con un modello configurato e riscrive la richiesta in una query k-NN con `query_template` parametro. OpenSearch Serverless sostituisce il `${query_vec}` segnaposto nel modello con l'output del modello che `output_map` cattura. Sostituisci {{my-model-id}} con l'ID del modello distribuito.

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

Imposta `full_response_path` a `true` in modo che `output_map` Il percorso JSON si risolve in base alla risposta completa del modello. Ciò consente di utilizzare lo stesso percorso di output letto dalla risposta dell'API di previsione.

Imposta `ignore_missing` a `true` quando potrebbe mancare il campo sorgente. Una query che non contiene il campo mappato, ad esempio `match_all` query, quindi viene eseguita invariata anziché fallire. Il processore continua a riscrivere le interrogazioni che contengono il campo.

### Processore di risposta alla ricerca
<a name="serverless-ml-inference-search-response"></a>

Un processore di risposta alla ricerca viene eseguito dopo la restituzione di una query, in modo da poter arricchire o riepilogare ogni risultato. L'esempio seguente invia `text` campo di ogni hit su un modello configurato e scrive l'output del modello in un `text_vec` campo. Impostare `one_to_one` a `true` in modo che il processore esegua il modello una volta per ogni risultato di ricerca. L'impostazione predefinita è `false`, che invia tutti gli hit al modello in un'unica richiesta e i modelli che prevedono un singolo valore di input rifiutano tale richiesta. Sostituisci {{my-model-id}} con l'ID del modello distribuito.

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

Per riassumere i risultati con un modello linguistico di grandi dimensioni, aggiungi un `model_config` oggetto che contiene il prompt del modello e il set `one_to_one` a `true` in modo che il processore riassuma separatamente ogni risultato di ricerca. Il prompt può fare riferimento all'input mappato tramite un parametro del modello come `${parameters.context}`. Il `output_map` il percorso in questo esempio corrisponde a un modello che restituisce la sua risposta grezza. Per ulteriori informazioni, consulta [Abbina il processore al tuo modello](#serverless-ml-inference-match-model). Sostituisci {{my-model-id}} con l'ID del modello distribuito.

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

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

Il `ml_inference` il processore viene eseguito sul computer che elabora le richieste della raccolta. In una pipeline di ingest, la sua elaborazione viene conteggiata ai fini dell'indicizzazione OpenSearch Compute Units (OCU) per la tua raccolta. In una pipeline di ricerca, la sua elaborazione viene conteggiata ai fini degli OCU di ricerca, allo stesso modo delle altre attività di indicizzazione e ricerca. Le pipeline con più processori o con processori ad alta intensità di calcolo consumano più capacità rispetto alle pipeline semplici. Per ulteriori informazioni sulla scalabilità e sulla fatturazione della capacità, consulta [Gestione dei limiti di capacità per Amazon OpenSearch Senza server](serverless-scaling.md) e [Amazon OpenSearch Prezzi del servizio](https://aws.amazon.com/opensearch-service/pricing/).

Il processore richiama anche il modello remoto configurato e il fornitore del modello fattura separatamente l'inferenza del modello.

## Autorizzazioni richieste
<a name="serverless-ml-inference-permissions"></a>

Gestione delle pipeline di ricerca e acquisizione che contengono un `ml_inference` il processore è mappato a quanto segue OpenSearch Autorizzazioni delle policy di accesso ai dati senza server. Le autorizzazioni si applicano a `collection` tipo di risorsa.
+ `aoss:CreateCollectionItems` — Creare o aggiornare una pipeline.
+ `aoss:DescribeCollectionItems` — Recupera, elenca e simula le pipeline.
+ `aoss:DeleteCollectionItems` — Eliminare una pipeline.

Il processore richiama anche il modello configurato. Per le autorizzazioni relative alle policy di accesso ai dati di cui un responsabile ha bisogno per creare ed eseguire modelli, consulta [Configurazione del Machine Learning su Amazon OpenSearch Serverless](serverless-configure-machine-learning.md).

**Importante**  
Il committente che invia una richiesta tramite la pipeline ha bisogno di `aoss:ExecuteMLResource` autorizzazione sul modello. Questo vale per l'indicizzazione dei documenti, in esecuzione `_simulate`e ricerca. Senza questa autorizzazione, queste richieste hanno esito negativo con un `Forbidden` errore che non indica l'autorizzazione mancante.

Il seguente esempio di politica di accesso ai dati concede a un principale l'autorizzazione a gestire le pipeline in una raccolta e ad eseguire i modelli in quella raccolta. Sostituisci {{collection-name}} con il nome della tua collezione, {{account-id}} con il tuo AWS ID dell'account e {{role-name}} con il nome del ruolo IAM che gestisce e utilizza le pipeline.

```
[
    {
        "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}}"
        ]
    }
]
```

Per la mappatura completa di OpenSearch Operazioni API per OpenSearch Autorizzazioni serverless, vedi [Operazioni e plugin supportati in Amazon Serverless OpenSearch](serverless-genref.md).

## Risoluzione dei problemi
<a name="serverless-ml-inference-troubleshooting"></a>

Se una richiesta utilizza un `ml_inference` la pipeline fallisce con a `Forbidden` errore, controlla le seguenti cause comuni:
+ Il preside chiamante non ha `aoss:ExecuteMLResource` sul modello. Aggiungere un `model` regola alla politica di accesso ai dati, come mostrato in [Autorizzazioni richieste](#serverless-ml-inference-permissions).
+ La politica di accesso ai dati non concede al committente le autorizzazioni di indicizzazione o raccolta per l'operazione, ad esempio la scrittura di documenti, la ricerca o la creazione di pipeline.
+ La richiesta è firmata con il nome del servizio `es` invece di `aoss`.
+ La politica di rete per la raccolta non consente l'accesso dall'origine della richiesta.

Se una richiesta di ricerca non va a buon fine con un `Pipeline {{my-pipeline}} is not defined` errore subito dopo aver creato la pipeline, attendi qualche minuto e riprova. Per ulteriori informazioni, consulta [Usare ml\_inference in una pipeline di ricerca](#serverless-ml-inference-search).

## Ulteriori informazioni
<a name="serverless-ml-inference-more-info"></a>

Per ulteriori informazioni su `ml_inference` processore, vedere quanto segue:
+ Per il riferimento al processore ingest-pipeline, vedere [Processore di inferenza ML](https://docs.opensearch.org/latest/ingest-pipelines/processors/ml-inference/) sul *OpenSearch Documentazione* sito web.
+ Per il riferimento al processore di richieste di ricerca, vedere [Processore di richieste di ricerca per inferenza ML](https://docs.opensearch.org/latest/search-plugins/search-pipelines/ml-inference-search-request/) sul *OpenSearch Documentazione* sito web.
+ Per il riferimento al processore di risposta alla ricerca, vedere [Processore di risposta alla ricerca con inferenza ML](https://docs.opensearch.org/latest/search-plugins/search-pipelines/ml-inference-search-response/) sul *OpenSearch Documentazione* sito web.
+ Per un esempio funzionante di riepilogo delle recensioni e ricerca semantica, vedi [Introduzione ai processori di inferenza ML in OpenSearch: riepilogo delle revisioni e ricerca semantica](https://opensearch.org/blog/introduction-to-ml-inference-processors-in-opensearch-review-summarization-and-semantic-search/) sul *OpenSearch* blog.