Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
Cohere Sematkan v4
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 adalahcohere.embed-v4.
Catatan penggunaan tambahan
-
Panjang konteks: Hingga ~ 128k token didukung; 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.
Permintaan dan Tanggapan
- 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": "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 menggunakantexts, jangan mengirim images panggilan yang sama.
-
gambar (opsional) - Array 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": "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 objek masukan. Model ini mendukung hingga ~ 128.000 token; 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 diubah 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, hanyafloat):
{
"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 (misalnya,["float","int8"]):
{
"id": "string",
"embeddings": {
"float": [[ ... ]],
"int8": [[ ... ]]
},
"response_type": "embeddings_by_type",
"texts": ["..."], // when text used
"inputs": [ { "content": [ ... ] } ] // when 'inputs' used
}
Permintaan dan tanggapan untuk input_types yang berbeda
A) Halaman interleaved (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": "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": "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
- 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": "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()
