Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Modelos Amazon Titan Text
Los modelos Amazon Titan Text admiten los siguientes parámetros de inferencia.
Para obtener más información sobre las directrices de ingeniería de peticiones de Titan Text, consulte las [directrices de ingeniería de peticiones de Titan Text](https://d2eo22ngex1n9g.cloudfront.net/Documentation/User+Guides/Titan/Amazon+Titan+Text+Prompt+Engineering+Guidelines.pdf).
Para obtener más información sobre los modelos Titan, consulte [Información general de los modelos Amazon Titan](titan-models.md).
**Topics**
+ [Solicitud y respuesta](#model-parameters-titan-request-response)
+ [Ejemplos de código](#inference-titan-code)
## Solicitud y respuesta
El cuerpo de la solicitud se pasa en el campo `body` de una solicitud [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html).
------
#### [ Request ]
```
{
"inputText": string,
"textGenerationConfig": {
"temperature": float,
"topP": float,
"maxTokenCount": int,
"stopSequences": [string]
}
}
```
Se requieren los siguientes parámetros:
+ **inputText**: petición que se proporciona al modelo para que genere una respuesta. Para generar respuestas en un estilo conversacional, envíe la petición con el siguiente formato:
```
"inputText": "User: \nBot:"
```
Este formato indica al modelo que debe responder en una nueva línea después de que el usuario haya proporcionado una petición.
La `textGenerationConfig` es opcional. Puede utilizar los [parámetros de inferencia](inference-parameters.md) para configurarla:
+ **temperature**: utilice un valor bajo para reducir la asignación al azar de la respuesta.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-titan-text.html)
+ **topP**: utilice un valor bajo para ignorar las opciones menos probables y reducir la diversidad de respuestas.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-titan-text.html)
+ **maxTokenCount**: especifique la cantidad máxima de tokens a generar en la respuesta. Los límites máximos de tokens se aplican de forma estricta.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-titan-text.html)
+ **stopSequences**: especifique las secuencias de caracteres para indicar dónde debe detenerse el modelo.
------
#### [ InvokeModel Response ]
```
{
"inputTextTokenCount": int,
"results": [{
"tokenCount": int,
"outputText": "\n\n",
"completionReason": "string"
}]
}
```
El cuerpo de la respuesta contiene los siguientes campos:
+ **inputTextTokenCount**: número de tokens de la petición.
+ **results**: matriz de un elemento; un objeto que contiene los siguientes campos:
+ **tokenCount**: número de tokens de la respuesta.
+ **outputText**: texto de la respuesta.
+ **completionReason**: motivo por el que al final no se ha generado la respuesta. Es posible que se deba a los siguientes motivos:
+ FINISHED: la respuesta se ha generado por completo.
+ LENGTH: la respuesta se ha truncado debido a la longitud de la respuesta que ha establecido.
+ STOP\$1CRITERIA\$1MET: la respuesta se ha truncado porque se ha alcanzado el criterio de parada.
+ RAG\$1QUERY\$1WHEN\$1RAG\$1DISABLED: la característica está deshabilitada y no se puede completar la consulta.
+ CONTENT\$1FILTERED: el filtro de contenido aplicado ha filtrado o eliminado el contenido.
------
#### [ InvokeModelWithResponseStream Response ]
Cada fragmento de texto en el cuerpo del flujo de respuestas tiene el siguiente formato. Debe decodificar el campo `bytes` (consulte [Envíe un único mensaje con InvokeModel](inference-invoke.md) para ver un ejemplo).
```
{
"chunk": {
"bytes": b'{
"index": int,
"inputTextTokenCount": int,
"totalOutputTextTokenCount": int,
"outputText": "",
"completionReason": "string"
}'
}
}
```
+ **index**: índice del fragmento de la respuesta de la transmisión.
+ **inputTextTokenCount**: número de tokens de la petición.
+ **totalOutputTextTokenCount**: número de tokens de la respuesta.
+ **outputText**: texto de la respuesta.
+ **completionReason**: motivo por el que al final no se ha generado la respuesta. Es posible que se den las siguientes razones.
+ FINISHED: la respuesta se ha generado por completo.
+ LENGTH: la respuesta se ha truncado debido a la longitud de la respuesta que ha establecido.
+ STOP\$1CRITERIA\$1MET: la respuesta se ha truncado porque se ha alcanzado el criterio de parada.
+ RAG\$1QUERY\$1WHEN\$1RAG\$1DISABLED: la característica está deshabilitada y no se puede completar la consulta.
+ CONTENT\$1FILTERED: el filtro aplicado ha filtrado o eliminado el contenido.
------
## Ejemplos de código
El siguiente ejemplo muestra cómo ejecutar inferencias con el modelo Amazon Titan Text Premier con el SDK para Python.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to create a list of action items from a meeting transcript
with the Amazon Titan Text model (on demand).
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
class ImageError(Exception):
"Custom exception for errors returned by Amazon Titan Text models"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text(model_id, body):
"""
Generate text using Amazon Titan Text models on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
response (json): The response from the model.
"""
logger.info(
"Generating text with Amazon Titan 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())
finish_reason = response_body.get("error")
if finish_reason is not None:
raise ImageError(f"Text generation error. Error is {finish_reason}")
logger.info(
"Successfully generated text with Amazon Titan Text model %s", model_id)
return response_body
def main():
"""
Entrypoint for Amazon Titan Text model example.
"""
try:
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
# You can replace the model_id with any other Titan Text Models
# Titan Text Model family model_id is as mentioned below:
# amazon.titan-text-premier-v1:0, amazon.titan-text-express-v1, amazon.titan-text-lite-v1
model_id = 'amazon.titan-text-premier-v1:0'
prompt = """Meeting transcript: Miguel: Hi Brant, I want to discuss the workstream
for our new product launch Brant: Sure Miguel, is there anything in particular you want
to discuss? Miguel: Yes, I want to talk about how users enter into the product.
Brant: Ok, in that case let me add in Namita. Namita: Hey everyone
Brant: Hi Namita, Miguel wants to discuss how users enter into the product.
Miguel: its too complicated and we should remove friction.
for example, why do I need to fill out additional forms?
I also find it difficult to find where to access the product
when I first land on the landing page. Brant: I would also add that
I think there are too many steps. Namita: Ok, I can work on the
landing page to make the product more discoverable but brant
can you work on the additonal forms? Brant: Yes but I would need
to work with James from another team as he needs to unblock the sign up workflow.
Miguel can you document any other concerns so that I can discuss with James only once?
Miguel: Sure.
From the meeting transcript above, Create a list of action items for each person. """
body = json.dumps({
"inputText": prompt,
"textGenerationConfig": {
"maxTokenCount": 3072,
"stopSequences": [],
"temperature": 0.7,
"topP": 0.9
}
})
response_body = generate_text(model_id, body)
print(f"Input token count: {response_body['inputTextTokenCount']}")
for result in response_body['results']:
print(f"Token count: {result['tokenCount']}")
print(f"Output text: {result['outputText']}")
print(f"Completion reason: {result['completionReason']}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except ImageError as err:
logger.error(err.message)
print(err.message)
else:
print(
f"Finished generating text with the Amazon Titan Text Premier model {model_id}.")
if __name__ == "__main__":
main()
```
El siguiente ejemplo muestra cómo ejecutar inferencias con el modelo Amazon Titan Text G1 - Express con el SDK para Python.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to create a list of action items from a meeting transcript
with the Amazon &titan-text-express; model (on demand).
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
class ImageError(Exception):
"Custom exception for errors returned by Amazon &titan-text-express; model"
def __init__(self, message):
self.message = message
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text(model_id, body):
"""
Generate text using Amazon &titan-text-express; model on demand.
Args:
model_id (str): The model ID to use.
body (str) : The request body to use.
Returns:
response (json): The response from the model.
"""
logger.info(
"Generating text with Amazon &titan-text-express; 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())
finish_reason = response_body.get("error")
if finish_reason is not None:
raise ImageError(f"Text generation error. Error is {finish_reason}")
logger.info(
"Successfully generated text with Amazon &titan-text-express; model %s", model_id)
return response_body
def main():
"""
Entrypoint for Amazon &titan-text-express; example.
"""
try:
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'amazon.titan-text-express-v1'
prompt = """Meeting transcript: Miguel: Hi Brant, I want to discuss the workstream
for our new product launch Brant: Sure Miguel, is there anything in particular you want
to discuss? Miguel: Yes, I want to talk about how users enter into the product.
Brant: Ok, in that case let me add in Namita. Namita: Hey everyone
Brant: Hi Namita, Miguel wants to discuss how users enter into the product.
Miguel: its too complicated and we should remove friction.
for example, why do I need to fill out additional forms?
I also find it difficult to find where to access the product
when I first land on the landing page. Brant: I would also add that
I think there are too many steps. Namita: Ok, I can work on the
landing page to make the product more discoverable but brant
can you work on the additonal forms? Brant: Yes but I would need
to work with James from another team as he needs to unblock the sign up workflow.
Miguel can you document any other concerns so that I can discuss with James only once?
Miguel: Sure.
From the meeting transcript above, Create a list of action items for each person. """
body = json.dumps({
"inputText": prompt,
"textGenerationConfig": {
"maxTokenCount": 4096,
"stopSequences": [],
"temperature": 0,
"topP": 1
}
})
response_body = generate_text(model_id, body)
print(f"Input token count: {response_body['inputTextTokenCount']}")
for result in response_body['results']:
print(f"Token count: {result['tokenCount']}")
print(f"Output text: {result['outputText']}")
print(f"Completion reason: {result['completionReason']}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
except ImageError as err:
logger.error(err.message)
print(err.message)
else:
print(
f"Finished generating text with the Amazon &titan-text-express; model {model_id}.")
if __name__ == "__main__":
main()
```