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à.

# Amazon Titan Modelli di testo
<a name="model-parameters-titan-text"></a>

I modelli Amazon Titan Text supportano i seguenti parametri di inferenza.

Per ulteriori informazioni sulle linee guida di progettazione dei prompt di Titan Text, consulta [Linee guida alla progettazione dei prompt di Titan Text](https://d2eo22ngex1n9g.cloudfront.net/Documentation/User+Guides/Titan/Amazon+Titan+Text+Prompt+Engineering+Guidelines.pdf). 

Per ulteriori informazioni sui modelli Titan, vedi [Panoramica di Amazon Titan Modelli  ](titan-models.md).

**Topics**
+ [Richiesta e risposta](#model-parameters-titan-request-response)
+ [Esempi di codice](#inference-titan-code)

## Richiesta e risposta
<a name="model-parameters-titan-request-response"></a>

Il corpo della richiesta viene passato nel `body` campo di una [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)richiesta [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)or.

------
#### [ Request ]

```
{
    "inputText": string,
    "textGenerationConfig": {
        "temperature": float,  
        "topP": float,
        "maxTokenCount": int,
        "stopSequences": [string]
    }
}
```

I parametri seguenti sono obbligatori:
+ **inputText**: il prompt fornito al modello affinché questo generi una risposta. Per generare risposte in stile di conversazione, invia il prompt utilizzando il seguente formato:

  ```
  "inputText": "User: {{<theUserPrompt>}}\nBot:"
  ```

  Questo formato indica al modello che deve rispondere su una nuova riga dopo che l’utente ha fornito un prompt.

Il `textGenerationConfig` è facoltativo. Puoi utilizzarlo per configurare i seguenti [parametri di inferenza](inference-parameters.md):
+ **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-titan-text.html)
+ **topP**: utilizza un valore più basso per ignorare le opzioni meno probabili e ridurre la diversità delle risposte. Il valore minimo è escluso 0: utilizza invece un valore molto piccolo come 0,0001.  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-titan-text.html)
+ **max TokenCount**: specifica il numero massimo di token da generare nella risposta. I limiti massimi di token vengono applicati rigorosamente.  
****    
[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-titan-text.html)
+ **stopSequences**: specifica una sequenza di caratteri per indicare dove il modello deve fermarsi.

------
#### [ InvokeModel Response ]

```
{
    "inputTextTokenCount": int,
    "results": [{
        "tokenCount": int,
        "outputText": "\n{{<response>}}\n",
        "completionReason": "string"
    }]
}
```

Il corpo della risposta contiene i campi seguenti:
+ **input TextTokenCount**: il numero di token nel prompt.
+ **results**: un array di un elemento, un oggetto contenente i seguenti campi:
  + **tokenCount**: il numero di token nella risposta.
  + **outputText**: il testo nella risposta.
  + **completionReason**: il motivo per cui la risposta ha smesso di essere generata. Sono possibili i seguenti motivi:
    + FINISHED: la risposta è stata generata completamente.
    + LENGTH: la risposta è stata troncata a causa della lunghezza della risposta impostata.
    + STOP\_CRITERIA\_MET: la risposta è stata troncata perché sono stati raggiunti i criteri di arresto.
    + RAG\_QUERY\_WHEN\_RAG\_DISABLED: la funzionalità è disabilitata e non può completare la query.
    + CONTENT\_FILTERED: i contenuti sono stati filtrati o rimossi dal filtro di contenuto applicato.

------
#### [ InvokeModelWithResponseStream Response ]

Ogni blocco di testo nel corpo del flusso di risposta è nel formato seguente. Devi decodificare il campo `bytes` (cedi [Invia una sola richiesta con InvokeModelInvia una singola richiesta con InvokeModel (spostato)](inference-invoke.md) per un esempio).

```
{
    "chunk": {
        "bytes": b'{
            "index": int,
            "inputTextTokenCount": int,
            "totalOutputTextTokenCount": int,
            "outputText": "{{<response-chunk>}}",
            "completionReason": "string"
        }'
    }
}
```
+ **index**: l’indice del blocco nella risposta di streaming.
+ **input TextTokenCount** — Il numero di token nel prompt.
+ **total OutputTextTokenCount**: il numero di token nella risposta.
+ **outputText**: il testo nella risposta.
+ **completionReason**: il motivo per cui la risposta ha smesso di essere generata. Sono possibili i seguenti motivi.
  + FINISHED: la risposta è stata generata completamente.
  + LENGTH: la risposta è stata troncata a causa della lunghezza della risposta impostata.
  + STOP\_CRITERIA\_MET: la risposta è stata troncata perché sono stati raggiunti i criteri di arresto.
  + RAG\_QUERY\_WHEN\_RAG\_DISABLED: la funzionalità è disabilitata e non può completare la query.
  + CONTENT\_FILTERED: i contenuti sono stati filtrati o rimossi dal filtro applicato.

------

## Esempi di codice
<a name="inference-titan-code"></a>

L’esempio seguente mostra come eseguire l’inferenza con il modello Amazon Titan Text Premier con SDK per 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()
```

L’esempio seguente mostra come eseguire l’inferenza con il modello Amazon Titan Text G1 - Express con SDK per 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()
```