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.
## Uso de un conjunto de datos de entrada 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 ambos`MIME_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 de`model_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 proporciona`model_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 UnidoInglaterra”. 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](https://paperswithcode.com/dataset/crows-pairs).
+ `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](https://paperswithcode.com/dataset/crows-pairs).
+ `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.
## Uso de un `ModelRunner` personalizado
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 [AutoConfig](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)para 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](https://huggingface.co/docs/transformers/v4.34.1/en/main_classes/text_generation#transformers.GenerationConfig).
1. 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\$1runner](https://github.com/aws/fmeval/tree/main/src/fmeval/model_runners) 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](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html) de Hugging Face que se especifica mediante el parámetro model\$1name 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](https://huggingface.co/docs/transformers/model_doc/auto#transformers.AutoTokenizer) 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\$1chat\$1template](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer.apply_chat_template).
+ IDs Los tokens se envían a un dispositivo en el que se encuentra el modelo para que el modelo pueda usarlos.
+ `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](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.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 del indicador de entrada incluidos en`input_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`.
1. 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\$1config 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` siguientes`from_pretrained`. [AutoClass](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)
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()
```