Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
Cohere Embed v4
Cohere Embed v4ist ein multimodales Einbettungsmodell, das sowohl Text- als auch Bildeingaben unterstützt. Es kann verschachtelte Text- und Bildinhalte verarbeiten und eignet sich daher ideal für Anwendungen zum Verstehen von Dokumenten, zur visuellen Suche und zum multimodalen Abrufen. Das Modell unterstützt verschiedene Einbettungsarten, darunter Float-, Int8-, Uint8-, Binär- und Ubinärformate, mit konfigurierbaren Ausgabeabmessungen von 256 bis 1536.
Die Modell-ID für ist. Cohere Embed v4 cohere.embed-v4
Zusätzliche Nutzungshinweise
-
Kontextlänge: Bis zu ~128.000 Token werden unterstützt. Bei RAG verbessern kleinere Blöcke häufig den Abruf und die Kosten.
-
Bildgröße: Bilder > 2.458.624 Pixel werden auf diese Größe heruntergerechnet; Bilder mit < 3.136 Pixeln werden hochgerechnet.
-
Eingaben im Querformat: Bevorzugen Sie inputs.content [] für seitenähnlichen multimodalen Inhalt, sodass der Textkontext (z. B. Dateiname, Entitäten) zusammen mit dem Bild übertragen wird.
Anforderung und Antwort
- Request
-
Inhaltstyp: application/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 (erforderlich) — Fügt spezielle Token hinzu, um Anwendungsfälle zu unterscheiden. Erlaubt:search_document,,search_query,classification. clustering Für Suche/RAG betten Sie Ihren Korpus mit search_document und Abfragen mit ein. search_query
-
Texte (optional) — Array von Zeichenketten, die eingebettet werden sollen. Max. 96 pro Anruf. Wenn Sie es verwendentexts, senden Sie images nicht denselben Anruf ein.
-
images (optional) — Array von einzubettenden Base64-Bildern mit Daten-URI. Max. 96 pro Anruf. Sende texts sie nicht images zusammen. (Verwenden Sie inputs für verschachtelt.)
-
Eingaben (optional; mixed/fused Modalität) — Eine Liste, in der jedes Element eine Inhaltsliste mit Teilen enthält. Jeder Teil ist { "type": "text", "text": ... } oder{ "type": "image_url", "image_url": "data:<mime>;base64,..." }. Verschachtelte seitenähnliche Inhalte hier versenden (z. B. PDF-Seitenbild + Bildunterschrift/Metadaten). Maximal 96 Artikel.
-
embedding_types (optional) — Einer oder mehrere der:float,,,int8,uint8. binary ubinary Wenn nicht angegeben, werden Float-Einbettungen zurückgegeben.
-
output_dimension (optional) — Wählen Sie die Vektorlänge aus. Zulässig:256,512, 1536 (Standard1024, 1536 falls nicht angegeben).
-
max_tokens (optional) — Kürzungsbudget pro Eingabeobjekt. Das Modell unterstützt bis zu ~128.000 Token; je nach Bedarf kleinere Blöcke für RAG.
-
truncate (optional) — Wie man mit zu langen Eingaben umgeht: LEFT Löscht Tokens von Anfang an; entfernt sie am EndeRIGHT; NONE gibt einen Fehler zurück, wenn die Eingabe das Limit überschreitet.
Grenzwerte und Größenangaben
-
Artikel pro Anfrage: bis zu 96 Bilder. Der ursprüngliche Bilddateityp muss im PNG-, JPEG-, Webp- oder GIF-Format vorliegen und kann bis zu 5 MB groß sein.
-
Maximale Größe der Anfrage: ~20 MB Gesamtnutzlast.
-
Maximale Eingabe-Token: max. 128.000 Token. Bilddateien werden in Token umgewandelt, und die Gesamtzahl der Token sollte weniger als 128 KB betragen.
-
Bilder: Maximal 2.458.624 Pixel vor dem Downsampling; Bilder, die kleiner als 3.136 Pixel sind, werden hochgerechnet. Stellen Sie Bilder bereit als data:<mime>;base64,....
-
Token-Abrechnung (pro inputs Objekt): Tokens aus einer Bildeingabe ≈ (Bildpixel ÷784) x 4 Tokens aus einem verschachtelten Text und einer Bildeingabe = (Bildpixel ÷784) x 4 + (Text-Token)
Tipp: Konvertiere jede Seite in ein Bild und sende sie inputs zusammen mit Seitenmetadaten (z. B. Dateiname, Entitäten) in angrenzenden Textteilen. PDFs
- Response
-
Inhaltstyp: application/json
Wenn Sie einen einzigen Einbettungstyp angefordert haben (z. B. nurfloat):
{
"id": "string",
"embeddings": [[ /* length = output_dimension */ ]],
"response_type": "embeddings_floats",
"texts": ["..."], // present if text was provided
"inputs": [ { "content": [ ... ] } ] // present if 'inputs' was used
}
Wenn Sie mehrere Einbettungsarten angefordert haben (z. B.["float","int8"]):
{
"id": "string",
"embeddings": {
"float": [[ ... ]],
"int8": [[ ... ]]
},
"response_type": "embeddings_by_type",
"texts": ["..."], // when text used
"inputs": [ { "content": [ ... ] } ] // when 'inputs' used
}
Anfrage und Antwort für verschiedene input_types
A) Verschachtelte Seite (Bild + Bildunterschrift) mit kompakten int8-Vektoren
Anforderung
{
"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
}
Antwort (gekürzt)
{
"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) Korpusindizierung nur aus Text (Standard: float, 1536-dim)
Anforderung
{
"input_type": "search_document",
"texts": [
"RAG system design patterns for insurance claims",
"Actuarial loss triangles and reserving primer"
]
}
Antwort (Beispiel)
{
"response_type": "embeddings_floats",
"embeddings": [
[0.0135, -0.0272, ...], // length 1536
[0.0047, 0.0189, ...]
]
}
Codebeispiele
- 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()
