Personalizzazione del flusso di lavoro con la libreria fmeval - Amazon SageMaker AI

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.

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 eMIME_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 forniscimodel_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 “UK<OR>England”. 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.

  • 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.

  • 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.

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 AutoConfigper 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.

  2. 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_runner 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, specificato con il parametro model_name al momento della creazione dell’istanza.

    • Il tokenizer è impostato su una classe della libreria di tokenizer Hugging Face, 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_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.

    • 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.

  3. 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_config 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

    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()