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