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à. # Valutazione di un modello Amazon Bedrock per l’accuratezza della sintesi testuale È possibile utilizzare un `ModelRunner` wrapper di alto livello per creare una valutazione personalizzata basata su un modello ospitato all'esterno di. JumpStart Questo tutorial mostra come caricare il [modello Anthropic Claude 2](https://www.anthropic.com/index/claude-2), disponibile in Amazon Bedrock, e chiedere a questo modello di riepilogare i prompt di testo. Questo tutorial mostra anche come valutare l’accuratezza della risposta del modello utilizzando le metriche [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge), [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor) e [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore). Il tutorial spiega come: + Configurare l’ambiente. + Eseguire la valutazione del modello. + Visualizzare i risultati dell’analisi. ## Configurare l'ambiente **Prerequisiti** + Utilizza un ambiente kernel Python 3.10 di base e un’istanza `ml.m5.2xlarge` di Amazon Elastic Compute Cloud (Amazon EC2) prima di iniziare il tutorial. Per ulteriori informazioni sui tipi di istanze e sui relativi casi d’uso consigliati, consulta [Tipi di istanze disponibili per l'uso con i notebook Amazon SageMaker Studio Classic](notebooks-available-instance-types.md). **Configurazione di Amazon Bedrock** Prima di utilizzare un modello Amazon Bedrock, devi richiederne l’accesso. 1. Accedi al tuo. Account AWS 1. Se non disponi di un AWS account, consulta [Registrare un AWS account](https://docs.aws.amazon.com/bedrock/latest/userguide/setting-up.html#sign-up-for-aws) in **Configurare Amazon Bedrock**. 1. Apri la [console di Amazon Bedrock](https://console.aws.amazon.com/bedrock). 1. Nella sezione visualizzata **Ti diamo il benvenuto su Amazon Bedrock**, scegli **Gestisci l’accesso al modello**. 1. Nella sezione **Accesso al modello** visualizzata, scegli **Gestisci l’accesso al modello**. 1. Nella sezione **Modelli di base** visualizzata, seleziona la casella accanto a **Claude** nella sottosezione **Anthropic** di **Modelli**. 1. Scegli **Richiedi l’accesso al modello**. 1. Se la richiesta ha esito positivo, dovrebbe apparire un segno di spunta con **Accesso concesso** sotto **Stato di accesso** accanto al modello selezionato. 1. Potrebbe essere necessario accedere nuovamente al tuo account Account AWS per poter accedere al modello. **Installazione delle librerie richieste** 1. Nel codice, installa le librerie `fmeval` e `boto3` come descritto di seguito: ``` !pip install fmeval !pip3 install boto3==1.28.65 ``` 1. Importa le librerie, imposta un fattore di parallelizzazione e invoca un client Amazon Bedrock come descritto di seguito: ``` import boto3 import json import os # Dependent on available hardware and memory os.environ["PARALLELIZATION_FACTOR"] = "1" # Bedrock clients for model inference bedrock = boto3.client(service_name='bedrock') bedrock_runtime = boto3.client(service_name='bedrock-runtime') ``` Nell’esempio di codice precedente, si applica quanto segue: + `PARALLELIZATION_FACTOR`: un moltiplicatore per il numero di batch simultanei inviati all’istanza di calcolo. Se l’hardware consente la parallelizzazione, puoi impostare questo numero per moltiplicare il numero di invocazioni per il processo di valutazione. Ad esempio, se disponi di `100` invocazioni e `PARALLELIZATION_FACTOR` è impostato su `2`, il processo eseguirà `200` invocazioni. Puoi aumentare `PARALLELIZATION_FACTOR` fino a `10` o rimuovere completamente la variabile. Per leggere un blog sull'utilizzo di AWS Lambda, `PARALLELIZATION_FACTOR` consulta Nuovi [controlli di scalabilità Lambda per le sorgenti di eventi Kinesis](https://aws.amazon.com/blogs/compute/new-aws-lambda-scaling-controls-for-kinesis-and-dynamodb-event-sources/) e DynamoDB. 1. Scarica il set di dati `JSON Lines` di esempio [sample-dataset.jsonl](https://github.com/aws/fmeval/blob/8da27af2f20369fd419c03d5bb0707ab24010b14/examples/xsum_sample.jsonl) nella directory di lavoro corrente. 1. Verifica che il tuo ambiente contenga il file di input di esempio come descritto di seguito: ``` import glob # Check for the built-in dataset if not glob.glob("sample-dataset.jsonl"): print("ERROR - please make sure file exists: sample-dataset.jsonl") ``` **Invio di una richiesta di inferenza di esempio al modello** 1. Definisci il modello e il tipo `MIME` del prompt. Per un [modello Anthropic Claude 2](https://www.anthropic.com/index/claude-2) ospitato su Amazon Bedrock, il prompt deve essere strutturato come descritto di seguito: ``` import json model_id = 'anthropic.claude-v2' accept = "application/json" contentType = "application/json" # Ensure that your prompt has the correct format prompt_data = """Human: Who is Barack Obama? Assistant: """ ``` Per ulteriori informazioni su come strutturare il corpo della richiesta, consulta [Model invocation request body field](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html#model-parameters-claude-request-body). Altri modelli possono avere formati diversi. 1. Invia una richiesta di esempio al tuo modello. Il corpo della richiesta contiene il prompt e tutti i parametri aggiuntivi da impostare. Di seguito è riportato un esempio di richiesta con `max_tokens_to_sample` impostato su `500`: ``` body = json.dumps({"prompt": prompt_data, "max_tokens_to_sample": 500}) response = bedrock_runtime.invoke_model( body=body, modelId=model_id, accept=accept, contentType=contentType ) response_body = json.loads(response.get("body").read()) print(response_body.get("completion")) ``` Nell’esempio di codice precedente, puoi impostare i parametri seguenti: + `temperature`: controlla la casualità del testo generato e accetta valori positivi. I valori più alti di `temperature` indicano al modello di generare risposte più casuali e diversificate. I valori più bassi generano risposte più prevedibili. Gli intervalli per `temperature` sono compresi tra `0` e `1`, con un valore predefinito di 0,5. + `topP`: controlla la casualità limitando il set di token da considerare nella generazione del token successivo. I valori più alti di `topP` producono un set che contiene un vocabolario più ampio, mentre i valori più bassi limitano il set di token alle parole più probabili. Gli intervalli per `topP` sono compresi tra `0` e `1`, con un valore predefinito di `1`. + `topK`: limita le previsioni tramite modello ai primi `k` token più probabili. I valori più alti `topK` indicano risposte più creative. I valori più bassi generano risposte più coerenti. Gli intervalli per `topK` sono compresi tra `0` e `500`, con un valore predefinito di `250`. + `max_tokens_to_sample`: limita la lunghezza della risposta contenendo il numero di token restituiti dal modello. Gli intervalli per `max_tokens_to_sample` sono compresi tra `0` e `4096`, con un valore predefinito di `200`. + `stop_sequences`: specifica un elenco di sequenze di caratteri che indicano al modello di arrestare la generazione di una risposta. L’output del modello viene arrestato la prima volta che una delle stringhe elencate viene rilevata nell’output. La risposta non contiene la sequenza di arresto. Ad esempio, puoi utilizzare una sequenza di ritorno a capo per limitare la risposta del modello a una sola riga. Puoi configurare fino a `4` sequenze di arresto. Per ulteriori informazioni sui parametri che puoi specificare in una richiesta, consulta [Modelli Anthropic Claude](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html). **Configurare FMEval** 1. Carica le librerie richieste per eseguirle FMEval come segue: ``` from fmeval.data_loaders.data_config import DataConfig from fmeval.model_runners.bedrock_model_runner import BedrockModelRunner from fmeval.constants import MIME_TYPE_JSONLINES from fmeval.eval_algorithms.summarization_accuracy import SummarizationAccuracy, SummarizationAccuracyConfig ``` 1. Configura i dati per il tuo set di dati di input. Il seguente input di esempio è composto da una sola riga di `sample-dataset.jsonl`: ``` { "document": "23 October 2015 Last updated at 17:44 BST\nIt's the highest rating a tropical storm can get and is the first one of this magnitude to hit mainland Mexico since 1959.\nBut how are the categories decided and what do they mean? Newsround reporter Jenny Lawrence explains.", "summary": "Hurricane Patricia has been rated as a category 5 storm.", "id": "34615665", } ``` L’input di esempio precedente contiene il testo da sintetizzare all’interno della chiave `document`. Il riferimento rispetto al quale valutare la risposta del modello si trova nella chiave `summary`. È necessario utilizzare queste chiavi all'interno della configurazione dei dati per specificare quali colonne contengono le informazioni FMEval necessarie per valutare la risposta del modello. La configurazione dei dati deve identificare il testo che il modello deve sintetizzare in `model_input_location`. Devi identificare il valore di riferimento con `target_output_location`. L’esempio seguente di configurazione dei dati si riferisce al precedente esempio di input, nel quale vengono specificati le colonne richieste per un’attività di sintesi testuale, il nome, l’URI (Uniform Resource Identifier) e il tipo `MIME`: ``` config = DataConfig( dataset_name="sample-dataset", dataset_uri="sample-dataset.jsonl", dataset_mime_type=MIME_TYPE_JSONLINES, model_input_location="document", target_output_location="summary" ) ``` Per ulteriori informazioni sulle informazioni delle colonne richieste per altre attività, consulta la sezione **Utilizzo di un set di dati di input personalizzato** in [Valutazione automatica del modello](clarify-foundation-model-evaluate-auto.md). 1. Configura un `ModelRunner` personalizzato come mostrato nell’esempio di codice seguente: ``` bedrock_model_runner = BedrockModelRunner( model_id=model_id, output='completion', content_template='{"prompt": $prompt, "max_tokens_to_sample": 500}' ) ``` L’esempio di codice precedente specifica quanto segue: + `model_id`: l’ID utilizzato per specificare il modello. + `output`: acquisisce l’output del modello [Anthropic Claude 2](https://www.anthropic.com/index/claude-2), che restituisce la risposta in una chiave `completion`. + `content_template`: specifica in che modo il modello interagisce con le richieste. Il modello di configurazione di esempio viene fornito esclusivamente per spiegare l’esempio precedente e non è obbligatorio. + Nell’esempio `content_template` precedente, si applica quanto segue: + La variabile `prompt` specifica il prompt di input che acquisisce la richiesta effettuata dall’utente. + La variabile `max_tokens_to_sample` specifica che il numero massimo di token è `500`, per limitare la lunghezza della risposta. Per ulteriori informazioni sui parametri che puoi specificare nella richiesta, consulta [Modelli Anthropic Claude](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html). Il formato del parametro `content_template` dipende dagli input e dai parametri supportati dal tuo LLM. In questo tutorial, il [modello Anthropic Claude 2](https://www.anthropic.com/index/claude-2) utilizza `content_template`, riportato di seguito: ``` "content_template": "{\"prompt\": $prompt, \"max_tokens_to_sample\": 500}" ``` Un altro esempio è il [modello Falcon 7b](https://huggingface.co/tiiuae/falcon-7b) che può supportare il `content_template` seguente: ``` "content_template": "{\"inputs\": $prompt, \"parameters\":{\"max_new_tokens\": \ 10, \"top_p\": 0.9, \"temperature\": 0.8}}" ``` ## Esecuzione della valutazione del modello **Definizione ed esecuzione dell’algoritmo di valutazione** 1. Definisci il tuo algoritmo di valutazione. L’esempio seguente mostra come definire un algoritmo `SummarizationAccuracy`, utilizzato per determinare l’accuratezza delle attività di sintesi testuale: ``` eval_algo = SummarizationAccuracy(SummarizationAccuracyConfig()) ``` Per esempi di algoritmi che calcolano le metriche per altre attività di valutazione, consulta **Valutazione del modello** in [Utilizzo della libreria `fmeval` per eseguire una valutazione automatica](clarify-foundation-model-evaluate-auto-lib.md). 1. Esegui l’algoritmo di valutazione. L’esempio di codice seguente utilizza la configurazione dei dati definita in precedenza, oltre a `prompt_template`, che utilizza le chiavi `Human` e `Assistant`: ``` eval_output = eval_algo.evaluate(model=bedrock_model_runner, dataset_config=config, prompt_template="Human: $feature\n\nAssistant:\n", save=True) ``` Nell’esempio di codice precedente, `feature` contiene il prompt nel formato previsto dal modello Amazon Bedrock. ## Visualizzazione dei risultati dell’analisi 1. Analizza un report di valutazione dall’oggetto `eval_output` restituito dall’algoritmo di valutazione come descritto di seguito: ``` # parse report print(json.dumps(eval_output, default=vars, indent=4)) ``` Il comando precedente restituisce il seguente output: ``` [ { "eval_name": "summarization_accuracy", "dataset_name": "sample-dataset", "dataset_scores": [ { "name": "meteor", "value": 0.2048823008681274 }, { "name": "rouge", "value": 0.03557697913367101 }, { "name": "bertscore", "value": 0.5406564395678671 } ], "prompt_template": "Human: $feature\n\nAssistant:\n", "category_scores": null, "output_path": "/tmp/eval_results/summarization_accuracy_sample_dataset.jsonl", "error": null } ] ``` L’output di esempio precedente mostra i tre punteggi di accuratezza [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor), [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge) e [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore), il valore `prompt_template` di input, un valore `category_score` (se è stato richiesto), gli eventuali errori e il valore `output_path`. Nella fase seguente, utilizzerai `output_path` per creare `Pandas DataFrame`. 1. Importa i risultati e leggili in un `DataFrame`, quindi collega i punteggi di accuratezza all’input del modello, all’output del modello e all’output di destinazione come descritto di seguito: ``` import pandas as pd data = [] with open("/tmp/eval_results/summarization_accuracy_sample_dataset.jsonl", "r") as file: for line in file: data.append(json.loads(line)) df = pd.DataFrame(data) df['meteor_score'] = df['scores'].apply(lambda x: x[0]['value']) df['rouge_score'] = df['scores'].apply(lambda x: x[1]['value']) df['bert_score'] = df['scores'].apply(lambda x: x[2]['value']) df ``` In questa invocazione, l’esempio di codice precedente restituisce il seguente output (contratto per brevità): ``` model_input model_output target_output prompt scores meteor_score rouge_score bert_score 0 John Edward Bates, formerly of Spalding, Linco... I cannot make any definitive judgments, as th... A former Lincolnshire Police officer carried o... Human: John Edward Bates, formerly of Spalding... [{'name': 'meteor', 'value': 0.112359550561797... 0.112360 0.000000 0.543234 ... 1 23 October 2015 Last updated at 17:44 BST\nIt'... Here are some key points about hurricane/trop... Hurricane Patricia has been rated as a categor... Human: 23 October 2015 Last updated at 17:44 B... [{'name': 'meteor', 'value': 0.139822692925566... 0.139823 0.017621 0.426529 ... 2 Ferrari appeared in a position to challenge un... Here are the key points from the article:\n\n... Lewis Hamilton stormed to pole position at the... Human: Ferrari appeared in a position to chall... [{'name': 'meteor', 'value': 0.283411142234671... 0.283411 0.064516 0.597001 ... 3 The Bath-born player, 28, has made 36 appearan... Okay, let me summarize the key points from th... Newport Gwent Dragons number eight Ed Jackson ... Human: The Bath-born player, 28, has made 36 a... [{'name': 'meteor', 'value': 0.089020771513353... 0.089021 0.000000 0.533514 ... ... ``` L’output del modello potrebbe essere diverso dall’output di esempio precedente. Per un taccuino che contiene gli esempi di codice forniti in questa sezione, vedete [bedrock-claude-summarization-accuracy.ipnyb.](https://github.com/aws/fmeval/blob/main/examples/bedrock-claude-summarization-accuracy.ipynb)