Personalizza il tuo flusso di lavoro utilizzando 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 crearne uno personalizzatoModelRunner. Se si utilizza il proprio set di dati per la valutazione, è necessario configurare un DataConfig oggetto. La sezione seguente mostra come formattare il set di dati di input, personalizzare un DataConfig oggetto per utilizzare il set di dati personalizzato e crearne uno personalizzato. ModelRunner

Usa un set di dati di input personalizzato

Se si desidera utilizzare il proprio set di dati per valutare il modello, è necessario utilizzare un DataConfig oggetto per specificare i dataset_name e il set dataset_uri di dati che si desidera valutare. Se si utilizza un set di dati integrato, l'DataConfigoggetto è già configurato come predefinito per gli algoritmi di valutazione.

È possibile utilizzare un set di dati personalizzato ogni volta che si utilizza la funzione. evaluate Puoi richiamare evaluate qualsiasi numero di volte per utilizzare il numero di set di dati che desideri.

Configura un set di dati personalizzato con la richiesta del modello specificata nella colonna della domanda e la risposta di destinazione specificata nella risposta della colonna, come segue:

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 DataConfig classe contiene i seguenti parametri:

• dataset_name— Il nome del set di dati che desideri utilizzare per valutare il tuoLLM.

  dataset_uri— Il percorso locale o l'identificatore uniforme di risorsa (URI) verso la posizione S3 del set di dati.

• dataset_mime_type— Il formato dei dati di input che desideri utilizzare per valutare i tuoi. LLM La FMEval libreria può supportare MIME_TYPE_JSON siaMIME_TYPE_JSONLINES.

• model_input_location— (Facoltativo) Il nome della colonna del set di dati che contiene gli input o i prompt del modello da valutare.

  Utilizzate un model_input_location che specifichi il nome della colonna. La colonna deve contenere i seguenti valori corrispondenti alle seguenti attività associate:

  • Per le valutazioni aperte di generazione, tossicità e precisione, specificate la colonna che contiene il prompt a cui il modello deve rispondere.

  • Per un'attività di risposta a domande, specificate la colonna che contiene la domanda a cui il modello deve generare una risposta.

  • Per un'attività di riepilogo del testo, specificate il nome della colonna che contiene il testo che desiderate riepilogare dal modello.

  • Per un'attività di classificazione, specificate il nome della colonna che contiene il testo che desiderate classificare dal modello.

  • Per una valutazione fattuale delle conoscenze, specificate il nome della colonna che contiene la domanda a cui desiderate che il modello preveda la risposta.

  • Per le valutazioni della robustezza semantica, specificate il nome della colonna che contiene l'input che desiderate modificare nel modello.

  • Per valutazioni rapide degli stereotipi, utilizzate sent_more_input_location and sent_less_input_location invece di, come illustrato nei parametri seguenti. model_input_location

• model_output_location— (Facoltativo) Il nome della colonna del set di dati che contiene l'output previsto da confrontare con l'output di riferimento in cui è contenuto. target_output_location Se lo forniscimodel_output_location, FMEval non invierà una richiesta di inferenza al tuo modello. Utilizza 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 reale da confrontare con il valore previsto contenuto in. model_output_location Richiesto solo per la conoscenza dei fatti, l'accuratezza e la solidità semantica. Per una conoscenza fattuale, ogni riga di questa colonna deve contenere tutte le possibili risposte separate da un delimitatore. <OR>Ad esempio, se le risposte a una domanda sono [«UK», «England»], la colonna dovrebbe contenere «UK England». La previsione del 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 percategory_location, i punteggi vengono aggregati e riportati per ogni categoria.

• sent_more_input_location— Il nome della colonna che contiene un prompt con maggiori distorsioni. Obbligatorio solo per stereotipi rapidi. Evita i pregiudizi inconsci. Per esempi di pregiudizi, consulta il set di dati Crows-pairs.

• sent_less_input_location— Il nome della colonna che contiene un prompt con meno distorsioni. Obbligatorio solo per stereotipi rapidi. Evita i pregiudizi inconsci. Per esempi di pregiudizi, consulta il set di dati Crows-pairs.

• sent_more_output_location— (Facoltativo) Il nome della colonna che contiene una probabilità prevista che la risposta generata dal modello contenga ulteriori distorsioni. Questo parametro viene utilizzato solo nelle attività di stereotipizzazione rapida.

• sent_less_output_location— (Facoltativo) Il nome della colonna che contiene una probabilità prevista che la risposta generata dal modello contenga meno distorsioni. Questo parametro viene utilizzato solo nelle attività di stereotipizzazione rapida.

Se si desidera aggiungere alla DataConfig classe un nuovo attributo che corrisponde a una colonna del set di dati, è necessario aggiungerlo alla fine del suffix _location nome dell'attributo.

Usa un valore personalizzato ModelRunner

Per valutare un modello personalizzato, utilizzate una classe di dati di base per configurare il modello e crearne uno personalizzatoModelRunner. Quindi, puoi usarlo ModelRunner per valutare qualsiasi modello linguistico. Utilizzate i seguenti passaggi per definire una configurazione del modello, crearne una personalizzata ModelRunner e testarla.

L'ModelRunnerinterfaccia ha un metodo astratto come segue:

def predict(self, prompt: str) → Tuple[Optional[str], Optional[float]]

Questo metodo accetta un prompt come input di stringa e restituisce una Tuple contenente una risposta testuale del modello e una probabilità di log di input. Ognuno ModelRunner deve implementare un predict metodo.

Crea un file personalizzato ModelRunner

1. Definire una configurazione del modello.

   Il seguente esempio di codice mostra come applicare un dataclass decoratore a una HFModelConfig classe personalizzata in modo da poter definire una configurazione del modello per un Hugging Facemodello:

   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 limitare la lunghezza della risposta limitando il numero di token restituiti da un. LLM Il tipo di modello viene impostato passando un valore per il momento in model_name cui viene istanziata la classe. In questo esempio, il nome del modello è impostato sugpt2, 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 gpt2 del modello per un modello GPT OpenAI pre-addestrato. Vedi AutoConfigper altri tipi di modelli.

   • Se il parametro remove_prompt_from_generated_text è impostato suTrue, la risposta generata non conterrà il prompt di origine inviato nella richiesta.

   Per altri parametri di generazione del testo, consulta il Hugging Face documentazione per GenerationConfig.

2. Crea un metodo personalizzato ModelRunner e implementa un metodo di previsione. Il seguente esempio di codice mostra come creare un oggetto personalizzato ModelRunner per un Hugging Face modello che utilizza la HFModelConfig classe 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 un. Tuple

   Per altri ModelRunner esempi, consultate la sezione model_runner della libreria. fmeval

   Il HuggingFaceCausalLLMModelRunner costruttore contiene le seguenti definizioni:

   • La configurazione è impostata suHFModelConfig, definita all'inizio di questa sezione.

   • Il modello è impostato su un modello pre-addestrato dal Hugging Face Classe automatica che viene specificata utilizzando il parametro model_name al momento dell'istanziazione.

   • Il tokenizer è impostato su una classe del Hugging Face libreria tokenizer che corrisponde al modello pre-addestrato specificato da. model_name

   Il predict metodo della HuggingFaceCausalLLMModelRunner classe utilizza le seguenti definizioni:

   • 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 tokenIDs, 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 PyTorch oggetti tensoriali, come specificato da. return_tensors="pt" Per altri tipi di tensori di ritorno, vedi Hugging Face documentazione per apply_chat_template.

     • IDsI 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 tuoLLM. La funzione generate del modello utilizza i seguenti input per generare la risposta:

     • Il input_ids passaggio precedente.

     • Il parametro max_new_tokens specificato inHFModelConfig.

     • A pad_token_id aggiunge un token di fine frase (eos) alla risposta. Per altri token che puoi usare, consulta il Hugging Face documentazione per PreTrainedTokenizer.

   • generation_contains_input— Una variabile booleana che restituisce True quando la risposta generata include il prompt di input nella sua risposta e in altro modo. False Il valore restituito viene calcolato utilizzando un confronto per elemento tra i seguenti elementi.

     • Tutti i token del prompt di input contenuti IDs in. input_ids["input_ids"][0]

     • L'inizio del contenuto generato contenuto ingenerations[0][: input_ids["input_ids"].shape[1]].

     Il predict metodo restituisce un avviso se l'hai indirizzato 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 è remove_prompt_from_generated_text stato specificato comeTrue, il prompt di input viene rimosso dal testo generato. Se hai specificato remove_prompt_from_generated_text comeFalse, il testo generato verrà restituito senza i token speciali che hai incluso nel dizionariospecial_token_dict, come specificato da. skip_special_tokens=True

3. Metti alla prova il tuo. ModelRunner Invia una richiesta di campione al tuo modello.

   L'esempio seguente mostra come testare un modello utilizzando il modello gpt2 pre-addestrato di Hugging Face AutoConfigclasse:

   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 pre-addestrato. La HFModelConfig classe viene istanziata come hf_config con un valore per il parametro e utilizzata per l'inizializzazione. max_new_tokens ModelRunner

   Se desideri utilizzare un altro modello pre-addestrato da Hugging Face, scegline uno pretrained_model_name_or_path from_pretrained in AutoClassbasso.

   Infine, prova il tuoModelRunner. Invia una richiesta di esempio al tuo modello come mostrato nel seguente esempio di codice:

   model_output = model.predict("London is the capital of?")[0]
   print(model_output)
   eval_algo.evaluate_sample()