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à. # Tutorial sui notebook per la valutazione del modello Questa sezione fornisce i seguenti tutorial per i notebook, con codice di esempio e spiegazioni: + Come valutare un JumpStart modello per una rapida stereotipizzazione. + Come valutare un modello Amazon Bedrock per l’accuratezza della sintesi testuale. **Topics** + [Valuta un JumpStart modello per una rapida stereotipizzazione](clarify-foundation-model-evaluate-auto-tutorial-one.md) + [Valutazione di un modello Amazon Bedrock per l’accuratezza della sintesi testuale](clarify-foundation-model-evaluate-auto-tutorial-two.md) + [Notebook aggiuntivi](#clarify-foundation-model-evaluate-auto-tutorial-ex) # Valuta un JumpStart modello per una rapida stereotipizzazione Puoi utilizzare un `ModelRunner` wrapper di alto livello per valutare un SageMaker JumpStart modello Amazon per una rapida stereotipizzazione. L’algoritmo di stereotipizzazione dei prompt misura la probabilità che il modello includa bias nella risposta. Questi bias riguardano razza, genere, orientamento sessuale, religione, età, nazionalità, disabilità, aspetto fisico e status socioeconomico. Questo tutorial mostra come caricare il modello [Falcon 7-B](https://huggingface.co/tiiuae/falcon-7b) del [Technology Innovation Institute](https://www.tii.ae/), disponibile in JumpStart, e chiedere a questo modello di generare risposte ai prompt. Quindi, questo tutorial mostra come valutare le risposte per rilevare la stereotipizzazione dei prompt nel set di dati complesso open source [CrowS-Pairs](https://github.com/nyu-mll/crows-pairs) integrato. Le sezioni del tutorial spiegano 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.g4dn.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). **Installazione delle librerie richieste** 1. Installa l' SageMaker IA e `fmeval` le altre librerie richieste nel codice come segue: ``` !pip3 install sagemaker !pip3 install -U pyarrow !pip3 install -U accelerate !pip3 install "ipywidgets>=8" !pip3 install jsonlines !pip install fmeval !pip3 install boto3==1.28.65 import sagemaker ``` 1. Scarica il set di dati `JSON Lines` di esempio [crows-pairs\$1sample.jsonl](https://github.com/aws/fmeval/blob/main/examples/crows-pairs_sample.jsonl) nella directory di lavoro corrente. 1. Verifica che il tuo ambiente contenga il file di input di esempio utilizzando il codice seguente: ``` import glob # Check for fmeval wheel and built-in dataset if not glob.glob("crows-pairs_sample.jsonl"): print("ERROR - please make sure file exists: crows-pairs_sample.jsonl") ``` 1. Definisci un JumpStart modello come segue: ``` from sagemaker.jumpstart.model import JumpStartModel model_id, model_version, = ( "huggingface-llm-falcon-7b-instruct-bf16", "*", ) ``` 1. Implementate il JumpStart modello e create un endpoint come segue: ``` my_model = JumpStartModel(model_id=model_id) predictor = my_model.deploy() endpoint_name = predictor.endpoint_name ``` 1. Definisci un prompt e il formato della richiesta del modello, o payload, come descritto di seguito: ``` prompt = "London is the capital of" payload = { "inputs": prompt, "parameters": { "do_sample": True, "top_p": 0.9, "temperature": 0.8, "max_new_tokens": 1024, "decoder_input_details" : True, "details" : True }, } ``` Nell’esempio di codice precedente, nella richiesta del modello sono inclusi i seguenti parametri: + `do_sample`: indica al modello di campionare i risultati del modello non elaborato (prima della normalizzazione) durante l’inferenza del modello per introdurre diversità e creatività nelle risposte del modello. L’impostazione predefinita è `False`. Se imposti `do_sample` su `True`, devi specificare un valore per uno dei seguenti parametri: `temperature`, `top_k`, `top_p` o `typical_p`. + `top_p`: controlla la casualità limitando il set di token da considerare nella generazione del token successivo. I valori più alti di `top_p` indicano un set che contiene un vocabolario più ampio. I valori più bassi limitano il set di token alle parole più probabili. Gli intervalli per `top_p` sono maggiori di `0` e minori di `1`. + `temperature`: controlla la casualità del testo generato. I valori più alti di `temperature` indicano al modello di generare risposte più casuali e diversificate. I valori più bassi generano risposte più prevedibili. I valori per `temperature` devono essere positivi. + `max_new_tokens`: limita la lunghezza della risposta contenendo il numero di token restituiti dal modello. L’impostazione predefinita è `20`. + `decoder_input_details`— Restituisce informazioni sulle probabilità di registro assegnate dal modello a ciascun potenziale token successivo e al token corrispondente. IDs Se `decoder_input_details` è impostato su `True`, devi impostare anche `details` su `True` per ricevere le informazioni richieste. L’impostazione predefinita è `False`. Per ulteriori informazioni sui parametri per questo modello `Hugging Face`, consulta [types.py](https://github.com/huggingface/text-generation-inference/blob/v0.9.3/clients/python/text_generation/types.py#L8). ## Invio di una richiesta di inferenza di esempio Per testare il modello, invia una richiesta di esempio al modello e stampa la risposta del modello come descritto di seguito: ``` response = predictor.predict(payload) print(response[0]["generated_text"]) ``` Nell’esempio di codice precedente, se il modello ha fornito la risposta `[{"response": "this is the output"}]`, l’istruzione `print` restituisce `this is the output`. ## Configura FMEval 1. Carica le librerie richieste per eseguirle FMEval come segue: ``` import fmeval from fmeval.data_loaders.data_config import DataConfig from fmeval.model_runners.sm_jumpstart_model_runner import JumpStartModelRunner from fmeval.constants import MIME_TYPE_JSONLINES from fmeval.eval_algorithms.prompt_stereotyping import PromptStereotyping, PROMPT_STEREOTYPING from fmeval.eval_algorithms import EvalAlgorithm ``` 1. Configura i dati per il tuo set di dati di input. Se non utilizzi un set di dati integrato, la configurazione dei dati deve identificare la colonna che contiene più bias in `sent_more_input_location`. Devi anche identificare la colonna che contiene meno bias in `sent_less_input_location`. Se si utilizza un set di dati integrato da JumpStart, questi parametri vengono passati FMEval automaticamente tramite i metadati del modello. Specifica le colonne `sent_more_input_location` e `sent_less_input_location` per un’attività di stereotipizzazione dei prompt, oltre che per il nome, l’URI (Uniform Resource Identifier) e il tipo `MIME`. ``` config = DataConfig( dataset_name="crows-pairs_sample", dataset_uri="crows-pairs_sample.jsonl", dataset_mime_type=MIME_TYPE_JSONLINES, sent_more_input_location="sent_more", sent_less_input_location="sent_less", category_location="bias_type", ) ``` Per ulteriori informazioni sulle informazioni delle colonne richieste da altre attività, consulta la sezione **Utilizzo di un set di dati di input personalizzato** in [Utilizzo di un set di dati di input personalizzato](clarify-foundation-model-evaluate-auto-lib-custom.md#clarify-foundation-model-evaluate-auto-lib-custom-input). 1. Configura un `ModelRunner` personalizzato come mostrato nell’esempio di codice seguente: ``` js_model_runner = JumpStartModelRunner( endpoint_name=endpoint_name, model_id=model_id, model_version=model_version, output='[0].generated_text', log_probability='[0].details.prefill[*].logprob', content_template='{"inputs": $prompt, "parameters": {"do_sample": true, "top_p": 0.9, "temperature": 0.8, "max_new_tokens": 1024, "decoder_input_details": true,"details": true}}', ) ``` L’esempio di codice precedente specifica quanto segue: + `endpoint_name`: il nome dell’endpoint creato nella fase precedente **Installazione delle librerie richieste**. + `model_id`: l’ID utilizzato per specificare il modello. Questo parametro è stato specificato al momento della definizione del JumpStart modello. + `model_version`: la versione del modello utilizzata per specificare il modello. Questo parametro è stato specificato al momento della definizione del JumpStart modello. + `output`: acquisisce l’output del [modello Falcon 7b](https://huggingface.co/tiiuae/falcon-7b), che restituisce la risposta in una chiave `generated_text`. Se il modello ha fornito la risposta `[{"generated_text": "this is the output"}]`, `[0].generated_text` restituisce `this is the output`. + `log_probability`— Cattura la probabilità logaritmica restituita da questo JumpStart modello. + `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. I parametri nel modello di contenuto sono gli stessi dichiarati per `payload`. Per ulteriori informazioni sui parametri per questo modello `Hugging Face`, consulta [types.py](https://github.com/huggingface/text-generation-inference/blob/v0.9.3/clients/python/text_generation/types.py#L8). 1. Configura il report di valutazione e salvalo in una directory come mostrato nel codice di esempio seguente: ``` import os eval_dir = "results-eval-prompt-stereotyping" curr_dir = os.getcwd() eval_results_path = os.path.join(curr_dir, eval_dir) + "/" os.environ["EVAL_RESULTS_PATH"] = eval_results_path if os.path.exists(eval_results_path): print(f"Directory '{eval_results_path}' exists.") else: os.mkdir(eval_results_path) ``` 1. Configura un fattore di parallelizzazione come descritto di seguito: ``` os.environ["PARALLELIZATION_FACTOR"] = "1" ``` `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à AWS 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. ## Esecuzione della valutazione del modello 1. Definisci il tuo algoritmo di valutazione. L’esempio seguente mostra come definire un algoritmo `PromptStereotyping`. ``` eval_algo = PromptStereotyping() ``` 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 il modello e la configurazione dei dati precedentemente definiti, oltre a `prompt_template`, che utilizza `feature` per passare il prompt al modello nel modo seguente: ``` eval_output = eval_algo.evaluate(model=js_model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` L’output del modello potrebbe essere diverso dall’output di esempio precedente. ## Visualizzazione dei risultati dell’analisi 1. Analizza un report di valutazione dall’oggetto `eval_output` restituito dall’algoritmo di valutazione come descritto di seguito: ``` import json print(json.dumps(eval_output, default=vars, indent=4)) ``` Il comando precedente restituisce l’output seguente (ridotto per brevità): ``` [ { "eval_name": "prompt_stereotyping", "dataset_name": "crows-pairs_sample", "dataset_scores": [ { "name": "prompt_stereotyping", "value": 0.6666666666666666 } ], "prompt_template": "$feature", "category_scores": [ { "name": "disability", "scores": [ { "name": "prompt_stereotyping", "value": 0.5 } ] }, ... ], "output_path": "/home/sagemaker-user/results-eval-prompt-stereotyping/prompt_stereotyping_crows-pairs_sample.jsonl", "error": null } ] ``` L’output di esempio precedente mostra un punteggio complessivo per il set di dati che segue `"name": prompt_stereotyping`. Questo punteggio rappresenta la differenza normalizzata in termini di probabilità logaritmiche tra la risposta del modello con **più** bias rispetto a una con meno bias. Se il punteggio è maggiore di `0.5`, significa che è più probabile che il modello restituisca una risposta che contiene più bias. Se il punteggio è minore di `0.5`, significa che è più probabile che il modello restituisca una risposta che contiene meno bias. Se il punteggio è `0.5`, la risposta del modello non contiene bias misurati dal set di dati di input. Nella fase seguente, utilizzerai `output_path` per creare `Pandas` `DataFrame`. 1. Importa i risultati e leggili in un `DataFrame`, quindi collega i punteggi di stereotipizzazione dei prompt all’input del modello, all’output del modello e all’output di destinazione come illustrato di seguito: ``` import pandas as pd data = [] with open(os.path.join(eval_results_path, "prompt_stereotyping_crows-pairs_sample.jsonl"), "r") as file: for line in file: data.append(json.loads(line)) df = pd.DataFrame(data) df['eval_algo'] = df['scores'].apply(lambda x: x[0]['name']) df['eval_score'] = df['scores'].apply(lambda x: x[0]['value']) df ``` [Per un taccuino che contiene gli esempi di codice forniti in questa sezione, consulta .ipnyb. jumpstart-falcon-stereotyping](https://github.com/aws/fmeval/blob/main/examples/jumpstart-falcon-stereotyping.ipynb) # 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) ## Notebook aggiuntivi La GitHub directory [fmeval](https://github.com/aws/fmeval/tree/main/examples) contiene i seguenti taccuini di esempio aggiuntivi: + [bedrock-claude-factual-knowledge.ipnyb](https://github.com/aws/fmeval/blob/main/examples/bedrock-claude-factual-knowledge.ipynb) — Valuta un [modello Anthropic Claude 2](https://www.anthropic.com/index/claude-2) ospitato su Amazon Bedrock per una conoscenza fattuale. + [byo-model-outputs.ipynb: valuta un modello Falcon 7b](https://github.com/aws/fmeval/blob/main/examples/byo-model-outputs.ipynb) [ospitato su di esso JumpStart per acquisire conoscenze fattuali, in cui è possibile inserire gli output del modello](https://huggingface.co/tiiuae/falcon-7b) anziché inviare richieste di inferenza al modello. + [custom\$1model\$1runner\$1chat\$1gpt.ipnyb](https://github.com/aws/fmeval/blob/main/examples/custom_model_runner_chat_gpt.ipynb): valuta un modello `ChatGPT 3.5` personalizzato ospitato su `Hugging Face` per le conoscenze fattuali.