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.
# Amazon Titan Embeddings G1 – Text
Titan Embeddings G1 - Text unterstützt keine Verwendung von Inferenzparametern. In den folgenden Abschnitten werden die Anforderungs- und Antwortformate detailliert beschrieben und ein Codebeispiel angegeben.
**Topics**
+ [Anforderung und Antwort](#model-parameters-titan-embed-text-request-response)
+ [Beispiel-Code](#api-inference-examples-titan-embed-text)
## Anforderung und Antwort
Der Anfragetext wird im `body` Feld einer [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)Anfrage übergeben.
------
#### [ V2 Request ]
Der inputText-Parameter ist erforderlich. Die Parameter „Normalize“ und „Dimensions“ sind optional.
+ inputText – Geben Sie Text ein, der in eine Einbettung umgewandelt werden soll.
+ normalize – (optional) Markierung, die angibt, ob die Ausgabeeinbettung normalisiert werden soll oder nicht. Standardwert ist „true“.
+ dimensions – (optional) Die Anzahl der Dimensionen, die die Ausgabeeinbettung haben sollte. Die folgenden Werte werden akzeptiert: 1024 (Standard), 512, 256.
+ embeddingTypes – (optional) akzeptiert eine Liste, die „float“, „binary“ oder beides enthält. Standardeinstellung: `float`.
```
{
"inputText": string,
"dimensions": int,
"normalize": boolean,
"embeddingTypes": list
}
```
------
#### [ V2 Response ]
Die -Felder werden im Folgenden beschrieben.
+ embedding – Ein Array, das den Einbettungsvektor der von Ihnen angegebenen Eingabe darstellt. Dies wird immer der Typ `float` sein.
+ Eingabe TextTokenCount — Die Anzahl der Token in der Eingabe.
+ Einbettungen ByType — Ein Wörterbuch oder eine Übersicht der Einbettungsliste. Hängt von der Eingabe ab und führt „float“, „binary“ oder beides auf.
+ Beispiel: `"embeddingsByType": {"binary": [int,..], "float": [float,...]}`
+ Dieses Feld wird immer angezeigt. Auch wenn Sie `embeddingTypes` in Ihrer Eingabe nicht angeben, wird dennoch „float“ angezeigt. Beispiel: `"embeddingsByType": {"float": [float,...]}`
```
{
"embedding": [float, float, ...],
"inputTextTokenCount": int,
"embeddingsByType": {"binary": [int,..], "float": [float,...]}
}
```
------
#### [ G1 Request ]
Das einzige verfügbare Feld ist `inputText`. Hier können Sie Text einfügen, der in eine Einbettung umgewandelt werden soll.
```
{
"inputText": string
}
```
------
#### [ G1 Response ]
Der `body` der Antwort enthält die folgenden Felder.
```
{
"embedding": [float, float, ...],
"inputTextTokenCount": int
}
```
Die -Felder werden im Folgenden beschrieben.
+ **embedding** – Ein Array, das den Einbettungsvektor der von Ihnen angegebenen Eingabe darstellt.
+ **Eingabe TextTokenCount** — Die Anzahl der Token in der Eingabe.
------
## Beispiel-Code
Die folgenden Beispiele zeigen, wie die Einbettungsmodelle von Amazon Titan aufgerufen werden, um eine Einbettung zu generieren. Wählen Sie die Registerkarte aus, die dem von Ihnen verwendeten Modell entspricht:
------
#### [ Amazon Titan Text Embeddings V2 ]
Bei der Verwendung von Titan Text Embeddings V2 ist das Feld `embedding` nicht in der Antwort enthalten, wenn `embeddingTypes` nur `binary` enthält.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an embedding with the Amazon Titan Text Embeddings V2 Model
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_embedding(model_id, body):
"""
Generate an embedding with the vector representation of a text input using Amazon Titan Text Embeddings G1 on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
response (JSON): The embedding created by the model and the number of input tokens.
"""
logger.info("Generating an embedding with Amazon Titan Text Embeddings V2 model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Amazon Titan Embeddings V2 - Text example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "amazon.titan-embed-text-v2:0"
input_text = "What are the different services that you offer?"
# Create request body.
body = json.dumps({
"inputText": input_text,
"embeddingTypes": ["binary"]
})
try:
response = generate_embedding(model_id, body)
print(f"Generated an embedding: {response['embeddingsByType']['binary']}") # returns binary embedding
print(f"Input text: {input_text}")
print(f"Input Token count: {response['inputTextTokenCount']}")
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 an embedding with Amazon Titan Text Embeddings V2 model {model_id}.")
if __name__ == "__main__":
main()
```
------
#### [ Amazon Titan Embeddings G1 – Text ]
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate an embedding with the Amazon Titan Embeddings G1 - Text model (on demand).
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_embedding(model_id, body):
"""
Generate an embedding with the vector representation of a text input using Amazon Titan Embeddings G1 - Text on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
response (JSON): The embedding created by the model and the number of input tokens.
"""
logger.info("Generating an embedding with Amazon Titan Embeddings G1 - Text model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
accept = "application/json"
content_type = "application/json"
response = bedrock.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=content_type
)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Amazon Titan Embeddings G1 - Text example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = "amazon.titan-embed-text-v1"
input_text = "What are the different services that you offer?"
# Create request body.
body = json.dumps({
"inputText": input_text,
})
try:
response = generate_embedding(model_id, body)
print(f"Generated an embedding: {response['embedding']}")
print(f"Input Token count: {response['inputTextTokenCount']}")
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 an embedding with Amazon Titan Embeddings G1 - Text model {model_id}.")
if __name__ == "__main__":
main()
```
------