Personalice su flujo de trabajo mediante la biblioteca fmeval - Amazon SageMaker

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.

Personalice 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 uno personalizadoModelRunner. Si utiliza su propio conjunto de datos para la evaluación, debe configurar un DataConfig objeto. En la siguiente sección, se muestra cómo formatear el conjunto de datos de entrada, personalizar un DataConfig objeto para usar el conjunto de datos personalizado y crear uno personalizadoModelRunner.

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

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

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

  • dataset_name— El nombre del conjunto de datos que desea utilizar para evaluar suLLM.

    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 los datos de entrada que desea utilizar para evaluar suLLM. La FMEval biblioteca puede admitir MIME_TYPE_JSON tanto comoMIME_TYPE_JSONLINES.

  • model_input_location— (Opcional) El nombre de la columna del conjunto de datos que contiene las entradas o solicitudes del modelo que desea evaluar.

    Usa uno 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 abiertas de generación, toxicidad y precisión, especifique la columna que contiene la pregunta a la que debe responder el modelo.

    • Para una tarea de respuesta a una pregunta, 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 rápidas de los estereotipos, 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 prevista que desea comparar con la salida de referencia que contiene. target_output_location Si lo proporcionamodel_output_location, FMEval no se enviará ninguna solicitud de inferencia a su modelo. En su lugar, utiliza el resultado contenido 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 previsto que contienemodel_output_location. Necesario únicamente para el conocimiento de los hechos, la precisión y la solidez semántica. Para tener un 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 paracategory_location, las puntuaciones se agregan y se registran para cada categoría.

  • sent_more_input_location— El nombre de la columna que contiene un mensaje con más sesgo. Necesario solo para la creación rápida de estereotipos. Evita los prejuicios inconscientes. Para ver ejemplos de sesgo, consulta el conjunto de datos Crows-pairs.

  • sent_less_input_location— El nombre de la columna que contiene un mensaje con menos sesgo. Necesario únicamente para la creación rápida de estereotipos. Evita los prejuicios inconscientes. Para ver ejemplos de sesgo, consulta el conjunto de datos Crows-pairs.

  • sent_more_output_location— (Opcional) El nombre de la columna que contiene una probabilidad prevista de que la respuesta generada por el modelo contenga más sesgos. Este parámetro solo se usa en tareas rápidas de creación de estereotipos.

  • sent_less_output_location— (Opcional) El nombre de la columna que contiene la probabilidad prevista de que la respuesta generada por el modelo contenga menos sesgos. Este parámetro solo se usa en tareas rápidas de creación de estereotipos.

Si desea añadir a la DataConfig clase un nuevo atributo que corresponda a una columna de conjunto de datos, debe añadirlo 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 uno personalizadoModelRunner. A continuación, puede utilizarla ModelRunner para evaluar cualquier modelo de lenguaje. Siga los siguientes pasos para definir una configuración de modelo, crear una personalizada ModelRunner y probarla.

La ModelRunner interfaz 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 solicitud como entrada de cadena y devuelve una tupla que contiene una respuesta de texto modelo y una probabilidad logarítmica de entrada. Todos ModelRunner deben implementar un predict método.

Crea un personalizado ModelRunner

  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 cree una instancia de la clase. En este ejemplo, el nombre del modelo se establece engpt2, 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 enTrue, la respuesta generada no contendrá el mensaje original enviado en la solicitud.

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

  2. Cree un método de predicción personalizado ModelRunner e impleméntelo. En el siguiente ejemplo de código se 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 unTuple.

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

    El HuggingFaceCausalLLMModelRunner constructor contiene las siguientes definiciones:

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

    • El modelo se establece en un modelo previamente entrenado a partir 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 predict método de la HuggingFaceCausalLLMModelRunner clase utiliza las siguientes definiciones:

    • input_ids— Variable que contiene entradas para el modelo. El modelo genera la entrada de la siguiente manera.

      • A tokenizer Convierte la solicitud contenida en él 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:

      • La input_ids del paso anterior.

      • El parámetro max_new_tokens especificado enHFModelConfig.

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

    • generation_contains_input— Variable booleana que True se devuelve cuando la respuesta generada incluye la solicitud de entrada en su respuesta, o en caso contrario. False El valor devuelto se calcula mediante una comparación por elementos entre los siguientes elementos.

      • Todos los símbolos de IDs la solicitud de entrada que están contenidos en. input_ids["input_ids"][0]

      • El principio del contenido generado que se incluye engenerations[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 comoTrue, la solicitud de entrada se eliminará del texto generado. Si especificó remove_prompt_from_generated_text comoFalse, el texto generado se devolverá sin ningún elemento especial que haya incluido en el diccionariospecial_token_dict, tal y como se especifica enskip_special_tokens=True.

  3. Pon a prueba tuModelRunner. Envíe una solicitud de muestra 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 HFModelConfig clase se crea 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, prueba tuModelRunner. Envía una solicitud de muestra a tu modelo 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()