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

# Cohere Sematkan v4
<a name="model-parameters-embed-v4"></a>

Cohere Embed v4adalah model penyematan multimodal yang mendukung input teks dan gambar. Ini dapat memproses teks dan konten gambar yang disisipkan, membuatnya ideal untuk pemahaman dokumen, pencarian visual, dan aplikasi pengambilan multimodal. Model ini mendukung berbagai jenis embedding termasuk format float, int8, uint8, biner, dan ubinary, dengan dimensi output yang dapat dikonfigurasi dari 256 hingga 1536.

ID model untuk Cohere Embed v4 adalah`cohere.embed-v4`.

**Catatan penggunaan tambahan**  

+ **Panjang konteks:** Hingga \~ 128k token per dokumen; untuk RAG, potongan yang lebih kecil sering meningkatkan pengambilan dan biaya.
+ **Ukuran gambar:** Gambar > 2.458.624 piksel diturunkan sampelnya ke ukuran itu; gambar <3.136 piksel di-upsample.
+ **Input interleaved:** Lebih suka inputs.content [] untuk konten multimodal seperti halaman sehingga konteks teks (misalnya, nama file, entitas) berjalan dengan gambar.

**Topics**
+ [Permintaan dan Tanggapan](#model-parameters-embed-v4-request-response)
+ [Permintaan dan tanggapan untuk input\_types yang berbeda](#api-inference-examples-cohere-embed-v4)
+ [Contoh Kode](#code-examples-cohere-embed-v4)

## Permintaan dan Tanggapan
<a name="model-parameters-embed-v4-request-response"></a>

------
#### [ Request ]

Jenis konten: aplikasi/json

```
{
  "input_type": "search_document | search_query | classification | clustering",
  "texts": ["..."],                      // optional; text-only
  "images": ["data:<mime>;base64,..."],  // optional; image-only
  "inputs": [
    { "content": [
        { "type": "text",      "text": "..." },
        { "type": "image_url", "image_url": {"url": "data:<mime>;base64,..."} }
      ]
    }
  ],                                     // optional; mixed (interleaved) text+image
  "embedding_types": ["float" | "int8" | "uint8" | "binary" | "ubinary"],
  "output_dimension": 256 | 512 | 1024 | 1536,
  "max_tokens": 128000,
  "truncate": "NONE | LEFT | RIGHT"
}
```

**Parameter**  

+ **input\_type** (wajib) - Menambahkan token khusus untuk membedakan kasus penggunaan. Diizinkan:`search_document`,`search_query`,`classification`,`clustering`. Untuk pencarian/RAG, sematkan korpus Anda dengan dan kueri dengan. `search_document` `search_query`
+ **teks** (opsional) - Array string untuk disematkan. Maks 96 per panggilan. Jika Anda menggunakan`texts`, jangan kirim `images` panggilan yang sama.
+ **gambar** (opsional) - Array dari data-uri gambar base64 untuk menanamkan. Maks 96 per panggilan. Jangan mengirim `texts` dan `images` bersama-sama. (Gunakan `inputs` untuk disisipkan.)
+ **input** (opsional; mixed/fused modalitas) - Daftar di mana setiap item memiliki daftar konten bagian. Setiap bagian adalah `{ "type": "text", "text": ... }` atau`{ "type": "image_url", "image_url": {"url": "data:<mime>;base64,..."} }`. Kirim konten seperti halaman yang disisipkan di sini (misalnya, gambar halaman PDF\+teks/metadata). Maks 96 item.
+ **embedding\_types** (opsional) - Satu atau lebih dari:`float`,,,,. `int8` `uint8` `binary` `ubinary` Jika dihilangkan, kembalikan penyematan float.
+ **output\_dimension** (opsional) - Pilih panjang vektor. Diizinkan:`256`,`512`,`1024`, `1536` (default `1536` jika tidak ditentukan).
+ **max\_tokens** (opsional) - Anggaran pemotongan per dokumen masukan. Model ini mendukung hingga \~ 128.000 token per dokumen; potongan lebih kecil untuk RAG yang sesuai.
+ **memotong** (opsional) — Cara menangani input yang terlalu panjang: `LEFT` menjatuhkan token dari awal; `RIGHT` turun dari akhir; `NONE` mengembalikan kesalahan jika input melebihi batas.

**Batas & ukuran**  

+ Item per permintaan: hingga 96 gambar. Jenis file gambar asli harus dalam format png, jpeg, webp, atau gif dan dapat berukuran hingga 5 MB.
+ Tutup ukuran permintaan: \~ 20 MB total muatan.
+ Token masukan maksimum: 128k token maks. File gambar dikonversi menjadi token, dan total token harus kurang dari 128k.
+ Gambar: maks 2.458.624 piksel sebelum downsampling; gambar yang lebih kecil dari 3.136 piksel di-upsample. Berikan gambar sebagai `data:<mime>;base64,....`
+ Penghitungan token (per `inputs` item): Token dari input gambar ≈ (piksel gambar ÷ 784) x 4 Token dari teks yang disisipkan dan input gambar = (piksel gambar ÷ 784) x 4 \+ (token teks)

**Tip:** Untuk PDFs, ubah setiap halaman menjadi gambar dan kirim melalui `inputs` bersama dengan metadata halaman (misalnya, file\_name, entitas) di bagian teks yang berdekatan.

------
#### [ Response ]

Jenis konten: aplikasi/json

Jika Anda meminta satu jenis penyematan (misalnya, hanya`float`):

```
{
"id": "string",
"embeddings": [[ /* length = output_dimension */ ]],
"response_type": "embeddings_floats",
"texts": ["..."], // present if text was provided
"inputs": [ { "content": [ ... ] } ] // present if 'inputs' was used
}
```

Jika Anda meminta beberapa jenis penyematan (mis.,`["float","int8"]`):

```
{
  "id": "string",
  "embeddings": {
    "float": [[ ... ]],
    "int8":  [[ ... ]]
  },
  "response_type": "embeddings_by_type",
  "texts": ["..."],     // when text used
  "inputs": [ { "content": [ ... ] } ] // when 'inputs' used
}
```
+ Jumlah vektor yang dikembalikan cocok dengan panjang `texts` array Anda atau jumlah `inputs` item.
+ Panjang setiap vektor sama `output_dimension` (default`1536`).

------

## Permintaan dan tanggapan untuk input\_types yang berbeda
<a name="api-inference-examples-cohere-embed-v4"></a>

**A) Halaman yang disisipkan (gambar\+keterangan) dengan vektor int8 kompak**

**Permintaan**  


```
{
  "input_type": "search_document",
  "inputs": [
    {
      "content": [
        { "type": "text", "text": "Quarterly ARR growth chart; outlier in Q3." },
        { "type": "image_url", "image_url": {"url": "data:image/png;base64,{{BASE64_PAGE_IMG}}"} }
      ]
    }
  ],
  "embedding_types": ["int8"],
  "output_dimension": 512,
  "truncate": "RIGHT",
  "max_tokens": 128000
}
```

**Respon (terpotong)**  


```
{
  "id": "836a33cc-61ec-4e65-afaf-c4628171a315",
  "embeddings": { "int8": [[ 7, -3, ... ]] },
  "response_type": "embeddings_by_type",
  "inputs": [
    { "content": [
      { "type": "text", "text": "Quarterly ARR growth chart; outlier in Q3." },
      { "type": "image_url", "image_url": {"url": "data:image/png;base64,{{...}}"} }
    ] }
  ]
}
```

**B) Pengindeksan korpus hanya teks (float default, 1536-redup)**

**Permintaan**  


```
{
  "input_type": "search_document",
  "texts": [
    "RAG system design patterns for insurance claims",
    "Actuarial loss triangles and reserving primer"
  ]
}
```

**Respon (sampel)**  


```
{
  "response_type": "embeddings_floats",
  "embeddings": [
    [0.0135, -0.0272, ...],   // length 1536
    [0.0047,  0.0189, ...]
  ]
}
```

## Contoh Kode
<a name="code-examples-cohere-embed-v4"></a>

------
#### [ Text input ]

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate embeddings using the Cohere Embed v4 model.
"""
import json
import logging
import boto3


from botocore.exceptions import ClientError

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


def generate_text_embeddings(model_id, body, region_name):
    """
    Generate text embedding by using the Cohere Embed model.
    Args:
        model_id (str): The model ID to use.
        body (str) : The reqest body to use.
        region_name (str): The AWS region to invoke the model on
    Returns:
        dict: The response from the model.
    """

    logger.info("Generating text embeddings with the Cohere Embed model %s", model_id)

    accept = '*/*'
    content_type = 'application/json'

    bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)

    response = bedrock.invoke_model(
        body=body,
        modelId=model_id,
        accept=accept,
        contentType=content_type
    )

    logger.info("Successfully generated embeddings with Cohere model %s", model_id)

    return response


def main():
    """
    Entrypoint for Cohere Embed example.
    """

    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
    
    region_name = 'us-east-1'

    model_id = 'cohere.embed-v4:0'
    text1 = "hello world"
    text2 = "this is a test"
    input_type = "search_document"
    embedding_types = ["float"]

    try:
        body = json.dumps({
            "texts": [
                text1,
                text2],
            "input_type": input_type,
            "embedding_types": embedding_types
        })
        
        response = generate_text_embeddings(model_id=model_id, body=body, region_name=region_name)

        response_body = json.loads(response.get('body').read())

        print(f"ID: {response_body.get('id')}")
        print(f"Response type: {response_body.get('response_type')}")

        print("Embeddings")
        embeddings = response_body.get('embeddings')
        for i, embedding_type in enumerate(embeddings):
            print(f"\t{embedding_type} Embeddings:")
            print(f"\t{embeddings[embedding_type]}")

        print("Texts")
        for i, text in enumerate(response_body.get('texts')):
            print(f"\tText {i}: {text}")

    except ClientError as err:
        message = err.response["Error"]["Message"]
        logger.error("A client error occurred: %s", message)
        print("A client error occured: " +
              format(message))
    else:
        print(
            f"Finished generating text embeddings with Cohere model {model_id}.")


if __name__ == "__main__":
    main()
```

------
#### [ Mixed modalities ]

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate image embeddings using the Cohere Embed v4 model.
"""
import json
import logging
import boto3
import base64


from botocore.exceptions import ClientError

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

def get_base64_image_uri(image_file_path: str, image_mime_type: str):
    with open(image_file_path, "rb") as image_file:
        image_bytes = image_file.read()
        base64_image = base64.b64encode(image_bytes).decode("utf-8")
    return f"data:{image_mime_type};base64,{base64_image}"


def generate_embeddings(model_id, body, region_name):
    """
    Generate image embedding by using the Cohere Embed model.
    Args:
        model_id (str): The model ID to use.
        body (str) : The reqest body to use.
        region_name (str): The AWS region to invoke the model on
    Returns:
        dict: The response from the model.
    """

    logger.info("Generating image embeddings with the Cohere Embed model %s", model_id)

    accept = '*/*'
    content_type = 'application/json'

    bedrock = boto3.client(service_name='bedrock-runtime', region_name=region_name)

    response = bedrock.invoke_model(
        body=body,
        modelId=model_id,
        accept=accept,
        contentType=content_type
    )

    logger.info("Successfully generated embeddings with Cohere model %s", model_id)

    return response


def main():
    """
    Entrypoint for Cohere Embed example.
    """

    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
    
    region_name = 'us-east-1'

    image_file_path = "image.jpg"
    image_mime_type = "image/jpg"
    text = "hello world"

    model_id = 'cohere.embed-v4:0'
    input_type = "search_document"
    image_base64_uri = get_base64_image_uri(image_file_path, image_mime_type)
    embedding_types = ["int8","float"]

    try:
        body = json.dumps({
            "inputs": [
                {
                  "content": [
                    { "type": "text", "text": text },
                    { "type": "image_url", "image_url": {"url": "data:image/png;base64,{{image_base64_uri}}"} }
                  ]
                }
              ],
            "input_type": input_type,
            "embedding_types": embedding_types
        })
        
        response = generate_embeddings(model_id=model_id, body=body, region_name=region_name)

        response_body = json.loads(response.get('body').read())

        print(f"ID: {response_body.get('id')}")
        print(f"Response type: {response_body.get('response_type')}")

        print("Embeddings")
        embeddings = response_body.get('embeddings')
        for i, embedding_type in enumerate(embeddings):
            print(f"\t{embedding_type} Embeddings:")
            print(f"\t{embeddings[embedding_type]}")

        print("inputs")
        for i, input in enumerate(response_body.get('inputs')):
            print(f"\tinput {i}: {input}")

    except ClientError as err:
        message = err.response["Error"]["Message"]
        logger.error("A client error occurred: %s", message)
        print("A client error occured: " +
              format(message))
    else:
        print(
            f"Finished generating embeddings with Cohere model {model_id}.")


if __name__ == "__main__":
    main()
```

------