

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Saluran inferensi ML di Amazon OpenSearch Tanpa server

 `ml_inference` prosesor di Amazon OpenSearch Serverless adalah prosesor tujuan umum yang memanggil model pembelajaran mesin yang dikonfigurasi dan memetakan input dan output model ke bidang dokumen atau query. Anda mengontrol pemetaan dengan `input_map` dan `output_map` parameter, yang menentukan kolom dokumen atau query yang menyediakan input model dan bidang yang menerima output model.

Berbeda dengan prosesor pembelajaran mesin yang dibuat khusus seperti `text_embedding`, `text_image_embedding`, dan `sparse_encoding`, yang masing-masing mendukung satu jenis model, `ml_inference` prosesor bekerja dengan model yang dikonfigurasi. Ini juga dapat berjalan di saluran ingest dan pipeline pencarian, sehingga Anda dapat menerapkan inferensi model selama pengindeksan, sebelum kueri berjalan, atau setelah hasil dikembalikan. Gunakan `ml_inference` prosesor ketika Anda membutuhkan model atau pemetaan input dan output yang tidak disediakan oleh prosesor yang dibuat khusus. Untuk dokumentasi konseptual lengkap, lihat [Prosesor inferensi ML](https://docs.opensearch.org/latest/ingest-pipelines/processors/ml-inference/) pada *OpenSearch Dokumentasi* situs web.

Anda dapat menggunakan `ml_inference` prosesor untuk mendukung alur kerja seperti berikut:
+ Pencarian semantik
+ Retrieval-augmented generasi (RAG)
+ Pencarian multimodal
+ Ringkasan hasil
+ Pengayaan kueri

**Topics**
+ [Prasyarat](#serverless-ml-inference-prerequisites)
+ [Contoh: Menyiapkan model penyematan Amazon Titan](#serverless-ml-inference-model-setup)
+ [Cocokkan prosesor dengan model Anda](#serverless-ml-inference-match-model)
+ [Menggunakan ml\_inference dalam pipeline ingest](#serverless-ml-inference-ingest)
+ [Menggunakan ml\_inference dalam pipeline pencarian](#serverless-ml-inference-search)
+ [Harga](#serverless-ml-inference-pricing)
+ [Izin yang diperlukan](#serverless-ml-inference-permissions)
+ [Pemecahan Masalah](#serverless-ml-inference-troubleshooting)
+ [Untuk informasi selengkapnya](#serverless-ml-inference-more-info)

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

Sebelum Anda menggunakan `ml_inference` prosesor, lengkapi yang berikut ini:
+ **Buat koleksi pencarian vektor.** OpenSearch Serverless mendukung `ml_inference` prosesor pada koleksi pencarian vektor (tipe `VECTORSEARCH`) dalam NextGen kelompok koleksi. OpenSearch Serverless hanya menerima model dengan `function_name` dari `remote`. Untuk membuat grup koleksi, lihat [Buat grup koleksi](serverless-collection-groups-procedures.md#collection-groups-create). Untuk membuat koleksi, lihat [Bekerja dengan koleksi pencarian vektor](serverless-vector-search.md). Aktifkan replika siaga pada grup koleksi dan koleksi.

  Berikut ini AWS CLI contoh menciptakan NextGen kelompok koleksi dan koleksi pencarian vektor di dalamnya. Ganti {{my-collection-group}} dan {{my-collection}} dengan namamu sendiri.

  ```
  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
  ```
+ **Konfigurasikan dan gunakan model jarak jauh.** Prosesor memanggil model jarak jauh yang dikonfigurasi dan digunakan, yang Anda referensikan dengan ID modelnya. Untuk contoh yang mengatur model penyematan Amazon Titan, lihat [Contoh: Menyiapkan model penyematan Amazon Titan](#serverless-ml-inference-model-setup). Untuk informasi selengkapnya, lihat [Konfigurasikan Machine Learning di Amazon Tanpa OpenSearch Server](serverless-configure-machine-learning.md).
+ **Tanda tangani permintaan Anda.** Tanda tangani setiap permintaan ke titik akhir pengumpulan dengan AWS Tanda tangan Versi 4 menggunakan nama layanan `aoss`. Untuk informasi selengkapnya, lihat [Menandatangani permintaan HTTP dengan klien lain](serverless-clients.md#serverless-signing).

## Contoh: Menyiapkan model penyematan Amazon Titan
<a name="serverless-ml-inference-model-setup"></a>

Contoh dalam topik ini menggunakan model Amazon Titan Text Embeddings V2 di Amazon Bedrock. Langkah-langkah berikut membuat konektor dan model dalam koleksi Anda.

1. Buat peran IAM yang OpenSearch Serverless mengasumsikan untuk memanggil Amazon Bedrock. Kebijakan kepercayaan peran harus memungkinkan `ml.opensearchservice.amazonaws.com` prinsip layanan, dan kebijakan izin peran harus mengizinkan `bedrock:InvokeModel` pada model. Prinsip yang membuat konektor juga membutuhkan `iam:PassRole` pada peran ini.

1. Buat konektor. Ganti {{region}} dengan Wilayah AWS dari model Amazon Bedrock, {{account-id}} dengan Anda AWS ID akun, dan {{bedrock-role}} dengan nama peran dari langkah sebelumnya.

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

   Respons berisi ID konektor. `post_process_function` pengaturan mengembalikan penyematan di `$.inference_results[0].output[0].data`, yang merupakan jalur yang digunakan contoh dalam topik ini.

1. Daftarkan model dengan konektor. Ganti {{my-connector-id}} dengan ID konektor dari langkah sebelumnya.

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

   Respons berisi ID model.

1. Men-deploy model. Ganti {{my-model-id}} dengan ID model dari langkah sebelumnya.

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

1. Uji model dengan API prediksi, seperti yang ditunjukkan pada [Cocokkan prosesor dengan model Anda](#serverless-ml-inference-match-model).

Langkah-langkah ini memerlukan izin berikut pada `model` jenis sumber daya: `aoss:CreateMLResource` untuk membuat konektor dan mendaftarkan model, `aoss:UpdateMLResource` untuk menerapkannya, dan `aoss:ExecuteMLResource` untuk memanggil API prediksi. Untuk contoh kebijakan akses data yang memberikan izin ini, lihat [Mengkonfigurasi izin untuk Machine Learning](serverless-configure-machine-learning.md#serverless-configure-machine-learning-permissions).

## Cocokkan prosesor dengan model Anda
<a name="serverless-ml-inference-match-model"></a>

 `ml_inference` prosesor tidak tahu bentuk model Anda. Anda mengatakannya dengan `input_map` dan `output_map`. Jika ini tidak cocok dengan API prediksi model, prosesor gagal atau menulis nilai yang salah. Uji model dengan API prediksi terlebih dahulu, lalu salin nama parameter dan jalur keluaran ke pipeline Anda.

Tabel berikut menunjukkan dari mana setiap bagian pemetaan berasal.


| Pemetaan | Apa yang harus cocok | 
| --- | --- | 
| Kunci masuk input\_map | Nama parameter dalam permintaan prediksi, yang merupakan ${parameters.{{name}}} placeholder di konektor request\_body. | 
| Nilai dalam input\_map | Bidang dokumen, atau bidang kueri, yang menyediakan nilai. | 
| Kunci masuk output\_map | Nama bidang yang menerima output model. | 
| Nilai dalam output\_map | Jalur JSON ke respons prediksi, misalnya $.inference\_results[0].output[0].data. | 

Contoh berikut memanggil API prediksi untuk model penyematan teks. `inputText` parameter adalah nama yang sama dengan yang digunakan contoh saluran ingest sebagai kunci `input_map`. Ganti {{my-model-id}} dengan ID model yang Anda gunakan.

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

Model mengembalikan respons seperti berikut ini. `data` array disingkat untuk keterbacaan.

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

Penanamannya ada di `data` array dari output pertama. Jalur JSON `$.inference_results[0].output[0].data` memilihnya. Ini adalah jalur yang digunakan contoh saluran cerna di `output_map`.

**catatan**  
Bentuk respons ini berlaku saat konektor penyematan Amazon Titan disetel `post_process_function` kepada `connector.post_process.bedrock.embedding`. Tanpa fungsi pasca-pemrosesan, vektor berada di `$.inference_results[0].output[0].dataAsMap.embedding` sebagai gantinya. Untuk pengaturan konektor, lihat [Konfigurasikan Machine Learning di Amazon Tanpa OpenSearch Server](serverless-configure-machine-learning.md).

**penting**  
Parameter permintaan dan bentuk respons tergantung pada model dan konektornya. Saat Anda menggunakan model yang berbeda, jangan menggunakan kembali jalur dari contoh dalam topik ini. Jalankan API prediksi untuk model Anda dan baca jalur dari responsnya.

Misalnya, model bahasa besar yang mengembalikan respons mentah memiliki bentuk yang berbeda. Teks bersarang di dalam `dataAsMap` objek, dan parameter yang Anda kirim diberi nama setelah placeholder konektor alih-alih `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
    }
  ]
}
```

Untuk respons ini, jalur JSON adalah `$.inference_results[0].output[0].dataAsMap.output.message.content[0].text`. Struktur yang tepat di bawah `dataAsMap` adalah respons penyedia model Anda, sehingga berbeda antara penyedia dan model.

Untuk mengalihkan prosesor ke model yang berbeda, lakukan hal berikut:

1. Temukan nama-nama parameter di `request_body` dari konektor model. Masing-masing `${parameters.{{name}}}` placeholder adalah nama yang dapat Anda gunakan sebagai kunci di `input_map`.

1. Panggil API prediksi dengan nilai sampel untuk setiap parameter.

1. Baca respon prediksi, dan tulis jalur JSON ke nilai yang ingin Anda simpan.

1. Perbarui `model_id`, `input_map`, dan `output_map` dalam pipa.

1. Jalankan `_simulate` API pada dokumen sampel untuk mengonfirmasi bahwa bidang keluaran memiliki nilai yang Anda harapkan.

**catatan**  
API prediksi membutuhkan `aoss:ExecuteMLResource` izin pada sumber daya model. Untuk informasi selengkapnya, lihat [Konfigurasikan Machine Learning di Amazon Tanpa OpenSearch Server](serverless-configure-machine-learning.md).

## Menggunakan ml\_inference dalam pipeline ingest
<a name="serverless-ml-inference-ingest"></a>

Dalam pipa menelan, `ml_inference` prosesor menjalankan inferensi model selama pengindeksan. Penggunaan umum adalah untuk menghasilkan penyematan vektor dari bidang teks sehingga Anda dapat menjalankan pencarian semantik di atas data Anda. `input_map` memetakan bidang dokumen ke input model, dan `output_map` menulis output model ke bidang baru.

Contoh berikut membuat pipeline yang mengirimkan `text` bidang ke model dan menulis embedding yang dikembalikan ke `embedding` bidang. Ganti {{my-pipeline}} dengan nama pipa Anda dan {{my-model-id}} dengan ID model yang Anda gunakan.

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

Permintaan mengembalikan respons berikut:

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

 `output_map` jalan berakar pada `inference_results` karena `full_response_path` diatur ke `true`. Pengaturan ini mengevaluasi jalur keluaran terhadap respons model lengkap. Untuk informasi lebih lanjut, lihat [Prosesor inferensi ML](https://docs.opensearch.org/latest/ingest-pipelines/processors/ml-inference/) pada *OpenSearch Dokumentasi* situs web.

Sebelum Anda menerapkan pipeline ke lalu lintas langsung, Anda dapat mensimulasikannya terhadap dokumen sampel dengan `_simulate` titik akhir. Untuk menjalankan inferensi model secara otomatis pada setiap dokumen yang diindeks ke dalam indeks, atur `index.default_pipeline` pengaturan saat Anda membuat indeks. Atau, tentukan pipeline pada permintaan pengindeksan individu dengan `pipeline` parameter kueri. Untuk informasi selengkapnya tentang membuat, mensimulasikan, dan menerapkan saluran cerna, lihat [Menelan saluran pipa di Amazon OpenSearch Tanpa server](serverless-ingest-pipelines.md).

Contoh berikut mengindeks dokumen dan menjalankan pipeline. Ganti {{my-index}} dengan nama indeks Anda dan {{my-pipeline}} dengan nama pipa Anda.

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

Tanggapan menegaskan bahwa dokumen tersebut diindeks:

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

**catatan**  
Indeks target harus dikonfigurasi untuk pencarian vektor. Aktifkan `index.knn` dan memetakan bidang output (misalnya, `embedding`) sebagai `knn_vector` bidang dengan dimensi yang sesuai dengan model Anda.

## Menggunakan ml\_inference dalam pipeline pencarian
<a name="serverless-ml-inference-search"></a>

Dalam sebuah pipeline pencarian, `ml_inference` prosesor menjalankan inferensi model sebagai bagian dari query. Prosesor permintaan pencarian mengubah atau menulis ulang kueri sebelum dijalankan. Prosesor respons pencarian memperkaya hasil sebelum Anda menerimanya. Untuk menjalankan pipeline pencarian, kirim permintaan dengan `search_pipeline` parameter kueri. Ganti {{my-index}} dengan nama indeks Anda dan {{my-pipeline}} dengan nama pipa Anda.

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

Untuk membuat atau memperbarui pipeline pencarian, kirim badan pipa ke `_search/pipeline` titik akhir, seperti yang ditunjukkan oleh contoh di bagian berikut.

**catatan**  
Pipeline pencarian yang baru dibuat dapat memakan waktu beberapa menit untuk berlaku, bahkan setelah permintaan pembuatan kembali `"acknowledged": true`. Sampai saat itu, permintaan pencarian yang mereferensikan pipeline gagal dengan `Pipeline {{my-pipeline}} is not defined` kesalahan. Coba kembali permintaan setelah menunggu sebentar.

### Prosesor permintaan pencarian
<a name="serverless-ml-inference-search-request"></a>

Anda menggunakan prosesor permintaan pencarian untuk menulis ulang kueri yang masuk sebelumnya OpenSearch Serverless menjalankannya. Contoh berikut mengambil teks dari a `match` query, menghasilkan vektor darinya dengan model yang dikonfigurasi, dan menulis ulang permintaan menjadi kueri k-NN dengan `query_template` parameter. OpenSearch Tanpa server menggantikan `${query_vec}` placeholder dalam template dengan output model yang `output_map` menangkap. Ganti {{my-model-id}} dengan ID model yang Anda gunakan.

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

Mengatur `full_response_path` kepada `true` sehingga `output_map` Jalur JSON diselesaikan terhadap respons model lengkap. Ini memungkinkan Anda menggunakan jalur keluaran yang sama yang Anda baca dari respons API prediksi.

Mengatur `ignore_missing` kepada `true` ketika bidang sumber mungkin hilang. Kueri yang tidak berisi bidang yang dipetakan, seperti `match_all` query, kemudian melewati tidak berubah alih-alih gagal. Prosesor masih menulis ulang kueri yang berisi bidang.

### Prosesor respons pencarian
<a name="serverless-ml-inference-search-response"></a>

Prosesor respons pencarian berjalan setelah kueri kembali, sehingga Anda dapat memperkaya atau meringkas setiap hit. Contoh berikut mengirimkan `text` bidang setiap hit ke model yang dikonfigurasi dan menulis output model ke a `text_vec` bidang. Mengatur `one_to_one` kepada `true` sehingga prosesor menjalankan model sekali untuk setiap hit pencarian. Defaultnya adalah `false`, yang mengirimkan semua hit ke model dalam satu permintaan, dan model yang mengharapkan nilai input tunggal menolak permintaan itu. Ganti {{my-model-id}} dengan ID model yang Anda gunakan.

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

Untuk meringkas hasil dengan model bahasa besar, tambahkan `model_config` objek yang berisi prompt model, dan set `one_to_one` kepada `true` sehingga prosesor merangkum setiap hit pencarian secara terpisah. Prompt dapat mereferensikan input yang dipetakan melalui parameter template seperti `${parameters.context}`. `output_map` path dalam contoh ini cocok dengan model yang mengembalikan respons mentahnya. Untuk informasi selengkapnya, lihat [Cocokkan prosesor dengan model Anda](#serverless-ml-inference-match-model). Ganti {{my-model-id}} dengan ID model yang Anda gunakan.

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

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

 `ml_inference` prosesor berjalan pada komputasi yang memproses permintaan koleksi Anda. Dalam pipeline ingest, prosesnya diperhitungkan dalam pengindeksan OpenSearch Compute Units (OCus) untuk koleksi Anda. Dalam pipeline pencarian, prosesnya diperhitungkan terhadap OCUS pencarian, dengan cara yang sama seperti pengindeksan dan aktivitas pencarian lainnya. Pipa dengan lebih banyak prosesor, atau dengan prosesor komputasi intensif, mengkonsumsi lebih banyak kapasitas daripada saluran pipa sederhana. Untuk informasi selengkapnya tentang cara kapasitas dinaikkan dan ditagih, lihat [Mengelola batas kapasitas untuk Amazon OpenSearch Tanpa server](serverless-scaling.md) dan [Amazon OpenSearch Harga layanan](https://aws.amazon.com/opensearch-service/pricing/).

Prosesor juga memanggil model jarak jauh yang Anda konfigurasikan, dan penyedia model menagih inferensi model secara terpisah.

## Izin yang diperlukan
<a name="serverless-ml-inference-permissions"></a>

Mengelola saluran pencarian dan konsumsi yang berisi `ml_inference` prosesor memetakan ke yang berikut OpenSearch Izin kebijakan akses data tanpa server. Izin berlaku untuk `collection` jenis sumber daya.
+ `aoss:CreateCollectionItems` — Buat atau perbarui pipeline.
+ `aoss:DescribeCollectionItems` — Dapatkan, daftar, dan simulasikan saluran pipa.
+ `aoss:DeleteCollectionItems` — Hapus pipa.

Prosesor juga memanggil model yang Anda konfigurasikan. Untuk izin kebijakan akses data yang dibutuhkan kepala sekolah untuk membuat dan menjalankan model, lihat [Konfigurasikan Machine Learning di Amazon Tanpa OpenSearch Server](serverless-configure-machine-learning.md).

**penting**  
Kepala sekolah yang mengirimkan permintaan melalui pipa membutuhkan `aoss:ExecuteMLResource` izin pada model. Ini berlaku untuk mengindeks dokumen, berjalan `_simulate`, dan mencari. Tanpa izin ini, permintaan ini gagal dengan `Forbidden` kesalahan yang tidak menyebutkan nama izin yang hilang.

Contoh kebijakan akses data berikut memberikan izin utama untuk mengelola pipeline dalam koleksi dan menjalankan model dalam koleksi tersebut. Ganti {{collection-name}} dengan nama koleksi Anda, {{account-id}} dengan milikmu AWS ID akun, dan {{role-name}} dengan nama peran IAM yang mengelola dan menggunakan 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}}"
        ]
    }
]
```

Untuk pemetaan lengkap OpenSearch Operasi API untuk OpenSearch Izin tanpa server, lihat [Operasi dan plugin yang didukung di Amazon Tanpa Server OpenSearch](serverless-genref.md).

## Pemecahan Masalah
<a name="serverless-ml-inference-troubleshooting"></a>

Jika permintaan yang menggunakan `ml_inference` pipa gagal dengan a `Forbidden` kesalahan, periksa penyebab umum berikut:
+ Kepala sekolah yang menelepon tidak memiliki `aoss:ExecuteMLResource` pada model. Tambahkan a `model` aturan untuk kebijakan akses data, seperti yang ditunjukkan pada [Izin yang diperlukan](#serverless-ml-inference-permissions).
+ Kebijakan akses data tidak memberi prinsipal izin indeks atau pengumpulan untuk operasi, seperti menulis dokumen, mencari, atau membuat pipeline.
+ Permintaan ditandatangani dengan nama layanan `es` alih-alih `aoss`.
+ Kebijakan jaringan untuk koleksi tidak mengizinkan akses dari sumber permintaan.

Jika permintaan pencarian gagal dengan `Pipeline {{my-pipeline}} is not defined` kesalahan tepat setelah Anda membuat pipeline, tunggu beberapa menit dan coba lagi. Untuk informasi selengkapnya, lihat [Menggunakan ml\_inference dalam pipeline pencarian](#serverless-ml-inference-search).

## Untuk informasi selengkapnya
<a name="serverless-ml-inference-more-info"></a>

Untuk informasi lebih lanjut tentang `ml_inference` prosesor, lihat yang berikut ini:
+ Untuk referensi prosesor saluran masuk, lihat [Prosesor inferensi ML](https://docs.opensearch.org/latest/ingest-pipelines/processors/ml-inference/) pada *OpenSearch Dokumentasi* situs web.
+ Untuk referensi prosesor permintaan pencarian, lihat [Prosesor permintaan pencarian inferensi ML](https://docs.opensearch.org/latest/search-plugins/search-pipelines/ml-inference-search-request/) pada *OpenSearch Dokumentasi* situs web.
+ Untuk referensi prosesor respons pencarian, lihat [Prosesor respons pencarian inferensi ML](https://docs.opensearch.org/latest/search-plugins/search-pipelines/ml-inference-search-response/) pada *OpenSearch Dokumentasi* situs web.
+ Untuk contoh ringkasan ulasan dan pencarian semantik yang berhasil, lihat [Pengantar prosesor inferensi ML di OpenSearch: ringkasan ulasan dan pencarian semantik](https://opensearch.org/blog/introduction-to-ml-inference-processors-in-opensearch-review-summarization-and-semantic-search/) pada *OpenSearch* blog.