Personalización de su flujo de trabajo mediante la biblioteca fmeval

Creación de un ModelRunner personalizado

1. Defina una configuración de modelo.

   El siguiente ejemplo de código muestra cómo aplicar un dataclass decorador a una HFModelConfig clase personalizada para poder definir una configuración de modelo para un Hugging Facemodelo:

   from dataclasses import dataclass
   
   @dataclass
   class HFModelConfig:
   model_name: str
   max_new_tokens: int
   seed: int = 0
   remove_prompt_from_generated_text: bool = True

   En el ejemplo de código anterior, se aplica lo siguiente:

   • El parámetro max_new_tokens se usa para limitar la longitud de la respuesta al limitar el número de fichas devueltas por unLLM. El tipo de modelo se establece pasando un valor para model_name cuando se crea una instancia de la clase. En este ejemplo, el nombre del modelo se establece en gpt2, como se muestra al final de esta sección. El parámetro max_new_tokens es una opción para configurar estrategias de generación de texto mediante una configuración de gpt2 modelo para un modelo GPT OpenAI previamente entrenado. Consulte AutoConfigpara ver otros tipos de modelos.

   • Si el parámetro remove_prompt_from_generated_text está establecido en True, la respuesta generada no contendrá la petición original enviada en la solicitud.

   Para ver otros parámetros de generación de texto, consulte Hugging Face documentación para GenerationConfig.

2. Cree un ModelRunner personalizado e implemente un método de predicción. El siguiente ejemplo de código muestra cómo crear una personalización ModelRunner para un Hugging Face modele utilizando la HFModelConfig clase creada en el ejemplo de código anterior.

   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

   El código anterior usa una HuggingFaceCausalLLMModelRunner clase personalizada que hereda las propiedades de la FMEval ModelRunner clase. La clase personalizada contiene un constructor y una definición para una función de predicción, que devuelve un Tuple.

   Para ver más ejemplos de ModelRunner, consulte la sección model_runner de la biblioteca fmeval.

   El constructor HuggingFaceCausalLLMModelRunner contiene las siguientes definiciones:

   • La configuración se establece en HFModelConfig, como se define al principio de esta sección.

   • El modelo está configurado como un modelo previamente entrenado del Hugging Face Clase automática que se especifica mediante el parámetro model_name en el momento de la instanciación.

   • El tokenizador se establece en una clase de Hugging Face biblioteca de tokenizadores que coincide con el modelo previamente entrenado especificado por. model_name

   El método predict de la clase HuggingFaceCausalLLMModelRunner utiliza las siguientes definiciones:

   • input_ids: una variable que contiene entradas para su modelo. El modelo genera la entrada de la siguiente manera.

     • A tokenizer Convierte la solicitud contenida en prompt en identificadores de token (). IDs El modelo puede utilizar directamente estos símbolosIDs, que son valores numéricos que representan un identificador específico (palabra, subpalabra o carácter), como entrada. Los símbolos IDs se devuelven como PyTorch objetos tensoriales, según lo especificado porreturn_tensors="pt". Para ver otros tipos de tensores de retorno, consulte la Hugging Face documentación de apply_chat_template.

     • IDsLos tokens se envían a un dispositivo en el que se encuentra el modelo para que el modelo pueda utilizarlos.

   • generations— Una variable que contiene la respuesta generada por tuLLM. La función de generación del modelo utiliza las siguientes entradas para generar la respuesta:

     • El input_ids del paso anterior.

     • El parámetro max_new_tokens especificado en HFModelConfig.

     • Un pad_token_id añade un token de fin de oración (eos) a la respuesta. Para ver otros tokens que puedes usar, consulta la Hugging Face documentación para PreTrainedTokenizer.

   • generation_contains_input: una variable booleana que devuelve True cuando la respuesta generada incluye la petición de entrada en su respuesta y False en caso contrario. El valor devuelto se calcula mediante una comparación basada elementos entre lo siguiente.

     • Todos los símbolos IDs de la solicitud de entrada incluidos eninput_ids["input_ids"][0].

     • El principio del contenido generado que está contenido en generations[0][: input_ids["input_ids"].shape[1]].

     El predict método devuelve una advertencia si lo has indicado remove_prompt_from_generated_text en tu configuración, pero la respuesta generada no contiene el mensaje de entrada. LLM

     El resultado del predict método contiene una cadena devuelta por el batch_decode método, que convierte el token IDs devuelto en la respuesta en texto legible por humanos. Si especificó remove_prompt_from_generated_text como True, la petición de entrada se eliminará del texto generado. Si especificó remove_prompt_from_generated_text como False, el texto generado se devolverá sin ningún token especial que haya incluido en el diccionario special_token_dict, tal y como se especifica en skip_special_tokens=True.

3. Pruebe su ModelRunner. Envíe una solicitud de ejemplo a su modelo.

   El siguiente ejemplo muestra cómo probar un modelo utilizando el modelo gpt2 previamente entrenado del Hugging Face AutoConfigclase:

   hf_config = HFModelConfig(model_name="gpt2", max_new_tokens=32)
   model = HuggingFaceCausalLLMModelRunner(model_config=hf_config)

   En el ejemplo de código anterior, model_name especifica el nombre del modelo previamente entrenado. La clase HFModelConfig se instancia como hf_config con un valor para el parámetro max_new_tokens y se usa para inicializar ModelRunner.

   Si desea utilizar otro modelo previamente entrenado de Hugging Face, selecciona uno pretrained_model_name_or_path en la parte from_pretrained inferior AutoClass.

   Por último, pruebe su ModelRunner. Envíe una solicitud de ejemplo a su modelo tal y como se muestra en el siguiente ejemplo de código:

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