Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo di Embedding Nova
Amazon Nova Multimodal Embeddings è un modello di incorporamento state-of-the-art multimodale per RAG agentici e applicazioni di ricerca semantica. È il primo modello di embedding unificato che supporta testo, documenti, immagini, video e audio attraverso un unico modello, per consentire il recupero intermodale con la massima precisione. Embedding multimodali Nova mappa ciascuno di questi tipi di contenuto in uno spazio semantico unificato che consente agli sviluppatori di condurre operazioni vettoriali unimodali, intermodali e multimodali.
L’API Embedding Nova può essere usata in una varietà di applicazioni, come:
+ Recupero e raccomandazione di contenuti semantici: genera embedding per i tuoi contenuti, quindi usali per trovare articoli simili o fornire consigli personalizzati ai tuoi utenti.
+ Ricerca multimodale: combina gli embedding di diversi tipi di contenuto per abilitare potenti funzionalità di ricerca intermodale.
+ RAG: genera embedding da contenuti multimodali, come documenti con testo e immagini interleaved, per potenziare il flusso di lavoro di recupero per le applicazioni GenAI.
# Caratteristiche chiave
+ Supporto per testo, immagini, immagini di documenti, video e audio in uno spazio semantico unificato. La lunghezza massima del contesto è di 8.000 token o 30 secondi di video e 30 secondi di audio.
+ Sincrono e asincrono: l'API supporta sia l'uso sincrono che asincrono. APIs
+ Segmentazione di file di grandi dimensioni: l’API asincrona semplifica la gestione di input di grandi dimensioni fornendo una segmentazione integrata nell’API per testi lunghi, video e audio, controllata da parametri definiti dall’utente. Il modello genererà un singolo embedding per ogni segmento.
+ Video con audio: elaborazione simultanea di video e audio. L’API consente di specificare se si desidera un singolo embedding che rappresenti entrambe le modalità o due embedding separati che rappresentino rispettivamente il flusso video e audio.
+ Scopo dell’embedding: Embedding multimodali Nova consente di ottimizzare gli embedding in base all’applicazione downstream prevista. I casi d’uso supportati comprendono il recupero (RAG/Ricerca), la classificazione e il clustering. I valori specifici dipendono dall’applicazione (vedi le procedure consigliate).
+ Dimensioni: 4 dimensioni per bilanciare la precisione di embedding e il costo di archiviazione dei vettori: 3072; 1024; 384; 256.
+ Metodi di input: puoi passare il contenuto da incorporare specificando un URI S3 o in linea come codifica base64.
# Come funziona Embedding multimodali Nova
+ Quando un contenuto viene passato attraverso gli embedding Nova, il modello converte quel contenuto in un formato numerico universale, denominato vettore. Un vettore è un insieme di valori numerici arbitrari che possono quindi essere usati per varie funzionalità di ricerca. Ai contenuti simili viene assegnato un vettore più ravvicinato rispetto ai contenuti meno simili. Ad esempio, a un contenuto che potrebbe essere descritto come “felice” viene assegnato un vettore più vicino a un vettore come “gioioso” invece che a uno come “tristezza”.
## Prerequisiti
Per usare Embedding multimodali occorre quanto segue:
+ Python installato
+ La AWS CLI installata
+ La AWS CLI configurata con le credenziali di accesso per il tuo account AWS
+ Il modello Nova Multimodal Embeddings abilitato sul tuo account AWS
Con questi elementi abilitati, puoi eseguire richieste di embedding asincrone o sincrone.
## Generare embedding in modo sincrono
Per elementi di contenuto più piccoli, puoi utilizzare l'API Bedrock Runtime. InvokeModel Questa è una buona opzione per generare rapidamente incorporamenti per testo, immagini o file brevi audio/video .
Il seguente esempio genera un embedding sincrono per il testo “Hello World\$1”
```
import json
import boto3
# Create the Bedrock Runtime client.
bedrock_runtime = boto3.client(
service_name="bedrock-runtime",
region_name="us-east-1",
)
# Define the request body.
request_body = {
"taskType": "SINGLE_EMBEDDING",
"singleEmbeddingParams": {
"embeddingPurpose": "GENERIC_INDEX",
"embeddingDimension": 3072,
"text": {"truncationMode": "END", "value": "Hello, World!"},
},
}
try:
# Invoke the Nova Embeddings model.
response = bedrock_runtime.invoke_model(
body=json.dumps(request_body, indent=2),
modelId="amazon.nova-2-multimodal-embeddings-v1:0",
accept="application/json",
contentType="application/json",
)
except Exception as e:
# Add your own exception handling here.
print(e)
# Print the request ID.
print("Request ID:", response.get("ResponseMetadata").get("RequestId"))
# Print the response body.
response_body = json.loads(response.get("body").read())
print(json.dumps(response_body, indent=2))
```
L'output apparirà come segue:
```
Request ID: fde55db5-c129-423b-c62d-7a8b36cf2859
{
"embeddings": [
{
"embeddingType": "TEXT",
"embedding": [
0.031115104,
0.032478657,
0.10006265,
...
]
}
]
}
```
## Generare embedding in modo asincrono
Per file di contenuto di dimensioni maggiori, è possibile utilizzare la StartAsyncInvoke funzione Bedrock Runtime per generare gli incorporamenti in modo asincrono. Ciò consente di inviare un processo e recuperare i risultati in un secondo momento, senza bloccare l’esecuzione dell’applicazione. I risultati vengono salvati in Amazon S3.
Il seguente esempio avvia un processo di generazione di embedding asincrono per un file video:
```
import boto3
# Create the Bedrock Runtime client.
bedrock_runtime = boto3.client(
service_name="bedrock-runtime",
region_name="us-east-1",
)
model_input = {
"taskType": "SEGMENTED_EMBEDDING",
"segmentedEmbeddingParams": {
"embeddingPurpose": "GENERIC_INDEX",
"embeddingDimension": 3072,
"video": {
"format": "mp4",
"embeddingMode": "AUDIO_VIDEO_COMBINED",
"source": {
"s3Location": {"uri": "s3://amzn-s3-demo-bucket/path/to/video.mp4"}
},
"segmentationConfig": {
"durationSeconds": 15 # Segment into 15 second chunks
},
},
},
}
try:
# Invoke the Nova Embeddings model.
response = bedrock_runtime.start_async_invoke(
modelId="amazon.nova-2-multimodal-embeddings-v1:0",
modelInput=model_input,
outputDataConfig={
"s3OutputDataConfig": {
"s3Uri": "s3://amzn-s3-demo-bucket"
}
},
)
except Exception as e:
# Add your own exception handling here.
print(e)
# Print the request ID.
print("Request ID:", response.get("ResponseMetadata").get("RequestId"))
# Print the invocation ARN.
print("Invocation ARN:", response.get("invocationArn"))
```
L'output apparirà come segue:
```
Request ID: 07681e80-5ce0-4723-cf52-68bf699cd23e
Invocation ARN: arn:aws:bedrock:us-east-1:111122223333:async-invoke/g7ur3b32a10n
```
Dopo aver avviato il processo asincrono, utilizzate InvocationARN per verificare lo stato del lavoro con la funzione. GetAsyncInvoke Per visualizzare le chiamate asincrone recenti e il relativo stato, utilizzate la funzione. ListAsyncInvokes
Quando la generazione degli embedding asincroni è completa, gli artefatti vengono scritti nel bucket S3 specificato come destinazione dell’output. I file avranno la struttura seguente:
```
amzn-s3-demo-bucket/
job-id/
segmented-embedding-result.json
embedding-audio.jsonl
embedding-image.json
embedding-text.jsonl
embedding-video.jsonl
manifest.json
```
# Schema completo delle richieste e delle risposte degli embedding
## Schema sincrono completo
```
{
"schemaVersion": "nova-multimodal-embed-v1",
"taskType": "SINGLE_EMBEDDING",
"singleEmbeddingParams": {
"embeddingPurpose": "GENERIC_INDEX" | "GENERIC_RETRIEVAL" | "TEXT_RETRIEVAL" | "IMAGE_RETRIEVAL" | "VIDEO_RETRIEVAL" | "DOCUMENT_RETRIEVAL" | "AUDIO_RETRIEVAL" | "CLASSIFICATION" | "CLUSTERING",
"embeddingDimension": 256 | 384 | 1024 | 3072,
"text": {
"truncationMode": "START" | "END" | "NONE",
"value": string,
"source": SourceObject,
},
"image": {
"detailLevel": "STANDARD_IMAGE" | "DOCUMENT_IMAGE",
"format": "png" | "jpeg" | "gif" | "webp",
"source": SourceObject
},
"audio": {
"format": "mp3" | "wav" | "ogg",
"source": SourceObject
},
"video": {
"format": "mp4" | "mov" | "mkv" | "webm" | "flv" | "mpeg" | "mpg" | "wmv" | "3gp",
"source": SourceObject,
"embeddingMode": "AUDIO_VIDEO_COMBINED" | "AUDIO_VIDEO_SEPARATE"
}
}
}
```
Il seguente elenco include tutti i parametri della richiesta:
+ `schemaVersion` (Facoltativo): la versione dello schema per la richiesta del modello di embedding multimodale
+ Tipo: stringa
+ Valori consentiti: "nova-multimodal-embed-v1"
+ Predefinito: "1" nova-multimodal-embed-v
+ `taskType` (Obbligatorio): specifica il tipo di operazione di embedding da eseguire sul contenuto di input. `single_embedding` si riferisce alla generazione di un embedding per input del modello. `segmented_embedding` si riferisce alla prima segmentazione dell’input del modello in base alle specifiche dell’utente e quindi alla generazione di un singolo embedding per segmento.
+ Tipo: stringa
+ Valori consentiti: deve essere “SINGLE\$1EMBEDDING” per le chiamate sincrone.
+ `singleEmbeddingParams` (Obbligatorio)
+ `embeddingPurpose` (Obbligatorio): Embedding multimodali Nova permette di ottimizzare gli embedding in base all’applicazione prevista. Gli esempi includono MM-RAG, Digital Asset Management per la ricerca di immagini e video, il confronto delle somiglianze per contenuti multimodali o la classificazione dei documenti per l’elaborazione intelligente dei documenti. `embeddingPurpose` consente di specificare il caso d’uso dell’embedding. Seleziona il valore corretto sulla base del caso d’uso riportato di seguito.
+ **Ricerca e recupero:** l’embedding di casi d’uso come RAG e ricerca prevede due passaggi principali: in primo luogo, la creazione di un indice generando embedding per il contenuto e, in secondo luogo, il recupero dei contenuti più pertinenti dall’indice durante la ricerca. Usa i seguenti valori quando lavori con casi d’uso di ricerca e recupero:
+ Indicizzazione:
+ “GENERIC\$1INDEX”: crea embedding ottimizzati per l’uso come indici in un archivio di dati vettoriali. Questo valore deve essere usato indipendentemente dalla modalità di indicizzazione.
+ Ricerca/recupero: ottimizza gli embedding in base al tipo di contenuto che stai recuperando:
+ “TEXT\$1RETRIEVAL”: crea embedding ottimizzati per la ricerca in un repository contenente solo embedding di testo.
+ “IMAGE\$1RETRIEVAL”: crea embedding ottimizzati per la ricerca in un repository contenente solo embedding di immagini creati con “STANDARD\$1IMAGE” DetailLevel.
+ “VIDEO\$1RETRIEVAL”: crea embedding ottimizzati per la ricerca in un archivio contenente solo embedding video o embedding creati con la modalità di embedding “AUDIO\$1VIDEO\$1COMBINED”.
+ “DOCUMENT\$1RETRIEVAL”: crea embedding ottimizzati per la ricerca in un repository contenente solo embedding di immagini di documenti creati con “DOCUMENT\$1IMAGE” DetailLevel.
+ “AUDIO\$1RETRIEVAL”: crea embedding ottimizzati per la ricerca in un repository contenente solo embedding audio.
+ “GENERIC\$1RETRIEVAL”: crea embedding ottimizzati per la ricerca in un repository contenente embedding in modalità mista.
+ Esempio: in un’app di ricerca immagini in cui gli utenti recuperano immagini utilizzando query di testo, usa `embeddingPurpose = generic_index` quando crei un indice di embedding basato sulle immagini e usa `embeddingPurpose = image_retrieval` quando crei un embedding della query utilizzata per recuperare le immagini.
+ “CLASSIFICAZIONE”: crea embedding ottimizzati per eseguire la classificazione.
+ “CLUSTERING”: crea embedding ottimizzati per il clustering.
+ `embeddingDimension` (Facoltativo): la dimensione del vettore da generare.
+ Type: int
+ Valori consentiti: 256 \$1 384 \$1 1024 \$1 3072
+ Predefinito: 3072
+ `text` (Facoltativo): rappresenta il contenuto del testo. Deve essere presente esattamente uno di testo, immagini, video e audio.
+ `truncationMode` (Obbligatorio): specifica quale parte del testo verrà troncata nei casi in cui la versione tokenizzata del testo supera il massimo supportato dal modello.
+ Tipo: stringa
+ Valori consentiti:
+ “INIZIO”: ometti i caratteri dall’inizio del testo quando necessario.
+ “FINE”: ometti i caratteri dalla fine del testo quando necessario.
+ “NESSUNO”: fallisce se la lunghezza del testo supera il limite massimo di token del modello.
+ `value` (Facoltativo; è necessario fornire il valore o l’origine): il valore di testo per il quale creare l’embedding.
+ Tipo: stringa
+ Lunghezza massima: 8192 caratteri.
+ `source` (Facoltativo; è necessario fornire il valore o la fonte): riferimento a un file di testo archiviato in S3. Si noti che l'opzione bytes di non SourceObject è applicabile agli input di testo. Per passare il testo in linea come parte della richiesta, usa invece il parametro value.
+ Tipo: SourceObject (vedi la sezione «Oggetti comuni»)
+ `image` (Facoltativo): rappresenta il contenuto dell’immagine. Deve essere presente esattamente uno di testo, immagini, video e audio.
+ `detailLevel` (Facoltativo): determina la risoluzione con cui l’immagine verrà elaborata con “STANDARD\$1IMAGE” usando una risoluzione dell’immagine inferiore e “DOCUMENT\$1IMAGE” usando un’immagine a risoluzione più elevata per interpretare meglio il testo.
+ Tipo: stringa
+ Valori consentiti: “STANDARD\$1IMAGE” \$1 “DOCUMENT\$1IMAGE”
+ Predefinito: “STANDARD\$1IMAGE”
+ `format` (Obbligatorio)
+ Tipo: stringa
+ Valori consentiti: “png” \$1 “jpeg” \$1 “gif” \$1 “webp”
+ `source` (Obbligatorio): una fonte di contenuti per le immagini.
+ Tipo: SourceObject (vedi la sezione «Oggetti comuni»)
+ `audio` (Facoltativo): rappresenta il contenuto dell’audio. Deve essere presente esattamente uno di testo, immagini, video e audio.
+ `format` (Obbligatorio)
+ Tipo: stringa
+ Valori consentiti: “mp3” \$1 “wav” \$1 “ogg”
+ `source` (Obbligatorio): una fonte di contenuti audio.
+ Tipo: SourceObject (vedi la sezione «Oggetti comuni»)
+ Durata massima audio: 30 secondi
+ `video` (Facoltativo): rappresenta il contenuto del video. Deve essere presente esattamente uno di testo, immagini, video e audio.
+ `format` (Obbligatorio)
+ Tipo: stringa
+ Valori consentiti: “mp4” \$1 “mov” \$1 “mkv” \$1 “webm” \$1 “flv” \$1 “mpeg” \$1 “mpg” \$1 “wmv” \$1 “3gp”
+ `source` (Obbligatorio): una fonte di contenuti video.
+ Tipo: SourceObject (vedi la sezione «Oggetti comuni»)
+ Durata massima video: 30 secondi
+ `embeddingMode` (Obbligatorio)
+ Tipo: stringa
+ Valori: “AUDIO\$1VIDEO\$1COMBINED” \$1 “AUDIO\$1VIDEO\$1SEPARATE”
+ “AUDIO\$1VIDEO\$1COMBINED”: produrrà un singolo embedding che combina contenuti audio e visivi.
+ “AUDIO\$1VIDEO\$1SEPARATE”: produrrà due embedding, uno per il contenuto audio e uno per il contenuto visivo.
**InvokeModel Corpo di risposta**
Quando [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_InvokeModel.html)restituisce un risultato positivo, il corpo della risposta avrà la seguente struttura:
```
{
"embeddings": [
{
"embeddingType": "TEXT" | "IMAGE" | "VIDEO" | "AUDIO" | "AUDIO_VIDEO_COMBINED",
"embedding": number[],
"truncatedCharLength": int // Only included if text input was truncated
}
]
}
```
Il seguente elenco include tutti i parametri della risposta:
+ `embeddings` (Obbligatorio): per la maggior parte delle richieste, questo array conterrà un singolo embedding. Per le richieste video in cui è stata selezionata la modalità EmbeddingMode “AUDIO\$1VIDEO\$1SEPARATE”, questo array conterrà due embedding: uno per il contenuto video e uno per il contenuto audio.
+ Tipo: array di embedding con le seguenti proprietà
+ `embeddingType` (Obbligatorio): riporta il tipo di embedding creato.
+ Tipo: stringa
+ Valori consentiti: “TEXT” \$1 “IMAGE” \$1 “VIDEO” \$1 “AUDIO” \$1 “AUDIO\$1VIDEO\$1COMBINED”
+ `embedding` (Obbligatorio): il vettore di embedding.
+ Tipo: numero[]
+ `truncatedCharLength` (Facoltativo): si applica solo alle richieste di embedding del testo. Restituito se la versione tokenizzata del testo di input ha superato i limiti del modello. Il valore indica il carattere dopo il quale il testo è stato troncato prima di generare l’embedding.
+ Type: int
## Schema asincrono completo
Puoi generare incorporamenti in modo asincrono utilizzando le funzioni dell'API Amazon Bedrock Runtime e. [StartAsyncInvoke[GetAsyncInvoke[ListAsyncInvokes](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_ListAsyncInvokes.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetAsyncInvoke.html)](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_StartAsyncInvoke.html) Devi usare l’API asincrona se vuoi utilizzare gli embedding Nova per segmentare contenuti lunghi come passaggi di testo o video e audio di durata superiore a 30 secondi.
Quando chiami [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_StartAsyncInvoke.html), devi fornire `modelId` e parametri. `outputDataConfig` `modelInput`
```
response = bedrock_runtime.start_async_invoke(
modelId="amazon.nova-2-multimodal-embeddings-v1:0",
outputDataConfig=Data Config,
modelInput=Model Input
)
```
`outputDataConfig` specifica il bucket S3 in cui vuoi salvare l’output generato. Ha la struttura seguente:
```
{
"s3OutputDataConfig": {
"s3Uri": "s3://your-s3-bucket"
}
}
```
`s3Uri` è l’URI S3 del bucket di destinazione. Per ulteriori parametri opzionali, consultate la StartAsyncInvoke documentazione.
Per il parametro `modelInput` viene usata la seguente struttura.
```
{
"schemaVersion": "nova-multimodal-embed-v1",
"taskType": "SEGMENTED_EMBEDDING",
"segmentedEmbeddingParams": {
"embeddingPurpose": "GENERIC_INDEX" | "GENERIC_RETRIEVAL" | "TEXT_RETRIEVAL" | "IMAGE_RETRIEVAL" | "VIDEO_RETRIEVAL" | "DOCUMENT_RETRIEVAL" | "AUDIO_RETRIEVAL" | "CLASSIFICATION" | "CLUSTERING",
"embeddingDimension": 256 | 384 | 1024 | 3072,
"text": {
"truncationMode": "START" | "END" | "NONE",
"value": string,
"source": {
"s3Location": {
"uri": "s3://Your S3 Object"
}
},
"segmentationConfig": {
"maxLengthChars": int
}
},
"image": {
"format": "png" | "jpeg" | "gif" | "webp",
"source": SourceObject,
"detailLevel": "STANDARD_IMAGE" | "DOCUMENT_IMAGE"
},
"audio": {
"format": "mp3" | "wav" | "ogg",
"source": SourceObject,
"segmentationConfig": {
"durationSeconds": int
}
},
"video": {
"format": "mp4" | "mov" | "mkv" | "webm" | "flv" | "mpeg" | "mpg" | "wmv" | "3gp",
"source": SourceObject,
"embeddingMode": "AUDIO_VIDEO_COMBINED" | "AUDIO_VIDEO_SEPARATE",
"segmentationConfig": {
"durationSeconds": int
}
}
}
}
```
Il seguente elenco include tutti i parametri della richiesta:
+ `schemaVersion` (Facoltativo): la versione dello schema per la richiesta del modello di embedding multimodale
+ Tipo: stringa
+ Valori consentiti: "nova-multimodal-embed-v1"
+ Predefinito: "1" nova-multimodal-embed-v
+ `taskType` (Obbligatorio): specifica il tipo di operazione di embedding da eseguire sul contenuto di input. `single_embedding` si riferisce alla generazione di un embedding per input del modello. `segmented_embedding` si riferisce alla prima segmentazione dell’input del modello in base alle specifiche dell’utente e quindi alla generazione di un singolo embedding per segmento.
+ Tipo: stringa
+ Valori consentiti: deve essere “SEGMENTED\$1EMBEDDING” per le chiamate asincrone.
+ `segmentedEmbeddingParams` (Obbligatorio)
+ `embeddingPurpose` (Obbligatorio): Embedding multimodali Nova permette di ottimizzare gli embedding in base all’applicazione prevista. Gli esempi includono MM-RAG, Digital Asset Management per la ricerca di immagini e video, il confronto delle somiglianze per contenuti multimodali o la classificazione dei documenti per l’elaborazione intelligente dei documenti. `embeddingPurpose` consente di specificare il caso d’uso dell’embedding. Seleziona il valore corretto sulla base del caso d’uso riportato di seguito.
+ **Ricerca e recupero:** l’embedding di casi d’uso come RAG e ricerca prevede due passaggi principali: in primo luogo, la creazione di un indice generando embedding per il contenuto e, in secondo luogo, il recupero dei contenuti più pertinenti dall’indice durante la ricerca. Usa i seguenti valori quando lavori con casi d’uso di ricerca e recupero:
+ Indicizzazione:
+ “GENERIC\$1INDEX”: crea embedding ottimizzati per l’uso come indici in un archivio di dati vettoriali. Questo valore deve essere usato indipendentemente dalla modalità di indicizzazione.
+ Ricerca/recupero: ottimizza gli embedding in base al tipo di contenuto che stai recuperando:
+ “TEXT\$1RETRIEVAL”: crea embedding ottimizzati per la ricerca in un repository contenente solo embedding di testo.
+ “IMAGE\$1RETRIEVAL”: crea embedding ottimizzati per la ricerca in un repository contenente solo embedding di immagini creati con “STANDARD\$1IMAGE” DetailLevel.
+ “VIDEO\$1RETRIEVAL”: crea embedding ottimizzati per la ricerca in un archivio contenente solo embedding video o embedding creati con la modalità di embedding “AUDIO\$1VIDEO\$1COMBINED”.
+ “DOCUMENT\$1RETRIEVAL”: crea embedding ottimizzati per la ricerca in un repository contenente solo embedding di immagini di documenti creati con “DOCUMENT\$1IMAGE” DetailLevel.
+ “AUDIO\$1RETRIEVAL”: crea embedding ottimizzati per la ricerca in un repository contenente solo embedding audio.
+ “GENERIC\$1RETRIEVAL”: crea embedding ottimizzati per la ricerca in un repository contenente embedding in modalità mista.
+ Esempio: in un’app di ricerca immagini in cui gli utenti recuperano immagini utilizzando query di testo, usa `embeddingPurpose = generic_index` quando crei un indice di embedding basato sulle immagini e usa `embeddingPurpose = image_retrieval` quando crei un embedding della query utilizzata per recuperare le immagini.
+ “CLASSIFICAZIONE”: crea embedding ottimizzati per eseguire la classificazione.
+ “CLUSTERING”: crea embedding ottimizzati per il clustering.
+ `embeddingDimension` (Facoltativo): la dimensione del vettore da generare.
+ Type: int
+ Valori consentiti: 256 \$1 384 \$1 1024 \$1 3072
+ Predefinito: 3072
+ `text` (Facoltativo): rappresenta il contenuto del testo. Deve essere presente esattamente uno di testo, immagini, video e audio.
+ `truncationMode` (Obbligatorio): specifica quale parte del testo verrà troncata nei casi in cui la versione tokenizzata del testo supera il massimo supportato dal modello.
+ Tipo: stringa
+ Valori consentiti:
+ “INIZIO”: ometti i caratteri dall’inizio del testo quando necessario.
+ “FINE”: ometti i caratteri dalla fine del testo quando necessario.
+ “NESSUNO”: fallisce se la lunghezza del testo supera il limite massimo di token del modello.
+ `value` (Facoltativo; è necessario fornire il valore o l’origine): il valore di testo per il quale creare l’embedding.
+ Tipo: stringa
+ Lunghezza massima: 8192 caratteri.
+ `source` (Facoltativo; è necessario fornire il valore o la fonte): riferimento a un file di testo archiviato in S3. Si noti che l'opzione bytes di non SourceObject è applicabile agli input di testo. Per passare il testo in linea come parte della richiesta, usa invece il parametro value.
+ `segmentationConfig` (Obbligatorio): controlla come il contenuto del testo deve essere segmentato in più embedding.
+ `maxLengthChars` (Facoltativo): la lunghezza massima consentita per ciascun segmento. Il modello tenterà di segmentare solo ai confini delle parole.
+ Type: int
+ Intervallo valido: 800-50.000
+ Predefinito: 32.000
+ `image` (Facoltativo): rappresenta il contenuto dell’immagine. Deve essere presente esattamente uno di testo, immagini, video e audio.
+ `format` (Obbligatorio)
+ Tipo: stringa
+ Valori consentiti: “png” \$1 “jpeg” \$1 “gif” \$1 “webp”
+ `source` (Obbligatorio): una fonte di contenuti per le immagini.
+ Tipo: SourceObject (vedi la sezione «Oggetti comuni»)
+ `detailLevel` (Facoltativo): determina la risoluzione con cui l’immagine verrà elaborata con “STANDARD\$1IMAGE” usando una risoluzione dell’immagine inferiore e “DOCUMENT\$1IMAGE” usando un’immagine a risoluzione più elevata per interpretare meglio il testo.
+ Tipo: stringa
+ Valori consentiti: “STANDARD\$1IMAGE” \$1 “DOCUMENT\$1IMAGE”
+ Predefinito: “STANDARD\$1IMAGE”
+ `audio` (Facoltativo): rappresenta il contenuto dell’audio. Deve essere presente esattamente uno di testo, immagini, video e audio.
+ `format` (Obbligatorio)
+ Tipo: stringa
+ Valori consentiti: “mp3” \$1 “wav” \$1 “ogg”
+ `source` (Obbligatorio): una fonte di contenuti audio.
+ Tipo: SourceObject (vedi la sezione «Oggetti comuni»)
+ `segmentationConfig` (Obbligatorio): controlla come il contenuto dell’audio deve essere segmentato in più embedding.
+ `durationSeconds` (Facoltativo): la durata massima dell’audio (in secondi) da usare per ogni segmento.
+ Type: int
+ Intervallo valido: 1-30
+ Impostazione predefinita: 5
+ `video` (Facoltativo): rappresenta il contenuto del video. Deve essere presente esattamente uno di testo, immagini, video e audio.
+ `format` (Obbligatorio)
+ Tipo: stringa
+ Valori consentiti: “mp4” \$1 “mov” \$1 “mkv” \$1 “webm” \$1 “flv” \$1 “mpeg” \$1 “mpg” \$1 “wmv” \$1 “3gp”
+ `source` (Obbligatorio): una fonte di contenuti video.
+ Tipo: SourceObject (vedi la sezione «Oggetti comuni»)
+ `embeddingMode` (Obbligatorio)
+ Tipo: stringa
+ Valori: “AUDIO\$1VIDEO\$1COMBINED” \$1 “AUDIO\$1VIDEO\$1SEPARATE”
+ “AUDIO\$1VIDEO\$1COMBINED”: produrrà un singolo embedding per ogni segmento combinando contenuti audio e visivi.
+ “AUDIO\$1VIDEO\$1SEPARATE”: produrrà due embedding per ogni segmento, uno per il contenuto audio e uno per il contenuto video.
+ `segmentationConfig` (Obbligatorio): controlla come i contenuti video devono essere segmentati in più embedding.
+ `durationSeconds` (Facoltativo): la durata massima del video (in secondi) da usare per ogni segmento.
+ Type: int
+ Intervallo valido: 1-30
+ Impostazione predefinita: 5
**StartAsyncInvoke Risposta**
La risposta a una chiamata a [StartAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_StartAsyncInvoke.html)avrà la struttura seguente. `invocationArn`Può essere utilizzato per interrogare lo stato del lavoro asincrono utilizzando la funzione. [GetAsyncInvoke](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetAsyncInvoke.html)
```
{
"invocationArn": "arn:aws:bedrock:us-east-1:xxxxxxxxxxxx:async-invoke/lvmxrnjf5mo3",
}
```
### Output asincrono
Quando la generazione degli embedding asincroni è completa, gli artefatti di output vengono scritti nel bucket S3 specificato come destinazione dell’output. I file avranno la struttura seguente:
```
amzn-s3-demo-bucket/
job-id/
segmented-embedding-result.json
embedding-audio.jsonl
embedding-image.json
embedding-text.jsonl
embedding-video.jsonl
manifest.json
```
`segmented-embedding-result.json` conterrà il risultato complessivo del processo e il riferimento ai file jsonl corrispondenti che contengono gli embedding effettivi per modalità. Di seguito è riportato un esempio troncato di un file:
```
{
"sourceFileUri": string,
"embeddingDimension": 256 | 384 | 1024 | 3072,
"embeddingResults": [
{
"embeddingType": "TEXT" | "IMAGE" | "VIDEO" | "AUDIO" | "AUDIO_VIDEO_COMBINED",
"status": "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS",
"failureReason": string, // Granular error codes
"message": string, // Human-readbale failure message
"outputFileUri": string // S3 URI to a "embedding-modality.jsonl" file
}
...
]
}
```
I file `embedding-modality.json` saranno file jsonl che contengono l’output di embedding per ciascuna modalità. Ogni riga del file jsonl rispetterà il seguente schema:
```
{
"embedding": number[], // The generated embedding vector
"segmentMetadata": {
"segmentIndex": number,
"segmentStartCharPosition": number, // Included for text only
"segmentEndCharPosition": number, // Included for text only
"truncatedCharLength": number, // Included only when text gets truncated
"segmentStartSeconds": number, // Included for audio/video only
"segmentEndSeconds": number // Included for audio/video only
},
"status": "SUCCESS" | "FAILURE",
"failureReason": string, // Granular error codes
"message": string // Human-readable failure message
}
```
Il seguente elenco include tutti i parametri della risposta. Per i caratteri o le ore di testo, audio/video tutte le ore di inizio e fine sono a base zero. Inoltre, tutte le posizioni finali del testo o i valori audio/video temporali sono inclusi.
+ `embedding` (Obbligatorio): il vettore di embedding.
+ Tipo: numero
+ `segmentMetadata`: i metadati per il segmento.
+ `segmentIndex`: l’indice del segmento all’interno dell’array fornito nella richiesta.
+ `segmentStartCharPosition`: solo per testo. La posizione iniziale (inclusiva) del carattere del contenuto incorporato all’interno del segmento.
+ `segmentEndCharPosition`: solo per testo. La posizione finale (esclusiva) del carattere del contenuto incorporato all’interno del segmento.
+ `truncatedCharLength` (Facoltativo): restituito se la versione tokenizzata del testo di input supera i limiti del modello. Il valore indica il carattere dopo il quale il testo è stato troncato prima di generare l’embedding.
+ Tipo: Integer
+ `segmentStartSeconds`— audio/video Solo per. La posizione temporale iniziale del contenuto incorporato all’interno del segmento.
+ `segmentEndSeconds`— audio/video Solo per. La posizione temporale finale del contenuto incorporato all’interno del segmento.
+ `status`: lo stato del segmento.
+ `failureReason`: le ragioni dettagliate del fallimento del segmento.
+ `RAI_VIOLATION_INPUT_TEXT_DEFLECTION`: il testo inserito viola la policy RAI.
+ `RAI_VIOLATION_INPUT_IMAGE_DEFLECTION`: l’immagine inserita viola la policy RAI.
+ `INVALID_CONTENT`: input non valido.
+ `RATE_LIMIT_EXCEEDED`: la richiesta di embedding è limitata a causa della mancata disponibilità del servizio.
+ `INTERNAL_SERVER_EXCEPTION`: qualcosa non ha funzionato.
+ `message`: messaggio di errore correlato.
## Limitazioni dei file per Embedding Nova
Le operazioni sincrone possono accettare sia gli input S3 che i blocchi in linea. Le operazioni asincrone possono accettare solo gli input S3.
Quando si generano embedding in modo asincrono, bisogna assicurarsi che il file sia separato in un numero appropriato di segmenti. Per gli embedding di testo non è possibile avere più di 1900 segmenti. Per gli embedding audio e video non è possibile avere più di 1434 segmenti.
**Limiti delle dimensioni dell’input sincrono**
| Tipo di file | Limiti di dimensione |
| --- | --- |
| (In linea) Tutti i tipi di file | 25 MB |
| (S3) Testo | 1 MB; 50.000 caratteri |
| (S3) Immagine | 50 MB |
| (S3) Video | 30 secondi; 100 MB |
| (S3) Audio | 30 secondi; 100 MB |
**Nota**
La restrizione di 25 MB per i file in linea si applica **dopo** l’embedding di Base64. Questo causa un aumento delle dimensioni del file di circa il 33%
**Limiti delle dimensioni dell’input asincrono**
| Tipo di file | Limiti di dimensione |
| --- | --- |
| (S3) Testo | 634 MB |
| (S3) Immagine | 50 MB |
| (S3) Video | 2 GB; 2 ore |
| (S3) Audio | 1 GB; 2 ore |
**Tipi di file di input**
| Modalità | Tipi di file |
| --- | --- |
| Formati di immagine | PNG, JPEG, WEBP, GIF |
| Formati audio | MP3, WAV, OGG |
| Formati video | MP4, MOV, MKV, WEBM, FLV, MPEG, MPG, WMV, 3GP |