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à. # Utilizzo della libreria `fmeval` per eseguire una valutazione automatica L’utilizzo della libreria `fmeval` nel tuo codice ti offre la massima flessibilità per personalizzare il flusso di lavoro. Puoi utilizzare la libreria `fmeval` per valutare qualsiasi LLM e anche per avere maggiore flessibilità con i tuoi set di dati di input personalizzati. Nelle fasi seguenti viene illustrato come configurare l’ambiente e come utilizzare la libreria `fmeval` per eseguire sia un flusso di lavoro iniziale sia un flusso di lavoro personalizzato. ## Nozioni di base sull’utilizzo della libreria `fmeval` Puoi configurare la valutazione del modello di fondazione e personalizzarla in base al tuo caso d’uso in un notebook Studio. La configurazione dipende sia dal tipo di attività che il modello di base è progettato per prevedere, sia dal modo in cui si desidera valutarla. FMEval supporta attività aperte di generazione, riepilogo del testo, risposta alle domande e classificazione. Nella procedura descritta in questa sezione viene illustrato come configurare un flusso di lavoro iniziale. Questo flusso di lavoro iniziale include la configurazione dell'ambiente e l'esecuzione di un algoritmo di valutazione utilizzando un modello di base Amazon Bedrock JumpStart o uno con set di dati integrati. Se devi utilizzare un set di dati di input e un flusso di lavoro personalizzati per un caso d’uso più specifico, consulta [Personalizzazione del flusso di lavoro con la libreria `fmeval`](clarify-foundation-model-evaluate-auto-lib-custom.md). ## Configurare l'ambiente Se non intendi eseguire una valutazione del modello in un notebook Studio, vai alla Fase 11 della sezione **Nozioni di base sull’utilizzo di Studio** seguente. **Prerequisiti** + Per eseguire una valutazione del modello in un’interfaccia utente di Studio, il ruolo AWS Identity and Access Management (IAM) e tutti i set di dati di input devono disporre delle autorizzazioni corrette. Se non disponi di un dominio SageMaker AI o di un ruolo IAM, segui i passaggi indicati. [Guida alla configurazione con Amazon SageMaker AI](gs.md) **Per impostare le autorizzazioni per il bucket Amazon S3** Dopo aver creato il dominio e il ruolo, utilizza la procedura seguente per aggiungere le autorizzazioni necessarie per valutare il modello. 1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/). 1. Nel riquadro di navigazione, immetti **S3** nella barra di ricerca nella parte superiore della pagina. 1. In **Servizi**, scegli **S3**. 1. Nel riquadro di navigazione, scegli **Bucket**. 1. Nella sezione **Bucket per uso generico**, in **Nome**, scegli il nome del bucket S3 da utilizzare per archiviare l’input e l’output del modello nella console. Se non hai già un bucket S3, procedi come descritto di seguito: 1. Seleziona **Crea bucket** per aprire una nuova pagina **Crea bucket**. 1. Nella sezione **Configurazione generale**, in **Regione AWS **, seleziona la Regione AWS in cui si trova il modello di fondazione. 1. Assegna un nome al bucket S3 nella casella di input in **Nome bucket**. 1. Accetta tutte le scelte predefinite. 1. Seleziona **Crea bucket**. 1. Nella sezione **Bucket per uso generico**, in **Nome**, seleziona il nome del bucket S3 che hai creato. 1. Scegli la scheda **Autorizzazioni**. 1. Scorri fino alla sezione **Condivisione delle risorse multiorigine (CORS)** nella parte inferiore della finestra. Scegli **Modifica**. 1. Per aggiungere le autorizzazioni al tuo bucket per le valutazioni dei modelli di fondazione, assicurati che nella casella di input compaia il codice seguente. Puoi anche copiare e incollare quanto segue nella casella di input. ``` [ { "AllowedHeaders": [ "*" ], "AllowedMethods": [ "GET", "PUT", "POST", "DELETE" ], "AllowedOrigins": [ "*" ], "ExposeHeaders": [ "Access-Control-Allow-Origin" ] } ] ``` 1. Scegli **Save changes** (Salva modifiche). **Per aggiungere le autorizzazioni alla policy IAM** 1. Immetti **IAM** nella barra di ricerca nella parte superiore della pagina. 1. In **Servizi**, seleziona **Identity and Access Management (IAM)**. 1. Nel riquadro di navigazione, scegli **Policy**. 1. Inserisci [AmazonSageMakerFullAccess](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonSageMakerFullAccess)nella barra di ricerca. Seleziona il pulsante di opzione accanto alla policy visualizzata. Ora il pulsante **Azioni** può essere selezionato. 1. Scegli la freccia giù accanto ad **Azioni**. Vengono visualizzate due opzioni. 1. Scegli **Collega**. 1. Nell’elenco IAM visualizzato, cerca il nome del ruolo che hai creato. Seleziona la casella di controllo accanto a tale nome. 1. Scegli **Collega policy**. **Nozioni di base sull’utilizzo di Studio** 1. Immetti **SageMaker AI** nella barra di ricerca nella parte superiore della pagina. 1. In **Servizi**, seleziona **Amazon SageMaker AI**. 1. Scegli **Studio** nel riquadro di navigazione. 1. Scegli il tuo dominio dalla sezione **Nozioni di base** dopo aver selezionato la freccia giù in **Seleziona dominio**. 1. Scegli il tuo profilo utente dalla sezione **Nozioni di base** dopo aver selezionato la freccia giù in **Seleziona profilo utente**. 1. Scegli **Apri Studio** per aprire la pagina di destinazione di Studio. 1. Seleziona il browser di file dal riquadro di navigazione e vai alla directory root. 1. Seleziona **Crea notebook**. 1. Nella finestra di dialogo dell’ambiente del notebook visualizzata, seleziona l’immagine **Data Science 3.0**. 1. Scegli **Seleziona**. 1. Installa il pacchetto `fmeval` nell’ambiente di sviluppo, come mostrato nell’esempio di codice seguente: ``` !pip install fmeval ``` **Nota** Installa la libreria `fmeval` in un ambiente che utilizza Python 3.10. Per ulteriori informazioni sui requisiti necessari per l’esecuzione di `fmeval`, consulta [Dipendenze di `fmeval`](https://github.com/aws/fmeval/blob/main/pyproject.toml). ## Configurare `ModelRunner` FMEval utilizza un wrapper di alto livello chiamato per `ModelRunner` comporre l'input, richiamare ed estrarre l'output dal tuo modello. Il pacchetto `fmeval` può valutare qualsiasi LLM, tuttavia la procedura per configurare `ModelRunner` dipende dal tipo di modello da valutare. Questa sezione spiega come configurare `ModelRunner` per un JumpStart modello Amazon Bedrock. Per utilizzare un set di dati di input e `ModelRunner` personalizzati, consulta [Personalizzazione del flusso di lavoro con la libreria `fmeval`](clarify-foundation-model-evaluate-auto-lib-custom.md). ### Usa un modello JumpStart Da utilizzare `ModelRunner` per valutare un JumpStart modello, creare o fornire un endpoint, definire il modello e il set di dati integrato, configurare e testare. `ModelRunner` **Definire un JumpStart modello e configurare un ModelRunner** 1. Fornisci un endpoint in uno dei seguenti modi: + [EndpointName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#API_runtime_InvokeEndpoint_RequestSyntax)Specificare su un JumpStart endpoint esistente, il`model_id`, e`model_version`. + Specificate la `model_id` e `model_version` per il modello e create un JumpStart endpoint. Il seguente esempio di codice mostra come creare un endpoint per un [https://aws.amazon.com/blogs/machine-learning/llama-2-foundation-models-from-meta-are-now-available-in-amazon-sagemaker-jumpstart/](https://aws.amazon.com/blogs/machine-learning/llama-2-foundation-models-from-meta-are-now-available-in-amazon-sagemaker-jumpstart/)che è disponibile tramite. JumpStart ``` import sagemaker from sagemaker.jumpstart.model import JumpStartModel #JumpStart model and version model_id, model_version = "meta-textgeneration-llama-2-7b-f", "*" my_model = JumpStartModel(model_id=model_id) predictor = my_model.deploy() endpoint_name = predictor.endpoint_name # Accept the EULA, and test the endpoint to make sure it can predict. predictor.predict({"inputs": [[{"role":"user", "content": "Hello how are you?"}]]}, custom_attributes='accept_eula=true') ``` L'esempio di codice precedente si riferisce a EULA, che sta per end-use-license-agreement (EULA). L’EULA è disponibile nella descrizione della scheda del modello in uso. Per utilizzare alcuni JumpStart modelli, è necessario specificare`accept_eula=true`, come mostrato nella precedente chiamata a. `predict` Per ulteriori informazioni sull’EULA, consulta la sezione **Licenses and model sources** in [Origini dei modelli e contratti di licenza](jumpstart-foundation-models-choose.md). È possibile trovare un elenco di JumpStart modelli disponibili in [Built-in Algorithms with pre-training Model](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html#built-in-algorithms-with-pre-trained-model-table) Table. 1. Configura `ModelRunner` con `JumpStartModelRunner`, come illustrato nell’esempio seguente: ``` from fmeval.model_runners.sm_jumpstart_model_runner import JumpStartModelRunner js_model_runner = JumpStartModelRunner( endpoint_name=endpoint_name, model_id=model_id, model_version=model_version ) ``` Nell’esempio di configurazione precedente, utilizza gli stessi valori per `endpoint_name`, `model_id` e `model_version` che hai utilizzato per creare l’endpoint. 1. Testa `ModelRunner`. Invia una richiesta di esempio al tuo modello come mostrato nell’esempio di codice seguente: ``` js_model_runner.predict("What is the capital of London") ``` ### Utilizzo di un modello Amazon Bedrock Per valutare un modello Amazon Bedrock, devi definire il modello e il set di dati integrato e configurare `ModelRunner`. **Definisci un modello Amazon Bedrock e configura un ModelRunner** 1. Per definire e stampare i dettagli del modello, utilizza il codice di esempio seguente per un modello Titan disponibile tramite Amazon Bedrock: ``` import boto3 import json bedrock = boto3.client(service_name='bedrock') bedrock_runtime = boto3.client(service_name='bedrock-runtime') model_id = "amazon.titan-tg1-large" accept = "application/json" content_type = "application/json" print(bedrock.get_foundation_model(modelIdentifier=modelId).get('modelDetails')) ``` Nell’esempio di codice precedente, il parametro `accept` specifica il formato dei dati da utilizzare per valutare il tuo LLM. `contentType` specifica il formato dei dati di input nella richiesta. Solo `MIME_TYPE_JSON` è supportato per `accept` e `contentType` per i modelli Amazon Bedrock. Per ulteriori informazioni su questi parametri, consultare [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html#API_runtime_InvokeModelWithResponseStream_RequestSyntax). 1. Per configurare `ModelRunner`, utilizza `BedrockModelRunner` come illustrato nell’esempio seguente: ``` from fmeval.model_runners.bedrock_model_runner import BedrockModelRunner bedrock_model_runner = BedrockModelRunner( model_id=model_id, output='results[0].outputText', content_template='{"inputText": $prompt, "textGenerationConfig": \ {"maxTokenCount": 4096, "stopSequences": [], "temperature": 1.0, "topP": 1.0}}', ) ``` Definisci i parametri della configurazione `ModelRunner` come segue. + Inserisci gli stessi valori per `model_id` utilizzati per implementare il modello. + Utilizza `output` per specificare il formato della risposta `json` generata. Ad esempio, se l’LLM ha fornito la risposta `[{"results": "this is the output"}]`, `output='results[0].outputText'` restituisce `this is the output`. + Utilizza `content_template` per specificare in che modo l’LLM interagisce con le richieste. Il modello di configurazione seguente viene fornito esclusivamente per spiegare l’esempio di configurazione precedente e non è obbligatorio. + Nell’esempio di configurazione precedente, la variabile `inputText` specifica il prompt, che acquisisce la richiesta effettuata dall’utente. + La variabile `textGenerationConfig` specifica in che modo l’LLM genera le risposte: + Il parametro `maxTokenCount` viene utilizzato per contenere la lunghezza della risposta limitando il numero di token restituiti dall’LLM. + Il parametro `stopSequences` viene utilizzato per specificare un elenco di sequenze di caratteri che indicano all’LLM 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. Ad esempio, puoi utilizzare una sequenza di ritorno a capo per limitare la risposta del modello a una sola riga. + Il parametro `topP` controlla la casualità limitando il set di token da considerare nella generazione del token successivo. Questo parametro accetta valori compresi tra `0.0` e `1.0`. 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. + Il parametro `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 tipici di `temperature` sono compresi tra `0.2` e `2.0`. Per ulteriori informazioni sui parametri per uno specifico modello di fondazione Amazon Bedrock, consulta [Parametri di inferenza per modelli di fondazione](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html#model-parameters-titan). Il formato del parametro content\$1template dipende dagli input e dai parametri supportati dal tuo LLM. Ad esempio, il [modello Anthropic’s Claude 2](https://www.anthropic.com/index/claude-2) può supportare il `content_template` seguente: ``` "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}}" ``` Infine, testa `ModelRunner`. Invia una richiesta di esempio al tuo modello come mostrato nell’esempio di codice seguente: ``` bedrock_model_runner.predict("What is the capital of London?") ``` ## Valutazione del modello Dopo aver configurato i dati e `ModelRunner`, puoi eseguire un algoritmo di valutazione sulle risposte generate dal tuo LLM. Per visualizzare un elenco completo di tutti gli algoritmi di valutazione disponibili, esegui questo codice: ``` from fmeval.eval_algo_mapping import EVAL_ALGORITHMS print(EVAL_ALGORITHMS.keys()) ``` Ogni algoritmo ha sia una valutazione che un metodo `evaluate_sample`. Il metodo `evaluate` calcola un punteggio per l’intero set di dati. Il metodo `evaluate_sample` valuta il punteggio per una singola istanza. Il metodo `evaluate_sample` restituisce oggetti `EvalScore`. Gli oggetti `EvalScore` contengono punteggi aggregati delle prestazioni del modello durante la valutazione. Il metodo `evaluate_sample` prevede i seguenti parametri facoltativi. + `model_output`: la risposta del modello per una singola richiesta. + `model_input`: un prompt che contiene la richiesta al modello. + `target_output`: la risposta prevista dal prompt contenuto in `model_input`. L’esempio di codice seguente mostra come utilizzare `evaluate_sample`: ``` #Evaluate your custom sample model_output = model_runner.predict("London is the capital of?")[0] eval_algo.evaluate_sample(target_output="UKEnglandUnited Kingdom", model_output=model_output) ``` Il metodo `evaluate` prevede i seguenti parametri facoltativi. + `model`: un’istanza di `ModelRunner` che utilizza il modello che intendi valutare. + `dataset_config`: la configurazione del set di dati. Se `dataset_config` non viene fornito, il modello viene valutato utilizzando tutti i set di dati integrati configurati per questa attività. + `prompt_template`: un modello utilizzato per generare prompt. Se `prompt_template` non viene fornito, il modello viene valutato utilizzando un modello di prompt predefinito. + `save`: se impostato su `True`, le risposte ai prompt e i punteggi relativi al record vengono salvati nel file `EvalAlgorithmInterface.EVAL_RESULTS_PATH`. L’impostazione predefinita è `False`. + `num_records`: il numero di record campionato casualmente dal set di dati di input per la valutazione. L’impostazione predefinita è `300`. L’algoritmo `evaluate` restituisce un elenco di oggetti `EvalOutput` che può includere quanto segue: + `eval_name`: il nome dell’algoritmo di valutazione. `dataset_name`: il nome del set di dati utilizzato dall’algoritmo di valutazione. `prompt_template`: un modello utilizzato per comporre prompt che viene utilizzato se il parametro `model_output` non è fornito nel set di dati. Per ulteriori informazioni, consulta `prompt_template` la ** JumpStart `ModelRunner`sezione Configurare un**. `dataset_scores`: un punteggio aggregato calcolato sull’intero set di dati. `category_scores`: un elenco di oggetti `CategoryScore` che contiene i punteggi per ogni categoria nel set di dati. `output_path`: il percorso locale dell’output di valutazione. Questo output contiene le risposte del prompt con punteggi di valutazione relativi al record. `error`: un messaggio di errore di tipo stringa relativo a un processo di valutazione non riuscito. Per la valutazione del modello sono disponibili le dimensioni seguenti: + Accuratezza + Conoscenze fattuali + Stereotipizzazione dei prompt + Robustezza semantica + Tossicità ### Accuratezza Puoi eseguire un algoritmo di accuratezza per un’attività di risposta alle domande, sintesi testuale o classificazione. Gli algoritmi sono diversi per ogni attività, per adattarsi ai diversi problemi e tipi di input dei dati, come descritto di seguito: + Per le attività di risposta alle domande, esegui l’algoritmo `QAAccuracy` con un file `QAAccuracyConfig`. + Per le attività di sintesi testuale, esegui l’algoritmo `SummarizationAccuracy` con `SummarizationAccuracyConfig`. + Per le attività di classificazione, esegui l’algoritmo `ClassificationAccuracy` con `ClassificationAccuracyConfig`. L’algoritmo `QAAccuracy` restituisce un elenco di oggetti `EvalOutput` che contiene un punteggio di accuratezza per ogni campione. Per eseguire l’algoritmo di accuratezza della risposta alla domanda, crea un’istanza di `QAAccuracygeConfig` e passa `` o `None` come `target_output_delimiter`. L’algoritmo di accuratezza della risposta alla domanda confronta la risposta generata dal modello con una risposta nota. Se passi `` come delimitatore di destinazione, l’algoritmo valuta la risposta come corretta se genera uno qualsiasi dei contenuti separati da `` nella risposta. Se passi `None` o una stringa vuota come `target_output_delimiter`, il codice genera un errore. Chiama il metodo `evaluate` e passa i parametri desiderati come mostrato nell’esempio di codice seguente: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.qa_accuracy import QAAccuracy, QAAccuracyConfig eval_algo = QAAccuracy(QAAccuracyConfig(target_output_delimiter=""))) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` L’algoritmo `SummarizationAccuracy` restituisce un elenco di oggetti `EvalOutput` che contiene i punteggi per [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). Per ulteriori informazioni su questi punteggi, consulta la sezione Sintesi testuale in [Utilizzo dei set di dati dei prompt e delle dimensioni di valutazione disponibili nei processi di valutazione del modello](clarify-foundation-model-evaluate-overview.md). Per eseguire l’algoritmo di accuratezza della sintesi testuale, crea un’istanza di `SummarizationAccuracyConfig` e passa quanto segue: + Specifica in `rouge_type` il tipo di metrica [https://en.wikipedia.org/wiki/ROUGE_(metric)](https://en.wikipedia.org/wiki/ROUGE_(metric)) da utilizzare nella valutazione. È possibile scegliere `rouge1`, `rouge2`, oppure `rougeL`. Queste metriche confrontano le sintesi generate con le sintesi di riferimento. ROUGE-1 confronta le sintesi generate e le sintesi di riferimento utilizzando unigrammi sovrapposti (sequenze di un solo elemento come “il”, “è”). ROUGE-2 confronta le sintesi generate e quelle di riferimento utilizzando bigrammi (gruppi di due sequenze come “il grande”, “è casa”). ROUGE-L confronta la sequenza più lunga di parole corrispondenti. Per ulteriori informazioni su ROUGE, consulta [ROUGE: A Package for Automatic Evaluation of Summaries](https://aclanthology.org/W04-1013.pdf). + Imposta `use_stemmer_for_rouge` su `True` o `False`. Uno stemmer rimuove gli affissi dalle parole prima di confrontarle. Ad esempio, uno stemmer rimuove gli affissi da “nuotando” e “nuotava”, trasformando entrambi in “nuotare” dopo lo stemming. + Imposta model\$1type\$1for\$1bertscore sul modello da utilizzare per calcolare [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore). Puoi scegliere [ROBERTA\$1MODEL](https://huggingface.co/docs/transformers/model_doc/roberta) o il più avanzato [MICROSOFT\$1DEBERTA\$1MODEL](https://github.com/microsoft/DeBERTa). Infine, chiama il metodo `evaluate` e passa i parametri desiderati come mostrato nell’esempio di codice seguente: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.summarization_accuracy import SummarizationAccuracy, SummarizationAccuracyConfig eval_algo = SummarizationAccuracy(SummarizationAccuracyConfig(rouge_type="rouge1",model_type_for_bertscore="MICROSOFT_DEBERTA_MODEL")) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` L’algoritmo `ClassificationAccuracy` restituisce un elenco di oggetti `EvalOutput` che contiene i punteggi di accuratezza della classificazione, precisione, richiamo e accuratezza bilanciata per ogni campione. Per ulteriori informazioni su questi punteggi, consulta la sezione **Classificazione** in [Utilizzo dei set di dati dei prompt e delle dimensioni di valutazione disponibili nei processi di valutazione del modello](clarify-foundation-model-evaluate-overview.md). Per eseguire l’algoritmo di accuratezza della classificazione, crea un’istanza di `ClassificationAccuracyConfig` e passa una strategia di calcolo della media a `multiclass_average_strategy`. Puoi scegliere `micro`, `macro`, `samples`, `weighted` o `binary`. Il valore predefinito è `micro`. Quindi, passa a valid\$1labels un elenco che contiene i nomi delle colonne con le etichette true per le tue categorie di classificazione. Infine, chiama il metodo `evaluate` e passa i parametri desiderati come mostrato nell’esempio di codice seguente: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.classification_accuracy import ClassificationAccuracy, ClassificationAccuracyConfig eval_algo = ClassificationAccuracy(ClassificationAccuracyConfig(multiclass_average_strategy="samples",valid_labels=["animal_type","plant_type","fungi_type"])) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` ### Conoscenze fattuali Puoi eseguire l’algoritmo di conoscenze fattuali per la generazione aperta. Per eseguire l’algoritmo di conoscenze fattuali, crea un’istanza di `FactualKnowledgeConfig` e, facoltativamente, passa una stringa delimitatore (`` per impostazione predefinita). L’algoritmo di conoscenze fattuali confronta la risposta generata dal modello con una risposta nota. L’algoritmo valuta la risposta come corretta se genera uno qualsiasi dei contenuti separati dal delimitatore nella risposta. Se passi `None` come `target_output_delimiter`, il modello deve generare la stessa risposta della domanda per essere valutato come corretto. Infine, chiama il metodo `evaluate` e passa i parametri desiderati. Le conoscenze fattuali restituiscono un elenco di oggetti `EvalScore`. Questi contengono punteggi aggregati sulla capacità del modello di codificare le conoscenze fattuali, come descritto nella sezione **Panoramica sulla valutazione del modello di fondazione**. I punteggi variano tra `0` e `1`, con il punteggio più basso che corrisponde a una minore conoscenza dei fatti del mondo reale. Il codice di esempio seguente mostra come valutare il tuo LLM utilizzando l’algoritmo di conoscenze fattuali: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.factual_knowledge import FactualKnowledge, FactualKnowledgeConfig eval_algo = FactualKnowledge(FactualKnowledgeConfig()) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` ### Stereotipizzazione dei prompt Puoi eseguire l’algoritmo di stereotipizzazione dei prompt per la generazione aperta. Per eseguire l’algoritmo di stereotipizzazione dei prompt, `DataConfig` deve identificare le colonne nel set di dati di input che contengono una frase meno stereotipata in `sent_less_input_location` e una frase più stereotipata in `sent_more_output_location`. Per ulteriori informazioni su `DataConfig`, consulta la sezione precedente **2. Configurazione`ModelRunner`**. Quindi, chiama il metodo `evaluate` e passa i parametri desiderati. La stereotipizzazione dei prompt restituisce un elenco di oggetti `EvalOutput` che contiene un punteggio per ogni record di input e punteggi complessivi per ogni tipo di bias. I punteggi vengono calcolati confrontando la probabilità associata alle frasi più e meno stereotipate. Il punteggio complessivo indica la frequenza con cui il modello ha preferito la frase stereotipata, in quanto il modello assegna una probabilità maggiore alla frase più stereotipata rispetto a quella meno stereotipata. Un punteggio di `0.5` indica che il modello è imparziale o che sceglie con la stessa frequenza frasi più e meno stereotipate. Un punteggio superiore a `0.5` indica che è probabile che il modello generi una risposta più stereotipata. Un punteggio inferiore a `0.5` indica che è probabile che il modello generi una risposta meno stereotipata. Il codice di esempio seguente mostra come valutare il tuo LLM utilizzando l’algoritmo di stereotipizzazione dei prompt: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.prompt_stereotyping import PromptStereotyping eval_algo = PromptStereotyping() eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` ### Robustezza semantica È possibile eseguire un algoritmo di robustezza semantica per qualsiasi FMEval attività, tuttavia il modello deve essere deterministico. Un modello è deterministico quando genera sempre lo stesso output per lo stesso input. Per ottenerlo, imposta un seed casuale nel processo di decodifica. Gli algoritmi sono diversi per ogni attività, per adattarsi ai diversi problemi e tipi di input dei dati, come descritto di seguito: + Per la generazione aperta, la risposta alle domande o la classificazione delle attività, esegui l’algoritmo `GeneralSemanticRobustness` con un file `GeneralSemanticRobustnessConfig`. + Per la sintesi testuale, esegui l’algoritmo `SummarizationAccuracySemanticRobustness` con un file `SummarizationAccuracySemanticRobustnessConfig`. L’algoritmo `GeneralSemanticRobustness` restituisce un elenco di oggetti `EvalScore` che contiene la metrica di accuratezza con valori compresi tra `0` e `1`, che quantifica la differenza tra gli output del modello perturbati e imperturbati. Per eseguire l’algoritmo generale di robustezza semantica, crea un’istanza di `GeneralSemanticRobustnessConfig` e passa `perturbation_type`. Per `perturbation_type`, puoi scegliere una delle seguenti opzioni: + `Butterfinger`: una perturbazione che imita gli errori di ortografia scambiando i caratteri in base alla distanza sulla tastiera. Inserisci una probabilità che un determinato carattere sia perturbato. Butterfinger è il valore predefinito per `perturbation_type`. + `RandomUpperCase`: una perturbazione che trasforma una frazione di caratteri in maiuscolo. Inserisci un decimale da `0` a `1`. + `WhitespaceAddRemove`: la probabilità che un carattere di spazio vuoto venga aggiunto prima di un carattere non di spazio vuoto. Puoi anche specificare i parametri seguenti: + `num_perturbations`: il numero di perturbazioni da introdurre nel testo generato per ogni campione. Il valore predefinito è `5`. + `butter_finger_perturbation_prob`: la probabilità che un carattere sia perturbato. Usato solo quando `perturbation_type` è `Butterfinger`. Il valore predefinito è `0.1`. + `random_uppercase_corrupt_proportion`: la frazione di caratteri da convertire in lettere maiuscole. Usato solo quando `perturbation_type` è `RandomUpperCase`. Il valore predefinito è `0.1`. + `whitespace_add_prob`: dato uno spazio vuoto, la probabilità che venga rimosso da un campione. Usato solo quando `perturbation_type` è `WhitespaceAddRemove`. Il valore predefinito è `0.05`. + `whitespace_remove_prob`: dato uno spazio non vuoto, la probabilità che venga aggiunto uno spazio vuoto davanti ad esso. Usato solo quando `perturbation_type` è `WhitespaceAddRemove`. Il valore predefinito è `0.1`. Infine, chiama il metodo `evaluate` e passa i parametri desiderati come mostrato nell’esempio di codice seguente: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.general_semantic_robustness import GeneralSemanticRobustness, GeneralSemanticRobustnessConfig eval_algo = GeneralSemanticRobustness(GeneralSemanticRobustnessConfig(perturbation_type="RandomUpperCase",num_perturbations=2,random_uppercase_corrupt_proportion=0.3))) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` L’algoritmo `SummarizationAccuracySemanticRobustness` restituisce un elenco di oggetti `EvalScore` che contiene la differenza (o Delta) tra i valori [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) del confronto tra le sintesi generate e quelle di riferimento. Per ulteriori informazioni su questi punteggi, consulta la sezione **Sintesi testuale** in [Utilizzo dei set di dati dei prompt e delle dimensioni di valutazione disponibili nei processi di valutazione del modello](clarify-foundation-model-evaluate-overview.md). Per eseguire l’algoritmo di robustezza semantica della sintesi testuale, crea un’istanza di `SummarizationAccuracySemanticRobustnessConfig` e passa `perturbation_type`. Per `perturbation_type`, puoi scegliere una delle seguenti opzioni: + `Butterfinger`: una perturbazione che imita gli errori di ortografia scambiando i caratteri in base alla distanza sulla tastiera. Inserisce una probabilità che un determinato carattere sia disturbato. `Butterfinger` è il valore predefinito per `perturbation_type`. + `RandomUpperCase`: una perturbazione che trasforma una frazione di caratteri in maiuscolo. Inserisci un decimale da `0` a `1`. + `WhitespaceAddRemove`: immetti una probabilità a probabilità che un carattere di spazio vuoto venga aggiunto prima di un carattere non di spazio vuoto. Puoi anche specificare i parametri seguenti: + `num_perturbations`: il numero di perturbazioni da introdurre nel testo generato per ogni campione. Il valore predefinito è “`5`”. + `butter_finger_perturbation_prob`: la probabilità che un carattere sia perturbato. Usato solo quando `perturbation_type` è `Butterfinger`. Il valore predefinito è “`0.1`”. + `random_uppercase_corrupt_proportion`: la frazione di caratteri da convertire in lettere maiuscole. Usato solo quando `perturbation_type` è `RandomUpperCase`. Il valore predefinito è “`0.1`”. + `whitespace_add_prob`: dato uno spazio vuoto, la probabilità che venga rimosso da un campione. Usato solo quando `perturbation_type` è `WhitespaceAddRemove`. Il valore predefinito è “`0.05`”. + `whitespace_remove_prob`: dato uno spazio non vuoto, la probabilità che venga aggiunto uno spazio vuoto davanti ad esso. Utilizzato solo quando `perturbation_type` è `WhitespaceAddRemove`. L’impostazione predefinita è `0.1`. + `rouge_type`: metriche che confrontano le sintesi generate con le sintesi di riferimento. Specifica in `rouge_type` il tipo di metrica [https://en.wikipedia.org/wiki/ROUGE_(metric)](https://en.wikipedia.org/wiki/ROUGE_(metric)) da utilizzare nella valutazione. Puoi scegliere `rouge1`, `rouge2` o `rougeL`. ROUGE-1 confronta le sintesi generate con le sintesi di riferimento utilizzando unigrammi sovrapposti (sequenze di un solo elemento come “il”, “è”). ROUGE-2 confronta le sintesi generate e quelle di riferimento utilizzando bigrammi (gruppi di due sequenze come “il grande”, “è casa”). ROUGE-L confronta la sequenza più lunga di parole corrispondenti. Per ulteriori informazioni su ROUGE, consulta [ROUGE: A Package for Automatic Evaluation of Summaries](https://aclanthology.org/W04-1013.pdf). + Imposta `user_stemmer_for_rouge` su `True` o `False`. Uno stemmer rimuove gli affissi dalle parole prima di confrontarle. Ad esempio, uno stemmer rimuove gli affissi da “nuotando” e “nuotava”, trasformando entrambi in “nuotare” dopo lo stemming. + Imposta `model_type_for_bertscore` sul modello da utilizzare per calcolare [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore). Puoi scegliere [ROBERTA\$1MODEL](https://huggingface.co/docs/transformers/model_doc/roberta) o il più avanzato [MICROSOFT\$1DEBERTA\$1MODEL](https://github.com/microsoft/DeBERTa). Chiama il metodo `evaluate` e passa i parametri desiderati come mostrato nell’esempio di codice seguente: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.summarization_accuracy_semantic_robustness import SummarizationAccuracySemanticRobustness, SummarizationAccuracySemanticRobustnessConfig eval_algo = SummarizationAccuracySemanticRobustness(SummarizationAccuracySemanticRobustnessConfig(perturbation_type="Butterfinger",num_perturbations=3,butter_finger_perturbation_prob=0.2))) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` ### Tossicità Puoi eseguire un algoritmo di tossicità per la generazione aperta, la sintesi testuale o la risposta alle domande. Sono disponibili tre classi distinte a seconda dell’attività. + Per una generazione aperta, esegui l’algoritmo Tossicità con un file `ToxicityConfig`. + Per la sintesi, utilizza la classe `Summarization_Toxicity`. + Per le attività di risposta alle domande, utilizza la classe `QAToxicity`. L’algoritmo di tossicità restituisce un elenco di oggetti `EvalScore` (a seconda del rilevatore di tossicità) che contiene punteggi compresi tra `0` e `1`. Per eseguire l’algoritmo di tossicità, crea un’istanza di `ToxicityConfig` e passa un modello di tossicità da utilizzare per valutare il tuo modello in `model_type`. Puoi scegliere le opzioni seguenti per `model_type`: + [`detoxify` for UnitaryAI Detoxify-unbiased](https://github.com/unitaryai/detoxify), un classificatore di testo multi-etichetta addestrato su [Toxic Comment Classification Challenge](https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge) e [Jigsaw Unintended Bias in Toxicity Classification](https://www.kaggle.com/c/jigsaw-unintended-bias-in-toxicity-classification). Il modello fornisce `7` punteggi per le seguenti classi: tossicità, tossicità grave, oscenità, minacce, insulti, riferimenti sessuali espliciti e attacchi all’identità. Di seguito è riportato l’output di esempio del modello di eliminazione della tossicità: ``` EvalScore(name='toxicity', value=0.01936926692724228), EvalScore(name='severe_toxicity', value=3.3755677577573806e-06), EvalScore(name='obscene', value=0.00022437423467636108), EvalScore(name='identity_attack', value=0.0006707844440825284), EvalScore(name='insult', value=0.005559926386922598), EvalScore(name='threat', value=0.00016682750720065087), EvalScore(name='sexual_explicit', value=4.828436431125738e-05) ``` + [`toxigen` per Toxigen-Roberta, un classificatore di testo binario BERTa basato su Ro ottimizzato sul set di dati, che contiene frasi con tossicità](https://github.com/microsoft/TOXIGEN) sottile e implicita relative a gruppi minoritari. ToxiGen `13` Infine, chiama il metodo `evaluate` e passa i parametri desiderati come mostrato nell’esempio di codice seguente. ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.toxicity import Toxicity, ToxicityConfig eval_algo = Toxicity(ToxicityConfig(model_type="detoxify")) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ```