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. # Uso de la biblioteca `fmeval` para ejecutar una evaluación automática El uso de la biblioteca `fmeval` en su propio código le da la mayor flexibilidad para personalizar su flujo de trabajo. Puede usar la biblioteca `fmeval` para evaluar cualquier LLM y también para tener más flexibilidad con sus conjuntos de datos de entrada personalizados. Los pasos siguientes muestran cómo configurar su entorno y cómo ejecutar un flujo de trabajo inicial y uno personalizado mediante la biblioteca `fmeval`. ## Introducción al uso de la biblioteca `fmeval` Puede configurar la evaluación del modelo fundacional y personalizarla para su caso de uso en un cuaderno de Studio. Su configuración depende tanto del tipo de tarea para la que se creó su modelo básico como de cómo desee evaluarla. FMEval admite tareas abiertas de generación, resumen de textos, respuesta a preguntas y clasificación. Los pasos de esta sección muestran cómo configurar un flujo de trabajo inicial. Este flujo de trabajo inicial incluye la configuración del entorno y la ejecución de un algoritmo de evaluación mediante un modelo básico de Amazon Bedrock JumpStart o uno con conjuntos de datos integrados. Si debe utilizar un flujo de trabajo y un conjunto de datos de entrada personalizados para un caso de uso más específico, consulte [Personalización de su flujo de trabajo mediante la biblioteca `fmeval`](clarify-foundation-model-evaluate-auto-lib-custom.md). ## Configure su entorno Si no quiere realizar una evaluación del modelo en un cuaderno de Studio, vaya al paso 11 de la sección **Introducción a Studio**. **Requisitos previos** + Para realizar una evaluación del modelo en una interfaz de usuario de Studio, su rol AWS Identity and Access Management (de IAM) y cualquier conjunto de datos de entrada deben tener los permisos correctos. Si no tiene un dominio de SageMaker IA o un rol de IAM, siga los pasos que se indican a continuación. [Guía para empezar a usar Amazon SageMaker AI](gs.md) **Configuración de permisos para su bucket de Amazon S3** Una vez creados el dominio y el rol, siga estos pasos para añadir los permisos necesarios para evaluar el modelo. 1. Abre la consola Amazon SageMaker AI en [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/). 1. En el panel de navegación, introduzca **S3** en la barra de búsqueda de la parte superior de la página. 1. Elija **S3** en **Servicios**. 1. En el panel de navegación, elija **Buckets**. 1. En la sección **Buckets de uso general**, en **Nombre**, elija el nombre del bucket de S3 que desee usar para almacenar la entrada y la salida del modelo en la consola. Si no dispone de un bucket de S3, haga lo siguiente: 1. Seleccione **Crear bucket** para abrir una nueva página **Crear bucket**. 1. En la sección **Configuración general**, en **Región de AWS **, seleccione la región de AWS en la que se encuentra el modelo fundacional. 1. Asigne un nombre a su bucket de S3 en el cuadro de entrada situado debajo de **Nombre del bucket**. 1. Acepte todas las opciones predeterminadas. 1. Seleccione **Crear bucket**. 1. En la sección **Buckets de uso general**, en **Nombre**, seleccione el nombre del bucket de S3 que ha creado. 1. Elija la pestaña **Permisos**. 1. Vaya a la sección **Uso compartido de recursos entre orígenes (CORS)** en la parte inferior de la ventana. Elija **Edit (Edición de)**. 1. Para añadir permisos a su bucket para las evaluaciones fundacionales, asegúrese de que aparezca el siguiente código en el recuadro de entrada. También puede copiar y pegar lo siguiente en el recuadro del editor. ``` [ { "AllowedHeaders": [ "*" ], "AllowedMethods": [ "GET", "PUT", "POST", "DELETE" ], "AllowedOrigins": [ "*" ], "ExposeHeaders": [ "Access-Control-Allow-Origin" ] } ] ``` 1. Seleccione **Save changes (Guardar cambios)**. **Adición de permisos a su política de IAM** 1. En la barra de búsqueda situada en la parte superior de la página, introduzca **IAM**. 1. En **Servicios**, seleccione **Identity and Access Management (IAM)**. 1. En el panel de navegación, elija **Políticas**. 1. [AmazonSageMakerFullAccess](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonSageMakerFullAccess)Introduce en la barra de búsqueda. Seleccione el botón de opción junto a la política que aparece. Ahora se puede seleccionar el botón **Acciones**. 1. Seleccione la flecha hacia abajo situada junto a **Acciones**. Aparecen dos opciones. 1. Elija **Adjuntar**. 1. En el listado de IAM que aparece, busque el nombre del rol que ha creado. Seleccione la casilla de verificación situada junto al nombre. 1. Elija **Asociar política**. **Introducción a Studio** 1. En la barra de búsqueda situada en la parte superior de la página, introduzca **SageMaker AI**. 1. En **Servicios**, selecciona **Amazon SageMaker AI**. 1. En el panel de navegación, seleccione **Studio**. 1. Elija su dominio en la sección **Introducción**, después de expandir la flecha hacia abajo situada debajo de **Seleccionar dominio**. 1. Elija su perfil de usuario en la sección **Introducción** después de expandir la flecha hacia abajo situada debajo de **Seleccionar perfil de usuario**. 1. Seleccione **Abrir Studio** para abrir la página de inicio de Studio. 1. Seleccione el explorador de archivos en el panel de navegación y vaya hasta el directorio raíz. 1. Seleccione **Crear cuaderno**. 1. En el cuadro de diálogo del entorno del cuaderno que se abre, seleccione la imagen **Data Science 3.0**. 1. Elija **Seleccionar**. 1. Instale el paquete `fmeval` en su entorno de desarrollo, tal y como se muestra en el siguiente ejemplo de código: ``` !pip install fmeval ``` **nota** Instale la biblioteca `fmeval` en un entorno que utilice Python 3.10. Para obtener más información sobre los requisitos necesarios para la ejecución de `fmeval`, consulte [`fmeval` dependencies](https://github.com/aws/fmeval/blob/main/pyproject.toml). ## Configurar `ModelRunner` FMEval utiliza un contenedor de alto nivel llamado `ModelRunner` para componer la entrada, invocar y extraer la salida de su modelo. El paquete `fmeval` puede evaluar cualquier LLM, sin embargo, el procedimiento para configurar `ModelRunner` depende del tipo de modelo que desee evaluar. En esta sección se explica cómo configurar `ModelRunner` un modelo JumpStart o Amazon Bedrock. Si desea utilizar un conjunto de datos de entrada personalizado y un `ModelRunner` personalizado, consulte [Personalización de su flujo de trabajo mediante la biblioteca `fmeval`](clarify-foundation-model-evaluate-auto-lib-custom.md). ### Utilice un modelo JumpStart Para usarlo `ModelRunner` para evaluar un JumpStart modelo, crear o proporcionar un punto final, defina el modelo y el conjunto de datos integrado, configúrelo y pruébelo`ModelRunner`. **Defina un JumpStart modelo y configure un ModelRunner** 1. Para proporcionar un punto de conexión, haga cualquiera de lo siguiente: + Especifique el [EndpointName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#API_runtime_InvokeEndpoint_RequestSyntax)para un JumpStart punto final existente`model_id`, el y`model_version`. + Especifique el `model_id` y `model_version` para su modelo y cree un JumpStart punto final. En el siguiente ejemplo de código se muestra cómo crear un punto final para un punto final [https://aws.amazon.com/blogs/machine-learning/llama-2-foundation-models-from-meta-are-now-available-in-amazon-sagemaker-jumpstart/](https://aws.amazon.com/blogs/machine-learning/llama-2-foundation-models-from-meta-are-now-available-in-amazon-sagemaker-jumpstart/)que esté disponible a través de él JumpStart. ``` import sagemaker from sagemaker.jumpstart.model import JumpStartModel #JumpStart model and version model_id, model_version = "meta-textgeneration-llama-2-7b-f", "*" my_model = JumpStartModel(model_id=model_id) predictor = my_model.deploy() endpoint_name = predictor.endpoint_name # Accept the EULA, and test the endpoint to make sure it can predict. predictor.predict({"inputs": [[{"role":"user", "content": "Hello how are you?"}]]}, custom_attributes='accept_eula=true') ``` El ejemplo de código anterior hace referencia a EULA, que significa end-use-license-agreement (EULA). El EULA se encuentra en la descripción de la tarjeta del modelo que está utilizando. Para utilizar algunos JumpStart modelos, debe especificarlos`accept_eula=true`, tal y como se muestra en la llamada anterior a. `predict` Para obtener más información sobre el EULA, consulte la sección **Licencias y orígenes de modelos** en [Fuentes de modelos y acuerdos de licencia](jumpstart-foundation-models-choose.md). Puede encontrar una lista de los JumpStart modelos disponibles en la [tabla de modelos preentrenados con algoritmos integrados](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html#built-in-algorithms-with-pre-trained-model-table). 1. Configure `ModelRunner` mediante el `JumpStartModelRunner`, tal y como se muestra en el siguiente ejemplo de configuración: ``` from fmeval.model_runners.sm_jumpstart_model_runner import JumpStartModelRunner js_model_runner = JumpStartModelRunner( endpoint_name=endpoint_name, model_id=model_id, model_version=model_version ) ``` En el ejemplo de configuración anterior, utilice los mismos valores para `endpoint_name`, `model_id` y `model_version` que utilizó para crear el punto de conexión. 1. Pruebe su `ModelRunner`. Envíe una solicitud de ejemplo a su modelo tal y como se muestra en el siguiente ejemplo de código: ``` js_model_runner.predict("What is the capital of London") ``` ### Uso de un modelo de Amazon Bedrock Para evaluar un modelo de Amazon Bedrock, debe definir el modelo y el conjunto de datos integrado, y configurar `ModelRunner`. **Defina un modelo de Amazon Bedrock y configure un ModelRunner** 1. Para definir e imprimir los detalles del modelo, utilice el siguiente ejemplo de código para un modelo de Titan que está disponible en Amazon Bedrock: ``` import boto3 import json bedrock = boto3.client(service_name='bedrock') bedrock_runtime = boto3.client(service_name='bedrock-runtime') model_id = "amazon.titan-tg1-large" accept = "application/json" content_type = "application/json" print(bedrock.get_foundation_model(modelIdentifier=modelId).get('modelDetails')) ``` En el ejemplo de código anterior, el parámetro `accept` especifica el formato de los datos que desea utilizar para evaluar su LLM. `contentType` especifica el formato de los datos de entrada de la solicitud. Solo se admite `MIME_TYPE_JSON` para `accept` y `contentType` en los modelos de Amazon Bedrock. Para obtener más información sobre estos parámetros, consulte [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html#API_runtime_InvokeModelWithResponseStream_RequestSyntax). 1. Para configurar `ModelRunner`, utilice el `BedrockModelRunner`, como se muestra en el siguiente ejemplo de configuración: ``` from fmeval.model_runners.bedrock_model_runner import BedrockModelRunner bedrock_model_runner = BedrockModelRunner( model_id=model_id, output='results[0].outputText', content_template='{"inputText": $prompt, "textGenerationConfig": \ {"maxTokenCount": 4096, "stopSequences": [], "temperature": 1.0, "topP": 1.0}}', ) ``` Parametrice la configuración de `ModelRunner` de la siguiente manera. + Utilice los mismos valores para `model_id` que utilizó para implementar el modelo. + Utilice `output` para especificar el formato de la respuesta de `json` generada. Por ejemplo, si su LLM proporcionó la respuesta `[{"results": "this is the output"}]`, `output='results[0].outputText'` devuelve `this is the output`. + Utilice `content_template` para especificar cómo interactúa su LLM con las solicitudes. La siguiente plantilla de configuración se incluye únicamente para explicar el ejemplo de configuración anterior y no es obligatoria. + En el ejemplo de configuración anterior, la variable `inputText` especifica la petición, que captura la solicitud realizada por el usuario. + La variable `textGenerationConfig` especifica cómo el LLM genera las respuestas de la siguiente manera: + El parámetro `maxTokenCount` se usa para limitar la longitud de la respuesta al limitar el número de token devueltos por el LLM. + El parámetro `stopSequences` se utiliza para especificar una lista de secuencias de caracteres que indican al LLM que deje de generar una respuesta. La salida del modelo se detiene la primera vez que se encuentra alguna de las cadenas de la lista en la salida. Por ejemplo, puede utilizar una secuencia de saltos de línea para limitar la respuesta del modelo a una sola línea. + El parámetro `topP` controla el grado de asignación al azar al limitar el conjunto de tokens que se deben tener en cuenta al generar el siguiente token. Este parámetro acepta valores comprendidos entre `0.0` y `1.0`. Los valores más altos de `topP` permiten un conjunto que contenga un vocabulario más amplio y los valores más bajos restringen el conjunto de token a palabras más probables. + El parámetro `temperature` controla el grado de asignación al azar del texto generado y acepta valores positivos. Los valores más altos de `temperature` indican al modelo que genere respuestas más aleatorias y diversas. Los valores más bajos generan respuestas más predecibles. Los rangos típicos de `temperature` se encuentran entre `0.2` y `2.0`. Para obtener más información sobre los parámetros de un modelo fundacional específico de Amazon Bedrock, consulte [Inference parameters for foundation models](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html#model-parameters-titan). El formato del parámetro content\$1template depende de las entradas y los parámetros admitidos por su LLM. Por ejemplo, el [modelo Anthropic’s Claude 2](https://www.anthropic.com/index/claude-2) puede admitir la siguiente `content_template`. ``` "content_template": "{\"prompt\": $prompt, \"max_tokens_to_sample\": 500}" ``` Como otro ejemplo, el [modelo Falcon 7b](https://huggingface.co/tiiuae/falcon-7b) puede admitir la `content_template` siguiente. ``` "content_template": "{\"inputs\": $prompt, \"parameters\":{\"max_new_tokens\": \ 10, \"top_p\": 0.9, \"temperature\": 0.8}}" ``` 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: ``` bedrock_model_runner.predict("What is the capital of London?") ``` ## Evaluar el modelo Después de configurar los datos y `ModelRunner`, puede ejecutar un algoritmo de evaluación de las respuestas generadas por su LLM. Para ver una lista de todos los algoritmos de evaluación disponibles, ejecute el siguiente código: ``` from fmeval.eval_algo_mapping import EVAL_ALGORITHMS print(EVAL_ALGORITHMS.keys()) ``` Cada algoritmo tiene una evaluación y un método `evaluate_sample`. El método `evaluate` calcula una puntuación para todo el conjunto de datos. El método `evaluate_sample` evalúa la puntuación de una sola instancia. El método `evaluate_sample` devuelve objetos `EvalScore`. Los objetos `EvalScore` contienen puntuaciones agregadas que indican el rendimiento del modelo durante la evaluación. El método `evaluate_sample` tiene los siguientes parámetros opcionales: + `model_output`: la respuesta del modelo para una sola solicitud. + `model_input`: una petición que contiene la solicitud a su modelo. + `target_output`: la respuesta esperada de la petición contenida en `model_input`. En el siguiente ejemplo de código se muestra cómo utilizar `evaluate_sample`: ``` #Evaluate your custom sample model_output = model_runner.predict("London is the capital of?")[0] eval_algo.evaluate_sample(target_output="UKEnglandUnited Kingdom", model_output=model_output) ``` El método `evaluate` tiene los siguientes parámetros opcionales: + `model`: una instancia de `ModelRunner` usando el modelo que se quiere evaluar. + `dataset_config`: la configuración del conjunto de datos. Si no se proporciona `dataset_config`, el modelo se evalúa con todos los conjuntos de datos integrados que están configurados para esta tarea. + `prompt_template`: una plantilla que se utiliza para generar peticiones. Si no se proporciona `prompt_template`, el modelo se evalúa mediante una plantilla de petición predeterminada. + `save`: si se establece en `True`, las respuestas y puntuaciones de peticiones basadas en registros se guardan en el archivo `EvalAlgorithmInterface.EVAL_RESULTS_PATH`. El valor predeterminado es `False`. + `num_records`: el número de registros que se muestrea aleatoriamente del conjunto de datos de entrada para su evaluación. El valor predeterminado es `300`. El algoritmo `evaluate` devuelve una lista de objetos `EvalOutput` que puede incluir lo siguiente: + `eval_name`: el nombre del algoritmo de evaluación. `dataset_name`: el nombre del conjunto de datos que utiliza el algoritmo de evaluación. `prompt_template`: una plantilla que se utiliza para redactar peticiones que se consumen si el parámetro `model_output` no se proporciona en el conjunto de datos. Para obtener más información, consulte `prompt_template` la ** JumpStart `ModelRunner`sección Configurar un**. `dataset_scores`: una puntuación agregada calculada en todo el conjunto de datos. `category_scores`: una lista de objetos `CategoryScore` que contienen las puntuaciones de cada categoría del conjunto de datos. `output_path`: la ruta local a la salida de la evaluación. Esta salida contiene respuestas a peticiones con puntuaciones de evaluación basadas en registros. `error`: un mensaje de error de cadena para un trabajo de evaluación fallido. Las siguientes dimensiones están disponibles para la evaluación del modelo. + Exactitud + Conocimiento fáctico + Estereotipado de peticiones + Solidez semántica + Toxicidad ### Exactitud Puede ejecutar un algoritmo de exactitud para una tarea de respuesta a preguntas, resumen de texto o clasificación. Los algoritmos son diferentes para cada tarea a fin de adaptarse a los diferentes tipos de entrada de datos y problemas de la siguiente manera: + Para las tareas de respuesta a preguntas, ejecute el algoritmo `QAAccuracy` con un archivo `QAAccuracyConfig`. + Para las tareas de resumen de texto, ejecute el algoritmo `SummarizationAccuracy` con un `SummarizationAccuracyConfig`. + Para las tareas de clasificación, ejecute el algoritmo `ClassificationAccuracy` con un `ClassificationAccuracyConfig`. El algoritmo `QAAccuracy` devuelve una lista de objetos `EvalOutput` que contiene una puntuación de exactitud para cada muestra. Para ejecutar el algoritmo de exactitud de respuestas a preguntas, cree una instancia de `QAAccuracygeConfig` y pase `` o `None` como el `target_output_delimiter`. El algoritmo de exactitud de respuestas a preguntas compara la respuesta que genera el modelo con una respuesta conocida. Si pasa `` como delimitador objetivo, el algoritmo califica la respuesta como correcta si genera cualquier parte del contenido separado por `` en la respuesta. Si pasa `None` una cadena vacía como `target_output_delimiter`, el código generará un error. Llama al método `evaluate` y pasa los parámetros que desee, tal y como se muestra en el siguiente ejemplo de código: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.qa_accuracy import QAAccuracy, QAAccuracyConfig eval_algo = QAAccuracy(QAAccuracyConfig(target_output_delimiter=""))) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` El algoritmo `SummarizationAccuracy` devuelve una lista de objetos `EvalOutput` que contienen puntuaciones para [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge), [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor) y [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore). Para obtener más información acerca de estas puntuaciones, consulte la sección Resumen de texto en [Uso de conjuntos de datos de peticiones y dimensiones de evaluación disponibles en trabajos de evaluación del modelo](clarify-foundation-model-evaluate-overview.md). Para ejecutar el algoritmo de exactitud del resumen de texto, cree una instancia de `SummarizationAccuracyConfig` y pase lo siguiente: + Especifique el tipo de métrica [https://en.wikipedia.org/wiki/ROUGE_(metric)](https://en.wikipedia.org/wiki/ROUGE_(metric)) que desea utilizar en la evaluación para `rouge_type`. Puede elegir `rouge1`, `rouge2`, o `rougeL`. Estas métricas comparan los resúmenes generados con los resúmenes de referencia. ROUGE-1 compara los resúmenes generados y los resúmenes de referencia mediante unigramas superpuestos (secuencias de un solo elemento, como “el” o “es”). ROUGE-2 compara los resúmenes generados y los de referencia mediante bigramas (grupos de dos secuencias, como “el grande”, “un hogar”). ROUGE-L compara la secuencia de palabras coincidente más larga. Para obtener más información sobre ROUGE, consulte [ROUGE: A Package for Automatic Evaluation of Summaries](https://aclanthology.org/W04-1013.pdf). + Establezca `use_stemmer_for_rouge` en `True` o `False`. Un lematizador elimina los afijos de las palabras antes de compararlas. Por ejemplo, un lematizador elimina los afijos de “anormal” y “normalizar” para que ambos sean “normal” después de la lematización. + Defina model\$1type\$1for\$1bertscore en el modelo que desee usar para calcular un [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore). Puede elegir [ROBERTA\$1MODEL](https://huggingface.co/docs/transformers/model_doc/roberta) o [MICROSOFT\$1DEBERTA\$1MODEL](https://github.com/microsoft/DeBERTa), que es más avanzado. Por último, llame al método `evaluate` y pase los parámetros que desee, tal y como se muestra en el siguiente ejemplo de código: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.summarization_accuracy import SummarizationAccuracy, SummarizationAccuracyConfig eval_algo = SummarizationAccuracy(SummarizationAccuracyConfig(rouge_type="rouge1",model_type_for_bertscore="MICROSOFT_DEBERTA_MODEL")) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` El algoritmo `ClassificationAccuracy` devuelve una lista de objetos `EvalOutput` que contiene las puntuaciones de exactitud, precisión, exhaustividad y exactitud equilibrada de la clasificación para cada muestra. Para obtener más información sobre estas puntuaciones, consulte la sección **Clasificación** en [Uso de conjuntos de datos de peticiones y dimensiones de evaluación disponibles en trabajos de evaluación del modelo](clarify-foundation-model-evaluate-overview.md). Para ejecutar el algoritmo de exactitud de la clasificación, cree una instancia de `ClassificationAccuracyConfig` y pase una estrategia de media a `multiclass_average_strategy`. Puede elegir `micro`, `macro`, `samples`, `weighted` o `binary`. El valor predeterminado es `micro`. A continuación, pase a valid\$1labels una lista con los nombres de las columnas que contienen las etiquetas verdaderas de sus categorías de clasificación. Por último, llame al método `evaluate` y pase los parámetros que desee, tal y como se muestra en el siguiente ejemplo de código: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.classification_accuracy import ClassificationAccuracy, ClassificationAccuracyConfig eval_algo = ClassificationAccuracy(ClassificationAccuracyConfig(multiclass_average_strategy="samples",valid_labels=["animal_type","plant_type","fungi_type"])) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` ### Conocimiento fáctico Puede ejecutar el algoritmo de conocimiento fáctico para una generación abierta. Para ejecutar el algoritmo de conocimiento fáctico, cree una instancia de `FactualKnowledgeConfig` y, si lo desea, pase una cadena delimitadora (de forma predeterminada es ``). El algoritmo de conocimiento fáctico compara la respuesta que genera el modelo con una respuesta conocida. El algoritmo califica la respuesta como correcta si genera cualquier parte del contenido separado por el delimitador en la respuesta. Si se pasa `None` como `target_output_delimiter`, el modelo debe generar la misma respuesta para que se califique como correcta. Por último, llame al método `evaluate` e introduzca los parámetros que desee. El conocimiento fáctico devuelve una lista de objetos `EvalScore`. Estos contienen puntuaciones agregadas sobre la capacidad de su modelo para codificar el conocimiento fáctico, tal y como se describe en la sección **Resumen de la evaluación del modelo fundacional**. Las puntuaciones oscilan entre `0` y `1`, siendo la puntuación más baja la que corresponde a un menor conocimiento de los hechos del mundo real. En el siguiente ejemplo de código, se muestra cómo evaluar su LLM mediante el algoritmo de conocimiento fáctico: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.factual_knowledge import FactualKnowledge, FactualKnowledgeConfig eval_algo = FactualKnowledge(FactualKnowledgeConfig()) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` ### Estereotipado de peticiones Puede ejecutar el algoritmo de estereotipado de peticiones para una generación abierta. Para ejecutar el algoritmo de estereotipado de peticiones, `DataConfig` debe identificar las columnas del conjunto de datos de entrada que contienen una oración menos estereotipada en `sent_less_input_location` y otra más estereotipada en `sent_more_output_location`. Para obtener más información sobre `DataConfig`, consulte la sección **2 anterior. Configure (Configuración)`ModelRunner`**. Luego, llame al método `evaluate` e introduzca los parámetros que desee. El estereotipado de peticiones devuelve una lista de objetos `EvalOutput` que contienen una puntuación para cada registro de entrada y puntuaciones generales para cada tipo de sesgo. Las puntuaciones se calculan comparando la probabilidad de las oraciones más y menos estereotipadas. La puntuación general indica la frecuencia con la que el modelo ha preferido la oración estereotipada, ya que el modelo asigna una mayor probabilidad a la oración más estereotipada en comparación con la menos estereotipada. Una puntuación de `0.5` indica que su modelo no tiene sesgos o que prefiere más y menos oraciones estereotipadas a partes iguales. Una puntuación superior a `0.5` indica que es probable que el modelo genere una respuesta más estereotipada. Las puntuaciones inferiores a `0.5` indican que es probable que el modelo genere una respuesta menos estereotipada. En el siguiente ejemplo de código, se muestra cómo evaluar su LLM mediante el algoritmo de estereotipado de peticiones: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.prompt_stereotyping import PromptStereotyping eval_algo = PromptStereotyping() eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` ### Solidez semántica Puede ejecutar un algoritmo de solidez semántica para cualquier FMEval tarea; sin embargo, su modelo debe ser determinista. Un modelo determinista es aquel que siempre genera la misma salida para la misma entrada. Por lo general, se puede lograr el determinismo estableciendo una semilla aleatoria en el proceso de decodificación. Los algoritmos son diferentes para cada tarea a fin de adaptarse a los diferentes tipos de entrada de datos y problemas de la siguiente manera: + Para la generación abierta, la respuesta a preguntas o la clasificación de tareas, ejecute el algoritmo `GeneralSemanticRobustness` con un archivo `GeneralSemanticRobustnessConfig`. + Para resumir el texto, ejecute el algoritmo `SummarizationAccuracySemanticRobustness` con un archivo `SummarizationAccuracySemanticRobustnessConfig`. El algoritmo `GeneralSemanticRobustness` devuelve una lista de objetos `EvalScore` que contienen exactitud, con valores comprendidos entre `0` y `1`, que cuantifican la diferencia entre las salidas del modelo alteradas y no alteradas. Para ejecutar el algoritmo de solidez semántica general, cree una instancia de `GeneralSemanticRobustnessConfig` y pase un `perturbation_type`. Puede elegir una de las siguientes opciones para `perturbation_type`: + `Butterfinger`: una alteración que imita los errores ortográficos mediante el intercambio de caracteres en función de la distancia del teclado. Introduzca la probabilidad de que un carácter determinado se altere. El valor predeterminado de `perturbation_type` es Butterfinger. + `RandomUpperCase`: una alteración que cambia una fracción de caracteres a mayúsculas. Introduzca un decimal de `0` a `1`. + `WhitespaceAddRemove`: la probabilidad de que se añada un carácter de espacio en blanco delante de un carácter que no sea un espacio en blanco. Puede especificar los siguientes parámetros: + `num_perturbations`: el número de alteraciones que debe introducir para cada muestra en el texto generado. El valor predeterminado es `5`. + `butter_finger_perturbation_prob`: la probabilidad de que un carácter se altere. Solo se usa cuando `perturbation_type` es `Butterfinger`. El valor predeterminado es `0.1`. + `random_uppercase_corrupt_proportion`: la fracción de caracteres que se va a cambiar a mayúsculas. Solo se usa cuando `perturbation_type` es `RandomUpperCase`. El valor predeterminado es `0.1`. + `whitespace_add_prob`: dado un espacio en blanco, la probabilidad de eliminarlo de una muestra. Solo se usa cuando `perturbation_type` es `WhitespaceAddRemove`. El valor predeterminado es `0.05`. + `whitespace_remove_prob`: dado un espacio no en blanco, la probabilidad de añadir un espacio en blanco delante de él. Solo se usa cuando `perturbation_type` es `WhitespaceAddRemove`. El valor predeterminado es `0.1`. Por último, llame al método `evaluate` y pase los parámetros que desee, tal y como se muestra en el siguiente ejemplo de código: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.general_semantic_robustness import GeneralSemanticRobustness, GeneralSemanticRobustnessConfig eval_algo = GeneralSemanticRobustness(GeneralSemanticRobustnessConfig(perturbation_type="RandomUpperCase",num_perturbations=2,random_uppercase_corrupt_proportion=0.3))) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` El algoritmo `SummarizationAccuracySemanticRobustness` devuelve una lista de objetos `EvalScore` que contienen la diferencia (o delta) entre los valores [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge), [https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor) y [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore) y entre los resúmenes generados y los de referencia. Para obtener más información acerca de estas puntuaciones, consulte la sección **Resumen de texto** en [Uso de conjuntos de datos de peticiones y dimensiones de evaluación disponibles en trabajos de evaluación del modelo](clarify-foundation-model-evaluate-overview.md). Para ejecutar el algoritmo de solidez semántica de resumen de texto, cree una instancia de `SummarizationAccuracySemanticRobustnessConfig` y pase un `perturbation_type`. Puede elegir una de las siguientes opciones para `perturbation_type`: + `Butterfinger`: una alteración que imita los errores ortográficos mediante el intercambio de caracteres en función de la distancia del teclado. Introduzca la probabilidad de que un carácter determinado se altere. `Butterfinger` es el valor predeterminado de `perturbation_type`. + `RandomUpperCase`: una alteración que cambia una fracción de caracteres a mayúsculas. Introduzca un decimal de `0` a `1`. + `WhitespaceAddRemove`: introduzca la probabilidad de que se añada un carácter de espacio en blanco delante de un carácter que no sea un espacio en blanco. Puede especificar los siguientes parámetros: + `num_perturbations`: el número de alteraciones que debe introducir para cada muestra en el texto generado. El valor predeterminado es `5`. + `butter_finger_perturbation_prob`: la probabilidad de que un carácter se altere. Solo se usa cuando `perturbation_type` es `Butterfinger`. El valor predeterminado es `0.1`. + `random_uppercase_corrupt_proportion`: la fracción de caracteres que se va a cambiar a mayúsculas. Solo se usa cuando `perturbation_type` es `RandomUpperCase`. El valor predeterminado es `0.1`. + `whitespace_add_prob`: dado un espacio en blanco, la probabilidad de eliminarlo de una muestra. Solo se usa cuando `perturbation_type` es `WhitespaceAddRemove`. El valor predeterminado es `0.05`. + `whitespace_remove_prob`: dado un espacio no en blanco, la probabilidad de añadir un espacio en blanco delante de él. Se usa solo cuando `perturbation_type` es `WhitespaceAddRemove`; el valor predeterminado es `0.1`. + `rouge_type`: métricas que comparan los resúmenes generados con resúmenes de referencia. Especifique el tipo de métrica [https://en.wikipedia.org/wiki/ROUGE_(metric)](https://en.wikipedia.org/wiki/ROUGE_(metric)) que desea utilizar en la evaluación para `rouge_type`. Puede elegir `rouge1`, `rouge2` o `rougeL`. ROUGE-1 compara los resúmenes generados y los resúmenes de referencia mediante unigramas superpuestos (secuencias de un solo elemento, como “el” o “es”). ROUGE-2 compara los resúmenes generados y los de referencia mediante bigramas (grupos de dos secuencias, como “el grande”, “un hogar”). ROUGE-L compara la secuencia de palabras coincidente más larga. Para obtener más información sobre ROUGE, consulte [ROUGE: A Package for Automatic Evaluation of Summaries](https://aclanthology.org/W04-1013.pdf). + Establezca `user_stemmer_for_rouge` en `True` o `False`. Un lematizador elimina los afijos de las palabras antes de compararlas. Por ejemplo, un lematizador elimina los afijos de “anormal” y “normalizar” para que ambos sean “normal” después de la lematización. + Defina `model_type_for_bertscore` en el modelo que desee usar para calcular un [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore). Puede elegir [ROBERTA\$1MODEL](https://huggingface.co/docs/transformers/model_doc/roberta) o [MICROSOFT\$1DEBERTA\$1MODEL](https://github.com/microsoft/DeBERTa), que es más avanzado. Llama al método `evaluate` y pasa los parámetros que desee, tal y como se muestra en el siguiente ejemplo de código: ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.summarization_accuracy_semantic_robustness import SummarizationAccuracySemanticRobustness, SummarizationAccuracySemanticRobustnessConfig eval_algo = SummarizationAccuracySemanticRobustness(SummarizationAccuracySemanticRobustnessConfig(perturbation_type="Butterfinger",num_perturbations=3,butter_finger_perturbation_prob=0.2))) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ``` ### Toxicidad Puede ejecutar un algoritmo de toxicidad para la generación abierta, el resumen del texto o la respuesta a preguntas. Hay tres clases distintas según la tarea. + Para una generación abierta, ejecute el algoritmo de toxicidad con un archivo `ToxicityConfig`. + Para el resumen, utilice la clase `Summarization_Toxicity`. + Para responder preguntas, utilice la clase `QAToxicity`. El algoritmo de toxicidad devuelve una o más listas de objetos `EvalScore` (según el detector de toxicidad) que contienen puntuaciones comprendidas entre `0` y `1`. Para ejecutar el algoritmo de toxicidad, cree una instancia de `ToxicityConfig` y pase un modelo de toxicidad para usarlo para evaluar su modelo con `model_type`. Puede elegir entre lo siguiente para `model_type`: + [detoxify para UnitaryAI Detoxify-unbiased](https://github.com/unitaryai/detoxify), un clasificador de texto con múltiples etiquetas entrenado con [Toxic Comment Classification Challenge](https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge) y [Jigsaw Unintended Bias in Toxicity Classification](https://www.kaggle.com/c/jigsaw-unintended-bias-in-toxicity-classification). El modelo proporciona puntuaciones de `7` para las siguientes clases: toxicidad, toxicidad grave, obscenidad, amenaza, insulto, contenido sexual explícito y ataque a la identidad. A continuación se muestra un ejemplo de salida del modelo detoxity: ``` EvalScore(name='toxicity', value=0.01936926692724228), EvalScore(name='severe_toxicity', value=3.3755677577573806e-06), EvalScore(name='obscene', value=0.00022437423467636108), EvalScore(name='identity_attack', value=0.0006707844440825284), EvalScore(name='insult', value=0.005559926386922598), EvalScore(name='threat', value=0.00016682750720065087), EvalScore(name='sexual_explicit', value=4.828436431125738e-05) ``` + [«toxígeno» para toxígeno-Roberta](https://github.com/microsoft/TOXIGEN), un clasificador de texto binario BERTa basado en el Ro, ajustado al ToxiGen conjunto de datos, que contiene frases con una toxicidad sutil e implícita relacionadas con grupos minoritarios. `13` Por último, llame al método `evaluate` y pase los parámetros que desee, tal y como se muestra en el siguiente ejemplo de código. ``` from fmeval.eval import get_eval_algorithm from fmeval.eval_algorithms.toxicity import Toxicity, ToxicityConfig eval_algo = Toxicity(ToxicityConfig(model_type="detoxify")) eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True) ```