Personalización de su flujo de trabajo mediante la biblioteca fmeval - Amazon SageMaker AI

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

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

Puede personalizar la evaluación de su modelo para incluir un modelo que no sea un modelo de Amazon Bedrock JumpStart o utilizar un flujo de trabajo personalizado para la evaluación. Si usa su propio modelo, debe crear un ModelRunner personalizado. Si utiliza su propio conjunto de datos para la evaluación, debe configurar un objeto DataConfig. En la siguiente sección, se muestra cómo formatear el conjunto de datos de entrada, personalizar un objeto DataConfig para usar el conjunto de datos personalizado y crear un ModelRunner personalizado.

Si desea usar su propio conjunto de datos para evaluar su modelo, debe usar un objeto DataConfig para especificar el dataset_name y el dataset_uri del conjunto de datos que desea evaluar. Si utiliza un conjunto de datos integrado, el objeto DataConfig ya está configurado como predeterminado para los algoritmos de evaluación.

Puede utilizar un conjunto de datos personalizado cada vez que utilice la función evaluate. Puede invocar a evaluate el número de veces que desee para usar el número de conjuntos de datos que quiera.

Configure un conjunto de datos personalizado con la solicitud de modelo especificada en la columna de preguntas y la respuesta objetivo especificada en la respuesta de la columna, de la siguiente manera:

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 clase DataConfig contiene los siguientes parámetros:

  • dataset_name: el nombre del conjunto de datos que desea utilizar para evaluar su LLM.

    dataset_uri: la ruta local o el identificador uniforme de recursos (URI) a la ubicación S3 de su conjunto de datos.

  • dataset_mime_type: el formato de datos de entrada que desea utilizar para evaluar su LLM. La FMEval biblioteca es compatible con ambosMIME_TYPE_JSON. MIME_TYPE_JSONLINES

  • model_input_location: (opcional) el nombre de la columna del conjunto de datos que contiene las entradas o peticiones del modelo que desea evaluar.

    Use un model_input_location que especifique el nombre de la columna. La columna debe contener los siguientes valores correspondientes a las siguientes tareas asociadas:

    • Para las evaluaciones de generación abierta, toxicidad y exactitud, especifique la columna que contiene la petición a la que debe responder el modelo.

    • Para una tarea de respuesta a preguntas, especifique la columna que contiene la pregunta para la que el modelo debe generar una respuesta.

    • Para una tarea de resumen de texto, especifique el nombre de la columna que contiene el texto que desea que resuma el modelo.

    • Para una tarea de clasificación, especifique el nombre de la columna que contiene el texto que desea que clasifique el modelo.

    • Para una evaluación del conocimiento fáctico, especifique el nombre de la columna que contiene la pregunta cuya respuesta desea que el modelo prediga.

    • Para las evaluaciones de solidez semántica, especifique el nombre de la columna que contiene la entrada que desea que altere el modelo.

    • Para realizar evaluaciones de estereotipado de peticiones, utilice sent_more_input_location y sent_less_input_location en lugar demodel_input_location, como se muestra en los siguientes parámetros.

  • model_output_location: (opcional) el nombre de la columna del conjunto de datos que contiene la salida pronosticada que desea comparar con la salida de referencia contenida en target_output_location. Si lo proporcionamodel_output_location, FMEval no enviará una solicitud de inferencia a su modelo. En su lugar, utiliza la salida contenida en la columna especificada para evaluar el modelo.

  • target_output_location: el nombre de la columna del conjunto de datos de referencia que contiene el valor real para compararlo con el valor pronosticado contenido en model_output_location. Solo es necesario para el conocimiento fáctico, la exactitud y la solidez semántica. Para el conocimiento fáctico, cada fila de esta columna debe contener todas las respuestas posibles separadas por un delimitador. Por ejemplo, si las respuestas a una pregunta son [“Reino Unido”,“Inglaterra”], la columna debe contener “Reino Unido<OR>Inglaterra”. La predicción del modelo es correcta si contiene alguna de las respuestas separadas por el delimitador.

  • category_location: el nombre de la columna que contiene el nombre de una categoría. Si proporciona un valor para category_location, las puntuaciones se agregan y se notifican para cada categoría.

  • sent_more_input_location: el nombre de la columna que contiene una petición con más sesgo. Solo es necesario para el estereotipado de peticiones. Evite los sesgos inconscientes. Para ver ejemplos de sesgos, consulte CrowS-Pairs dataset.

  • sent_less_input_location: el nombre de la columna que contiene una petición con menos sesgo. Solo es necesario para el estereotipado de peticiones. Evite los sesgos inconscientes. Para ver ejemplos de sesgos, consulte CrowS-Pairs dataset.

  • sent_more_output_location: (opcional) el nombre de la columna que contiene una probabilidad pronosticada de que la respuesta generada por el modelo contenga más sesgos. Este parámetro solo se usa en tareas de estereotipado de peticiones.

  • sent_less_output_location: (opcional) el nombre de la columna que contiene una probabilidad pronosticada de que la respuesta generada por el modelo contenga menos sesgos. Este parámetro solo se usa en tareas de estereotipado de peticiones.

Si quiere añadir un nuevo atributo que se corresponda a una columna del conjunto de datos a la clase DataConfig, debe añadir suffix _location al final del nombre del atributo.

Para evaluar un modelo personalizado, utilice una clase de datos base para configurar el modelo y crear un ModelRunner personalizado. A continuación, puede utilizar este ModelRunner para evaluar cualquier modelo de lenguaje. Siga estos pasos para definir una configuración de modelo, crear un ModelRunner personalizado y probarlo.

La interfaz ModelRunner tiene un método abstracto, tal como se indica a continuación:

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

Este método toma una petición como entrada de cadena y devuelve una tupla que contiene una respuesta de texto modelo y una probabilidad logarítmica de entrada. Cada ModelRunner debe implementar un método predict.

Creación de un ModelRunner personalizado

  1. Defina una configuración de modelo.

    El siguiente ejemplo de código muestra cómo aplicar un decorador dataclass a una clase HFModelConfig personalizada para poder definir una configuración de modelo para un modelo 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

    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 token devueltos por un LLM. 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 modelo gpt2 para un modelo GPT de 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 la Hugging Facedocumentación de GenerationConfig.

  2. Cree un ModelRunner personalizado e implemente un método de predicción. El siguiente ejemplo de código muestra cómo crear un ModelRunner personalizado para un modelo Hugging Face mediante la clase HFModelConfig 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 se establece en un modelo previamente entrenado de la Auto Class de Hugging Face que se especifica mediante el parámetro model_name en el momento de la creación de la instancia.

    • El tokenizador se establece en una clase desde la biblioteca de tokenizadores de Hugging Face que se corresponde 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ímbolos IDs, que son valores numéricos que representan un identificador específico (palabra, subpalabra o carácter), como entrada. El token IDs se devuelve como un objeto PyTorch tensor, según lo especificado en. return_tensors="pt" Para ver otros tipos de tensores de retorno, consulte la documentación de Hugging Face sobre apply_chat_template.

      • IDs Los tokens se envían a un dispositivo en el que se encuentra el modelo para que el modelo los pueda utilizar.

    • generations: una variable que contiene la respuesta generada por su LLM. 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 puede usar, consulte la Hugging Face documentación de 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 del IDs indicador de entrada que están contenidos eninput_ids["input_ids"][0].

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

      El método predict devuelve una advertencia si ha dirigido al LLM a remove_prompt_from_generated_text en su configuración, pero la respuesta generada no contiene la petición de entrada.

      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 previamente entrenado gpt2 de la clase AutoConfig de Hugging Face:

    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 quieres usar otro modelo previamente entrenadoHugging Face, elige uno de los pretrained_model_name_or_path siguientesfrom_pretrained. 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()