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 v4 ist 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 Einbettungstypen, darunter Float-, Int8-, Uint8-, Binär- und Ubinärformate, mit konfigurierbaren Ausgabedimensionen von 256 bis 1 536.
Die Modell-ID für Cohere Embed v4 lautet cohere.embed-v4.
Zusätzliche Nutzungshinweise
-
Kontextlänge: Bis zu ~128 000 Token werden unterstützt. Bei RAG sind kleinere Blöcke häufig im Hinblick auf Abruf und Kosten vorteilhaft.
-
Bildgröße: bei Bildern > 2 458 624 Pixel erfolgt ein Downsampling; bei Bildern < 3 136 Pixel wird ein Upsampling vorgenommen.
-
Interleaving-Eingaben: Verwenden Sie am besten 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 Zulässig: search_document, search_query, classification, clustering. Für search/RAG betten Sie Ihren Korpus mit search_document und Abfragen mit search_query ein.
-
texts (optional) – Array von Zeichenfolgen, die eingebettet werden sollen. Max. 96 pro Aufruf. Wenn Sie texts verwenden, senden Sie images nicht im selben Aufruf.
-
images (optional) – Array von einzubettenden base64-Bildern mit Daten-URI. Max. 96 pro Aufruf. Senden Sie texts und images nicht zusammen. (Verwenden Sie inputs für verschachtelt.)
-
inputs (optional; gemischte/fusionierte 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,..." }. Senden Sie verschachtelte seitenähnliche Inhalte hier (z. B. PDF-Seitenbild + Bildunterschrift/Metadaten). Max. 96 Elemente.
-
embedding_types (optional) – Ein oder mehrere der folgenden Typen: float, int8, uint8, binary, ubinary. Wenn nichts angegeben wurde, werden Float-Einbettungen zurückgegeben.
-
output_dimension (optional) – Wählen Sie die Vektorlänge aus. Zulässig: 256, 512, 1024, 1536 (Standardwert 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) – So gehen Sie mit zu langen Eingaben um: LEFT löscht Token am Anfang; RIGHT entfernt sie am Ende; NONE gibt einen Fehler zurück, wenn die Eingabe das Limit überschreitet.
Grenzwerte und Größenangaben
-
Elemente pro Anforderung: bis zu 96 Bilder. Der ursprüngliche Bilddateityp muss im PNG-, JPEG-, WEBP- oder GIF-Format vorliegen und kann bis zu 5 MB umfassen sein.
-
Maximale Größe der Anforderung: ~20 MB Gesamtnutzdaten.
-
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; bei Bildern, die kleiner als 3 136 Pixel sind, erfolgt ein Upsampling. Stellen Sie Bilder als data:<mime>;base64,.... bereit.
-
Token-Abrechnung (pro inputs-Element): Token aus einer Bildeingabe ≈ (Bildpixel ÷ 784) x 4 Token aus einer verschachtelten Text- und Bildeingabe = (Bildpixel ÷ 784) x 4 + (Text-Token)
Tipp: Konvertieren Sie bei PDF-Dateien jede Seite in ein Bild und senden Sie sie mit inputs zusammen mit den Seitenmetadaten (z. B. Dateiname, Entitäten) in angrenzenden Textteilen.
- Response
-
Inhaltstyp: application/json
Wenn Sie einen einzigen Einbettungstyp angefordert haben (z. B. nur float):
{
"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 Einbettungstypen 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
}
Anforderung 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()
