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à.
# Personalizzazione del flusso di lavoro con la libreria `fmeval`
Puoi personalizzare la valutazione del modello per consentire un modello diverso da un modello Amazon Bedrock JumpStart o utilizzare un flusso di lavoro personalizzato per la valutazione. Se utilizzi il tuo modello, devi creare un `ModelRunner` personalizzato. Se utilizzi il tuo set di dati per la valutazione, devi configurare un oggetto `DataConfig`. La sezione seguente mostra come formattare il set di dati di input, personalizzare un oggetto `DataConfig` per utilizzare tale set di dati e creare un `ModelRunner` personalizzato.
## Utilizzo di un set di dati di input personalizzato
Per valutare il modello con il tuo set di dati, devi utilizzare un oggetto `DataConfig` per specificare `dataset_name` e `dataset_uri` del set di dati da valutare. Se utilizzi un set di dati integrato, l’oggetto `DataConfig` è già configurato come predefinito per gli algoritmi di valutazione.
Puoi utilizzare un solo set di dati personalizzato ogni volta che utilizzi la funzione `evaluate`. Puoi invocare `evaluate` tutte le volte che vuoi per utilizzare il numero di set di dati desiderato.
Configura un set di dati personalizzato con la richiesta del modello specificata nella colonna della domanda e la risposta di destinazione specificata nella colonna della risposta, come descritto di seguito:
```
from fmeval.data_loaders.data_config import DataConfig
from fmeval.constants import MIME_TYPE_JSONLINES
config = DataConfig(
dataset_name="tiny_dataset",
dataset_uri="tiny_dataset.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
model_input_location="question",
target_output_location="answer",
)
```
La classe `DataConfig` contiene i parametri seguenti:
+ `dataset_name`: il nome del set di dati da utilizzare per valutare il tuo LLM.
`dataset_uri`: il percorso locale o l’URI (Uniform Resource Identifier) della posizione S3 del set di dati.
+ `dataset_mime_type`: il formato dei dati di input da utilizzare per valutare il tuo LLM. La FMEval libreria può supportare entrambi `MIME_TYPE_JSON` e`MIME_TYPE_JSONLINES`.
+ `model_input_location`: (facoltativo) il nome della colonna nel set di dati che contiene gli input o i prompt del modello da valutare.
Utilizza `model_input_location` per specificare il nome della colonna. La colonna deve contenere i valori seguenti, associati alle relative attività:
+ Per le valutazioni di **generazione aperta**, **tossicità** e **accuratezza**, specifica la colonna che contiene il **prompt** a cui il modello deve rispondere.
+ Per un’attività di **risposta alle domande**, specifica la colonna che contiene la **domanda** a cui il modello deve rispondere.
+ Per un’**attività di sintesi testuale**, specifica il nome della colonna che contiene il **testo** che il modello deve sintetizzare.
+ Per un’**attività di classificazione**, specifica il nome della colonna che contiene il **testo** che il modello deve classificare.
+ Per le valutazioni delle **conoscenze fattuali**, specifica il nome della colonna che contiene la **domanda** per la quale il modello deve prevedere la risposta.
+ Per le valutazioni di **robustezza semantica**, specifica il nome della colonna che contiene l’**input** da modificare nel modello.
+ Per le **valutazioni di stereotipizzazione dei prompt**, utilizza `sent_more_input_location` e ` sent_less_input_location` invece di `model_input_location`, come illustrato nei parametri seguenti.
+ `model_output_location`: (facoltativo) il nome della colonna del set di dati che contiene l’output previsto da confrontare con l’output di riferimento contenuto in `target_output_location`. Se fornisci`model_output_location`, FMEval non invierà una richiesta di inferenza al tuo modello. Utilizzerà invece l’output contenuto nella colonna specificata per valutare il modello.
+ `target_output_location`: il nome della colonna nel set di dati di riferimento che contiene il valore true da confrontare con il valore previsto contenuto in `model_output_location`. Richiesto solo per le conoscenze fattuali, l’accuratezza e la robustezza semantica. Per le conoscenze fattuali, ogni riga di questa colonna deve contenere tutte le possibili risposte separate da un delimitatore. Ad esempio, se le risposte a una domanda sono [“UK”, “England”], la colonna dovrebbe contenere “UKEngland”. La previsione tramite modello è corretta se contiene una delle risposte separate dal delimitatore.
+ `category_location`: il nome della colonna che contiene il nome di una categoria. Se fornisci un valore per `category_location`, i punteggi vengono aggregati e registrati per ogni categoria.
+ `sent_more_input_location`: il nome della colonna che contiene il prompt con più bias. Obbligatorio solo per la stereotipizzazione dei prompt. Evita i bias inconsci. Per esempi di bias, consulta il [set di dati CrowS-Pairs](https://paperswithcode.com/dataset/crows-pairs).
+ `sent_less_input_location`: il nome della colonna che contiene il prompt con meno bias. Obbligatorio solo per la stereotipizzazione dei prompt. Evita i bias inconsci. Per esempi di bias, consulta il [set di dati CrowS-Pairs](https://paperswithcode.com/dataset/crows-pairs).
+ `sent_more_output_location`: (facoltativo) il nome della colonna che contiene una probabilità prevista che la risposta generata dal modello contenga più bias. Questo parametro viene utilizzato solo nelle attività di stereotipizzazione dei prompt.
+ `sent_less_output_location`: (facoltativo) il nome della colonna che contiene una probabilità prevista che la risposta generata dal modello contenga meno bias. Questo parametro viene utilizzato solo nelle attività di stereotipizzazione dei prompt.
Per aggiungere alla `DataConfig` classe un nuovo attributo che corrisponde a una colonna del set di dati, è necessario aggiungere `suffix _location` alla fine del nome dell’attributo.
## Utilizzo di un `ModelRunner` personalizzato
Per valutare un modello personalizzato, utilizza una classe di dati di base per configurare il modello e creare un `ModelRunner` personalizzato. Quindi, puoi utilizzare `ModelRunner` per valutare qualsiasi modello linguistico. Utilizza la procedura seguente per definire una configurazione del modello, creare un `ModelRunner` personalizzato e testarlo.
L’interfaccia `ModelRunner` dispone di un metodo astratto come descritto di seguito:
```
def predict(self, prompt: str) → Tuple[Optional[str], Optional[float]]
```
Questo metodo accetta un prompt come input di stringa e restituisce una Tupla che contiene una risposta testuale del modello e una probabilità logaritmica di input. Ogni `ModelRunner` deve implementare un metodo `predict`.
**Creazione di un `ModelRunner` personalizzato**
1. Definisci una configurazione del modello.
L’esempio di codice seguente mostra come applicare un decoratore `dataclass` a una classe `HFModelConfig` personalizzata per definire una configurazione per un modello **Hugging Face**:
```
from dataclasses import dataclass
@dataclass
class HFModelConfig:
model_name: str
max_new_tokens: int
seed: int = 0
remove_prompt_from_generated_text: bool = True
```
Nell’esempio di codice precedente, si applica quanto segue:
+ Il parametro `max_new_tokens` viene utilizzato per contenere la lunghezza della risposta limitando il numero di token restituiti da un LLM. Il tipo di modello viene impostato passando un valore per `model_name` quando viene creata un’istanza della classe. In questo esempio, il nome del modello è impostato su `gpt2`, come mostrato alla fine di questa sezione. Il parametro `max_new_tokens` è un’opzione per configurare le strategie di generazione del testo utilizzando una configurazione del modello `gpt2` per un modello GPT OpenAI preaddestrato. Vedi [AutoConfig](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)per altri tipi di modelli.
+ Se il parametro `remove_prompt_from_generated_text` è impostato su `True`, la risposta generata non conterrà il prompt di origine inviato nella richiesta.
Per altri parametri di generazione del testo, consultate la [Hugging Facedocumentazione di GenerationConfig](https://huggingface.co/docs/transformers/v4.34.1/en/main_classes/text_generation#transformers.GenerationConfig).
1. Crea un `ModelRunner` personalizzato e implementa un metodo di previsione. L’esempio di codice seguente mostra come creare un `ModelRunner` personalizzato per un modello Hugging Face utilizzando la classe `HFModelConfig` creata nell’esempio di codice precedente.
```
from typing import Tuple, Optional
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from fmeval.model_runners.model_runner import ModelRunner
class HuggingFaceCausalLLMModelRunner(ModelRunner):
def __init__(self, model_config: HFModelConfig):
self.config = model_config
self.model = AutoModelForCausalLM.from_pretrained(self.config.model_name)
self.tokenizer = AutoTokenizer.from_pretrained(self.config.model_name)
def predict(self, prompt: str) -> Tuple[Optional[str], Optional[float]]:
input_ids = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
generations = self.model.generate(
**input_ids,
max_new_tokens=self.config.max_new_tokens,
pad_token_id=self.tokenizer.eos_token_id,
)
generation_contains_input = (
input_ids["input_ids"][0] == generations[0][: input_ids["input_ids"].shape[1]]
).all()
if self.config.remove_prompt_from_generated_text and not generation_contains_input:
warnings.warn(
"Your model does not return the prompt as part of its generations. "
"`remove_prompt_from_generated_text` does nothing."
)
if self.config.remove_prompt_from_generated_text and generation_contains_input:
output = self.tokenizer.batch_decode(generations[:, input_ids["input_ids"].shape[1] :])[0]
else:
output = self.tokenizer.batch_decode(generations, skip_special_tokens=True)[0]
with torch.inference_mode():
input_ids = self.tokenizer(self.tokenizer.bos_token + prompt, return_tensors="pt")["input_ids"]
model_output = self.model(input_ids, labels=input_ids)
probability = -model_output[0].item()
return output, probability
```
Il codice precedente utilizza una `HuggingFaceCausalLLMModelRunner` classe personalizzata che eredita le proprietà dalla FMEval `ModelRunner` classe. La classe personalizzata contiene un costruttore e una definizione per una funzione di previsione, che restituisce `Tuple`.
Per altri esempi di `ModelRunner`, consulta la sezione [model\$1runner](https://github.com/aws/fmeval/tree/main/src/fmeval/model_runners) della libreria `fmeval`.
Il costruttore `HuggingFaceCausalLLMModelRunner` contiene le seguenti definizioni:
+ La configurazione è impostata su `HFModelConfig`, definito all’inizio di questa sezione.
+ Il modello è impostato su un modello preaddestrato di Hugging Face [Auto Class](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html), specificato con il parametro model\$1name al momento della creazione dell’istanza.
+ Il tokenizer è impostato su una classe della [libreria di tokenizer Hugging Face](https://huggingface.co/docs/transformers/model_doc/auto#transformers.AutoTokenizer), che corrisponde al modello preaddestrato specificato da `model_name`.
Il metodo `predict` nella classe `HuggingFaceCausalLLMModelRunner` utilizza le definizioni seguenti:
+ `input_ids`: una variabile che contiene l’input per il modello. Il modello genera l’input come segue.
+ A `tokenizer` Converte la richiesta contenuta `prompt` in identificatori di token (). IDs Questi token IDs, che sono valori numerici che rappresentano un token specifico (parola, sottoparola o carattere), possono essere utilizzati direttamente dal modello come input. I token IDs vengono restituiti come oggetti PyTorch tensoriali, come specificato da. `return_tensors="pt"` Per altri tipi di tensori restituiti, consulta la documentazione di Hugging Face per [apply\$1chat\$1template](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer.apply_chat_template).
+ IDs I token vengono inviati a un dispositivo in cui si trova il modello in modo che possano essere utilizzati dal modello.
+ `generations`: una variabile che contiene la risposta generata dal tuo LLM. La funzione di generazione del modello utilizza i seguenti input per generare la risposta:
+ I valori `input_ids` della fase precedente.
+ Il parametro `max_new_tokens` specificato in `HFModelConfig`.
+ `pad_token_id` aggiunge un token di fine frase (eos) alla risposta. Per altri token che puoi usare, consulta la Hugging Face documentazione di [PreTrainedTokenizer](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer).
+ `generation_contains_input`: una variabile booleana che restituisce `True` quando la risposta generata include il prompt di input nella sua risposta, altrimenti restituisce `False`. Il valore restituito viene calcolato utilizzando un confronto a livello di elemento tra quanto segue.
+ Tutti i token IDs presenti nel prompt di input contenuti in. `input_ids["input_ids"][0]`
+ L’inizio del contenuto generato contenuto in `generations[0][: input_ids["input_ids"].shape[1]]`.
Il metodo `predict` restituisce un avviso se hai indirizzato l’LLM a `remove_prompt_from_generated_text` nella configurazione, ma la risposta generata non contiene il prompt di input.
L'output del `predict` metodo contiene una stringa restituita dal `batch_decode` metodo, che converte il token IDs restituito nella risposta in testo leggibile dall'uomo. Se hai specificato `remove_prompt_from_generated_text` come `True`, il prompt di input viene rimosso dal testo generato. Se hai specificato `remove_prompt_from_generated_text` come `False`, il testo generato verrà restituito senza i token speciali che hai incluso nel dizionario `special_token_dict`, come specificato da `skip_special_tokens=True`.
1. Testa `ModelRunner`. Invia una richiesta di esempio al tuo modello.
L’esempio seguente mostra come testare un modello con il modello preaddestrato `gpt2` della classe Hugging Face `AutoConfig`:
```
hf_config = HFModelConfig(model_name="gpt2", max_new_tokens=32)
model = HuggingFaceCausalLLMModelRunner(model_config=hf_config)
```
Nell’esempio di codice precedente, `model_name` specifica il nome del modello preaddestrato. Per la classe `HFModelConfig` viene creata un’istanza hf\$1config con un valore per il parametro `max_new_tokens`, che viene utilizzata per l’inizializzazione di `ModelRunner`.
Se desideri utilizzare un altro modello pre-addestrato diHugging Face, scegline uno `pretrained_model_name_or_path` in sotto. `from_pretrained` [AutoClass](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)
Infine, testa `ModelRunner`. Invia una richiesta di esempio al tuo modello come mostrato nell’esempio di codice seguente:
```
model_output = model.predict("London is the capital of?")[0]
print(model_output)
eval_algo.evaluate_sample()
```