Personalizza il tuo flusso di lavoro utilizzando la libreria fmeval

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 di 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 model_name quando la classe viene istanziata. 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 di testo, consultate la Hugging Facedocumentazione per. GenerationConfig

2. Crea un metodo di previsione personalizzato ModelRunner e implementa. Il seguente esempio di codice mostra come creare una personalizzazione ModelRunner per un Hugging Face modello utilizzando 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 della classe Hugging Face Auto che viene specificato utilizzando il parametro model_name al momento della creazione dell'istanza.

   • Il tokenizer è impostato su una classe della libreria Hugging Facetokenizer che corrisponde al modello preaddestrato 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 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 di ritorno, consulta la documentazione per apply_chat_template. Hugging Face

     • 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 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 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 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 hai indirizzato l'LLM 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 asTrue, 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 della Hugging Face AutoConfig classe:

   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 di, scegline uno in under. Hugging Face pretrained_model_name_or_path from_pretrained AutoClass

   Infine, prova il tuo. ModelRunner 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()