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 Cohere Command
Puede realizar solicitudes de inferencia a un modelo Cohere Command con [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) (transmisión). Necesitará el ID de modelo del modelo que desee utilizar. Para obtener el ID del modelo, consulte [Modelos fundacionales compatibles en Amazon Bedrock](models-supported.md).
**Topics**
+ [Solicitud y respuesta](#model-parameters-cohere-command-request-response)
+ [Ejemplo de código](#api-inference-examples-cohere-command)
## Solicitud y respuesta
------
#### [ Request ]
Los modelos Cohere Command tienen los siguientes parámetros de inferencia.
```
{
"prompt": string,
"temperature": float,
"p": float,
"k": float,
"max_tokens": int,
"stop_sequences": [string],
"return_likelihoods": "GENERATION|ALL|NONE",
"stream": boolean,
"num_generations": int,
"logit_bias": {token_id: bias},
"truncate": "NONE|START|END"
}
```
Los siguientes parámetros son obligatorios.
+ **prompt**: (obligatorio) texto de entrada que sirve como punto de partida para generar la respuesta.
Los siguientes son los límites de texto por llamada y de caracteres.
**Textos por llamada**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
**Caracteres**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
Los siguientes son parámetros opcionales.
+ **return\$1likelihoods**: especifica cómo y si se devuelven las probabilidades simbólicas con la respuesta. Puede especificar las opciones siguientes:
+ `GENERATION`: solo devuelve las probabilidades de los tokens generados.
+ `ALL`: devuelve las probabilidades de todos los tokens.
+ `NONE`: (predeterminado) no devuelvas ninguna probabilidad.
+ **stream**: (necesario para admitir la transmisión) especifique `true` para devolver la respuesta pieza por pieza en tiempo real y `false` para devolver la respuesta completa una vez finalizado el proceso.
+ **logit\$1bias**: evita que el modelo genere tokens no deseados o incentiva al modelo a incluir los tokens deseados. El formato es `{token_id: bias}` en el que el sesgo es un número flotante entre -10 y 10. Los tokens se pueden obtener a partir del texto mediante cualquier servicio de tokenización, como el punto de conexión Tokenize de Cohere. Para obtener más información, consulte [Documentación de Cohere](https://docs.cohere.com/docs).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **num\$1generations**: número máximo de generaciones que debe devolver el modelo.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **truncate**: especifica cómo gestiona la API las entradas que superen la longitud máxima del token. Utilice una de las siguientes:
+ `NONE`: devuelve un error cuando la entrada supera la longitud máxima del token de entrada.
+ `START`: descarta el inicio de la entrada.
+ `END`: (predeterminado) descarta el final de la entrada.
Si especifica `START` o`END`, el modelo descarta la entrada hasta que la entrada restante tenga exactamente la longitud máxima del token de entrada para el modelo.
+ **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-cohere-command.html)
+ **p**: P superior. Utilice un valor bajo para ignorar las opciones menos probables. Configúrelo en 0 o 1,0 para deshabilitarlo. Si ambos `p` y `k` están activados, `p` actúa después `k`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **k**: K superior. Especifique el número de opciones de token que el modelo utiliza para generar el siguiente token. Si ambos `p` y `k` están activados, `p` actúa después `k`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **max\$1tokens**: especifique la cantidad máxima de tokens para usar en la respuesta generada.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **stop\$1sequences**: configure hasta cuatro secuencias que reconozca el modelo. Tras una secuencia de detención, el modelo deja de generar más tokens. El texto devuelto no contiene la secuencia de detención.
------
#### [ Response ]
La respuesta tiene los siguientes campos posibles:
```
{
"generations": [
{
"finish_reason": "COMPLETE | MAX_TOKENS | ERROR | ERROR_TOXIC",
"id": string,
"text": string,
"likelihood" : float,
"token_likelihoods" : [{"token" : string, "likelihood": float}],
"is_finished" : true | false,
"index" : integer
}
],
"id": string,
"prompt": string
}
```
+ `generations`: una lista de los resultados generados junto con las probabilidades de que se soliciten los tokens. (Siempre se devuelve). Cada objeto de generación de la lista incluye los siguientes campos:
+ `id`: un identificador para la generación. (Siempre se devuelve).
+ `likelihood`: la probabilidad de la salida. El valor es el promedio de las probabilidades del token en `token_likelihoods`. Se devuelve si se especifica el parámetro de entrada `return_likelihoods`.
+ `token_likelihoods`: un conjunto de probabilidades por token. Se devuelve si se especifica el parámetro de entrada `return_likelihoods`.
+ `finish_reason`: indica la razón por la que el modelo ha terminado de generar tokens. `COMPLETE`: el modelo ha enviado una respuesta finalizada. `MAX_TOKENS`: la respuesta se ha interrumpido porque el modelo ha alcanzado el número máximo de tokens para su longitud de contexto. `ERROR `: algo ha salido mal al generar la respuesta. `ERROR_TOXIC`: el modelo ha generado una respuesta considerada tóxica. `finish_reason`: se devuelve solo cuando `is_finished`=`true`. (No siempre se devuelve).
+ `is_finished`: un campo booleano que se usa solo cuando `stream` es `true`, lo que indica si hay o no tokens adicionales que se generarán como parte de la respuesta de la transmisión. (No siempre se devuelve).
+ `text`: el texto generado.
+ `index`: en una respuesta de transmisión, se usa para determinar a qué generación pertenece un token determinado. Cuando solo se transmite una respuesta, todos los tokens pertenecen a la misma generación y no se devuelve el índice. Por lo tanto, `index` solo se devuelve en una solicitud de transmisión con un valor para `num_generations` superior a uno.
+ `prompt`: petición de la solicitud de entrada (se devuelve siempre).
+ `id`: un identificador de la solicitud (siempre devuelto).
Para obtener más información, consulte [Generate](https://docs.cohere.com/reference/generate-1) en la documentación de Cohere.
------
## Ejemplo de código
En este ejemplo se muestra cómo llamar al modelo *Cohere Command*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate text using a Cohere model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text(model_id, body):
"""
Generate text using a Cohere model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
Returns:
dict: The response from the model.
"""
logger.info("Generating text with Cohere model %s", model_id)
accept = 'application/json'
content_type = 'application/json'
bedrock = boto3.client(service_name='bedrock-runtime')
response = bedrock.invoke_model(
body=body,
modelId=model_id,
accept=accept,
contentType=content_type
)
logger.info("Successfully generated text with Cohere model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'cohere.command-text-v14'
prompt = """Summarize this dialogue:
"Customer: Please connect me with a support agent.
AI: Hi there, how can I assist you today?
Customer: I forgot my password and lost access to the email affiliated to my account. Can you please help me?
AI: Yes of course. First I'll need to confirm your identity and then I can connect you with one of our support agents.
"""
try:
body = json.dumps({
"prompt": prompt,
"max_tokens": 200,
"temperature": 0.6,
"p": 1,
"k": 0,
"num_generations": 2,
"return_likelihoods": "GENERATION"
})
response = generate_text(model_id=model_id,
body=body)
response_body = json.loads(response.get('body').read())
generations = response_body.get('generations')
for index, generation in enumerate(generations):
print(f"Generation {index + 1}\n------------")
print(f"Text:\n {generation['text']}\n")
if 'likelihood' in generation:
print(f"Likelihood:\n {generation['likelihood']}\n")
print(f"Reason: {generation['finish_reason']}\n\n")
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 with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```