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à.
# Modelli Cohere Command
Le richieste di inferenza a un modelli Cohere Command vengono effettuate 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) (streaming). È necessario l'ID modello per il modello che desideri utilizzare. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
**Topics**
+ [Richiesta e risposta](#model-parameters-cohere-command-request-response)
+ [esempio di codice](#api-inference-examples-cohere-command)
## Richiesta e risposta
------
#### [ Request ]
I modelli Cohere Command hanno i seguenti parametri di inferenza.
```
{
"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"
}
```
I seguenti sono parametri obbligatori.
+ **prompt** (obbligatorio): testo di input che funge da punto di partenza per la generazione della risposta.
Di seguito sono riportati i limiti di testo per chiamata e carattere.
**Testi per chiamata**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
**Caratteri**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
I seguenti sono parametri opzionali.
+ **return\$1likelihoods**: specifica come e se vengono restituite probabilità di token con la risposta. Puoi specificare le seguenti opzioni.
+ `GENERATION`: restituisce solo le verosimiglianze per i token generati.
+ `ALL`: restituisce le verosimiglianze per tutti i token.
+ `NONE`: (impostazione predefinita) non restituisce nessuna verosimiglianza.
+ **stream** (obbligatorio per supportare lo streaming): specifica `true` per restituire la risposta punto per punto in tempo reale e `false` per restituire la risposta completa al termine del processo.
+ **logit\$1bias**: impedisce al modello di generare token indesiderati o incentiva il modello a includere i token desiderati. Il formato è `{token_id: bias}`, dove bias è un numero a decimale mobile compreso tra -10 e 10. I token possono essere ottenuti dal testo utilizzando qualsiasi servizio di tokenizzazione, come l’endpoint Tokenize di Cohere. Per ulteriori informazioni, consulta la [documentazione di Cohere](https://docs.cohere.com/docs).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **num\$1generations**: numero massimo di generazioni che il modello deve restituire.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **truncate**: specifica in che modo l’API gestisce gli input maggiori della lunghezza massima del token. Utilizzare una delle seguenti operazioni:
+ `NONE`: restituisce un errore quando l'input supera la lunghezza massima del token di input.
+ `START`: elimina l'inizio dell'input.
+ `END`: (impostazione predefinita) elimina la fine dell'input.
Se specifichi `START` o`END`, il modello elimina l'input finché quello rimanente non raggiunge esattamente la lunghezza massima del token di input per il modello.
+ **temperature**: utilizza un valore più basso per ridurre la randomizzazione nella risposta.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **p**: Top P. Utilizza un valore più basso per ignorare le opzioni meno probabili. Imposta 0 o 1,0 per disabilitare questa funzionalità. Se `p` e `k` sono entrambi abilitati, `p` agisce dopo `k`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **k**: Top K. Specifica il numero di scelte di token utilizzate dal modello per generare il token successivo. Se `p` e `k` sono entrambi abilitati, `p` agisce dopo `k`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **max\$1tokens**: specifica il numero massimo di token da utilizzare nella risposta generata.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command.html)
+ **stop\$1sequences**: configura fino a quattro sequenze riconosciute dal modello. Dopo una sequenza di arresto, il modello smette di generare altri token. Il testo restituito non contiene la sequenza di arresto.
------
#### [ Response ]
La risposta ha i seguenti campi possibili:
```
{
"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`: un elenco dei risultati generati insieme alle verosimiglianze dei token richiesti. Viene restituito sempre. Ogni oggetto di generazione nell'elenco contiene i seguenti campi.
+ `id`: un identificatore per la generazione. Viene restituito sempre.
+ `likelihood`: la verosimiglianza dell'output. Il valore è la media delle verosimiglianze dei token in `token_likelihoods`. Restituito se specifichi il parametro di input `return_likelihoods`.
+ `token_likelihoods`: un array di verosimiglianze dei token. Restituito se specifichi il parametro di input `return_likelihoods`.
+ `finish_reason`: motivo per cui il modello ha smesso di generare token. `COMPLETE`: il modello ha restituito una risposta completa. `MAX_TOKENS`: la risposta è stata tagliata perché il modello ha raggiunto il numero massimo di token per la lunghezza del contesto. `ERROR `: si è verificato un errore durante la generazione della risposta. `ERROR_TOXIC`: il modello ha generato una risposta ritenuta tossica. `finish_reason` viene restituito solo quando `is_finished`=`true`. Non viene restituito sempre.
+ `is_finished`: un campo booleano usato solo quando `stream` è `true`, a indicare se esistono o meno altri token che verranno generati come parte della risposta in streaming. Non viene restituito sempre.
+ `text`: il testo generato.
+ `index`: da utilizzare in una risposta in streaming per stabilire a quale generazione appartiene un determinato token. Se viene trasmessa una sola risposta, tutti i token appartengono alla stessa generazione e l'indice non viene restituito. Di conseguenza, `index` viene restituito solo in una richiesta di streaming con un valore `num_generations` maggiore di uno.
+ `prompt`: prompt della richiesta di input (sempre restituito).
+ `id`: un identificatore per la richiesta. Viene restituito sempre.
Per ulteriori informazioni, consulta [Generate](https://docs.cohere.com/reference/generate-1) nella documentazione di Cohere.
------
## esempio di codice
Questo esempio mostra come chiamare il modello *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()
```