En este tutorial, ajustaremos un modelo IBM® Granite utilizando un conjunto de datos que contiene comentarios de clientes de un negocio de peluquería canina.
Prompt tuning es una forma eficiente y de bajo costo de adaptar un modelo fundacional de inteligencia artificial (IA) a nuevas tareas posteriores sin volver a entrenar todo el modelo y actualizar sus ponderaciones.
Los modelos fundacionales se basan en modelos de lenguaje grandes (LLM) y reciben grandes cantidades de datos de entrenamiento. Los casos de uso comunes de los modelos fundacionales son los chatbots y los asistentes virtuales.
Hay varias formas de mejorar la interpretación de la entrada de un modelo fundacional y la calidad de las respuestas. Para comprender mejor estos matices, comparemos algunos de los métodos.
- La ingeniería rápida es la optimización de las respuestas de un modelo fundacional proporcionando una instrucción bien diseñada. No se introducen nuevos datos con esta técnica y el modelo permanece tal cual. Con este método, el modelo recibe una entrada y una instrucción de ingeniería delante de ella. Por ejemplo, puede usar la instrucción: "Traducir inglés a español", con la entrada: "buenos días." Este método requiere más trabajo por parte del usuario. Sin embargo, este esfuerzo humano manual para formular instrucciones efectivas ayuda a los modelos de IA generativa a producir respuestas específicas para tareas sin volver a entrenar todo el modelo fundacional.
- El ajuste de modelos de lenguaje grandes implica ajustar el mismo modelo proporcionando un gran número de conjuntos de datos etiquetados. El ajuste altera las ponderaciones del modelo y se vuelve difícil de gestionar a medida que las tareas se diversifican. Esto requiere una cantidad significativa de recursos computacionales. A su vez, este método tiende a tener la mejor precisión, ya que el modelo se puede entrenar para casos de uso muy específicos.
- A diferencia del ajuste, prompt tuning no altera las ponderaciones del modelo previamente capacitado. En cambio, esta técnica es eficiente en cuanto a los parámetros al ajustar los parámetros de las instrucciones para guiar las respuestas del modelo en la dirección preferida. El modelo cuenta con una entrada y soft prompts ajustables generadas por la propia IA. Este contexto específico de la tarea guía el modelo masivo para adaptar sus respuestas a una tarea específica, incluso con datos limitados.
- De manera similar a prompt tuning, el ajuste de prefijosimplica que el modelo reciba varios ejemplos de resultados preferidos. La diferencia aquí es que también se incluye un prefijo, una serie de vectores específicos de la tarea. El ajuste de prefijos implica tanto soft prompts como instrucciones inyectadas en capas del modelo de aprendizaje profundo. Estos llamados "tokens" permiten al modelo ajustado la flexibilidad necesaria para admitir una variedad de tareas nuevas a la vez. Este método logra un rendimiento similar al ajuste de todas las capas y solo entrena alrededor del 0.1 % de los parámetros. El ajuste de prefijos incluso supera el ajuste en entornos con pocos datos.
Las hard prompts están orientadas al usuario y requieren la acción del usuario. Una hard prompt puede considerarse como una plantilla o instrucciones para que el LLM genere respuestas. A continuación, se presenta un ejemplo de una hard prompt. Le recomendamos que consulte la página de documentación de IBM para obtener más información sobre este tipo de instrucciones y varios otros.
hard_prompt_template = """Generate a summary of the context that answers the question. Explain the answer in multiple steps if possible.
Answer style should match the context. Ideal Answer length is 2-3 sentences.\n\n{context}\nQuestion: {question}\nAnswer:
"""
Con esta plantilla de instrucciones, se puede proporcionar a un LLM instrucciones específicas sobre la estructura y el estilo de salida preferidos. A través de esta instrucción explícita, el LLM tendría más probabilidades de producir respuestas deseables de mayor calidad.
A diferencia de las hard prompts, las soft prompts no están escritas en lenguaje natural. En cambio, las instrucciones se inicializan como vectores numéricos generados por IA que se agregan al inicio de cada incorporación de entrada que extrae el conocimiento del modelo más grande. Esta falta de interpretabilidad se extiende a la IA que elige instrucciones optimizadas para una tarea determinada. A menudo, la IA no puede explicar por qué eligió esas incorporaciones. En comparación con otros métodos de instrucciones, estos tokens son menos costosos desde el punto de vista informático que el ajuste, ya que el modelo en sí permanece congelado con ponderaciones fijas. Las soft prompts también tienden a superar a las hard prompts creadas por humanos.
En este tutorial, trabajaremos con soft prompts para prompt tuning.
Necesita una cuenta de IBM® Cloud para crear un proyecto en watsonx.ai .
Paso 1: Configuración del entorno
Si bien puede elegir entre varias herramientas, este tutorial lo guiará a través de cómo configurar una cuenta de IBM para usar un Jupyter Notebook.
Inicie sesión en watsonx.ai con su cuenta de IBM Cloud.
Cree un proyecto watsonx.ai.
Puede obtener su ID de proyecto desde dentro de su proyecto. Haga clic en la pestaña Manage. Luego, copie el ID del proyecto de la sección Details de la página General. Necesita este ID para este tutorial.
Cree un Jupyter Notebook.
Este paso abrirá un entorno de Notebook donde puede copiar el código de este tutorial para implementar prompt tuning por su cuenta. También puede descargar este Notebook en su sistema local y cargarlo en su proyecto watsonx.ai como activo. Este Jupyter Notebook con los conjuntos de datos utilizados se pueden encontrar en GitHub.
Paso 2. Configure una instancia de watsonx.ai Runtime y una clave de API
Cree una instancia de servicio watsonx.ai Runtime (seleccione la región adecuada y elija el plan Lite, que es una instancia gratuita).
Genere una clave de API.
Asocie la instancia del servicio watsonx.ai Runtime al proyecto que creó en watsonx.ai.
Paso 3. Instalación e importación de bibliotecas relevantes y configuración de sus credenciales
Necesitaremos algunas bibliotecas y módulos para este tutorial. Asegúrese de importar los siguientes; si no están instalados, puede resolver esto con una instalación rápida de pip.
%pip install ibm-watsonx-ai | tail -n 1
%pip install pandas | tail -n 1
%pip install wget | tail -n 1
%pip install scikit-learn | tail -n 1
%pip install matplotlib | tail -n 1 #imports
import wget
import pandas as pd
from ibm_watsonx_ai import APIClient
from ibm_watsonx_ai.foundation_models.utils.enums import ModelTypes
from ibm_watsonx_ai.experiment import TuneExperiment
from ibm_watsonx_ai.helpers import DataConnection
from ibm_watsonx_ai.foundation_models import ModelInference
from sklearn.metrics import accuracy_score, f1_score
from datetime import datetime
Configure sus credenciales. Ingrese su clave de API y el ID del proyecto.
"url": "https://us-south.ml.cloud.ibm.com",
"apikey": "YOUR_API_KEY_HERE"
}
project_id = "YOUR_PROJECT_ID_HERE"
Paso 4. Establecimiento del entorno e importación del conjunto de datos
Como primer paso para establecer el entorno, cree una instancia de APIClient con sus detalles de autenticación y establezca su project_id.
client.set.default_project(project_id)
Resultado:
'SUCCESS'
Para este tutorial, utilizaremos un conjunto de datos que consiste en comentarios de negocios de peluquería canina. Con la URL adecuada, podemos conectar el conjunto de datos al cliente de API.
Puede utilizar cualquier conjunto de datos de su elección. Varios conjuntos de datos de código abierto están disponibles en plataformas como HuggingFace.
url = "https://raw.githubusercontent.com/AnnaGutowska/think/main/tutorials/prompt-tuning-tutorial/" + train_filename
wget.download(url)
asset_details = client.data_assets.create(name=train_filename, file_path=train_filename)
asset_id = client.data_assets.get_id(asset_details)
Resultado:
Creando activo de datos...
SUCCESS
Resultado:
3b1db894-8d9e-428d-8fee-d96f328c7726
Para obtener insight sobre el formato de estos comentarios de clientes, carguemos los datos en un marco de datos de Pandas e imprimiremos algunas filas que muestren comentarios tanto positivos como negativos. Un resultado de "1" denota comentarios positivos y "0" se utiliza para comentarios negativos.
df = pd.read_json(train_filename)
df[5:10]
Resultado:
Paso 5. Ajuste del modelo.
La clase TuneExperiment se utiliza para crear experimentos y programar ajustes. Usémosla para inicializar nuestro experimento y establecer nuestro modelo fundacional base, datos de entrenamiento y parámetros. El objetivo de este ejercicio de prompt tuning es que el LLM adapte sus respuestas de acuerdo con las calificaciones de satisfacción del cliente extraídas de nuestro conjunto de datos. Esta es una tarea de clasificación, ya que los comentarios se pueden clasificar como positivos ("1") o negativos ("0").
Para este tutorial, sugerimos utilizar IBM Granite como modelo de lenguaje grande para lograr resultados similares.
project_id=project_id
)
prompt_tuner = experiment.prompt_tuner(name="prompt tuning tutorial",
task_id=experiment.Tasks.CLASSIFICATION,
base_model="ibm/granite-3-8b-instruct",
accumulate_steps=16,
batch_size=8,
learning_rate=0.001,
max_input_tokens=128,
max_output_tokens=2,
num_epochs=12,
tuning_type=experiment.PromptTuningTypes.PT,
init_text="Extract the satisfaction from the comment. Return simple '1' for satisfied customer or '0' for unsatisfied. Comment:",
init_method="text",
verbalizer="classify {0, 1} {{input}}",
auto_update_model=True
)
Ahora que tenemos nuestro experimento de ajuste configurado, necesitamos conectarlo a nuestro conjunto de datos. Para esto, usemos la clase DataConnection . Esto requiere el asset_id que producimos anteriormente al iniciar el activo de datos con nuestro cliente API.
Puede utilizar cualquier modelo de IA de su elección. Los modelos fundacionales disponibles para ajustar a través de watsonx se pueden encontrar aquí o ejecutando el siguiente comando.
Resultado:
{'FLAN_T5_XL': 'google/flan-t5-xl', 'GRANITE_13B_INSTRUCT_V2': 'ibm/granite-13b-instruct-v2', 'LLAMA_2_13B_CHAT': 'meta-llama/llama-2-13b-chat'}
training_data_references=[data_conn],
background_mode=False)
Resultado:
##############################################
Running '20671f17-ff53-470b-9bfe-04318ecb91d9'
##############################################
pending......
running....................................................................................................................................
completed
Training of '20671f17-ff53-470b-9bfe-04318ecb91d9' finished successfully.
Paso 6. Evaluación de los resultados del ajuste.
Para asegurarnos de que nuestro prompt tuning ha concluido, podemos verificar el estado. Si el estado que se imprime no es "completed", espere a que finalice el ajuste antes de continuar.
print(status)
Resultado:
completed
Ahora podemos recuperar el resumen de prompt tuning. En este resumen, verá un valor de pérdida. Para cada ejecución de entrenamiento, la función de pérdida mide la diferencia entre los resultados previstos y los reales. Por lo tanto, se prefiere un valor de pérdida más bajo.
También podemos trazar la curva de aprendizaje del ajuste de nuestro modelo mediante la función plot_learning_curve(). Una curva con pendiente negativa que se nivela cerca de cero indica que el modelo está mejorando su generación de salida esperada. Para obtener más información sobre la interpretación de los gráficos de funciones de pérdida, consulte la documentación pertinente de IBM watsonx.
Resultado:
Gráficos de curvas de aprendizaje
Paso 7. Despliegue del modelo ajustado.
Este paso de desplegar el modelo ajustado es crítico para completar el siguiente paso de comparar el rendimiento del modelo ajustado con el modelo previamente ajustado.
Nota: SERVING_NAME se establece en la fecha y hora actuales, ya que debe ser un valor único.
meta_props = {
client.deployments.ConfigurationMetaNames.NAME: "PROMP TUNE DEPLOYMENT",
client.deployments.ConfigurationMetaNames.ONLINE: {},
client.deployments.ConfigurationMetaNames.SERVING_NAME : datetime.now().strftime('%Y_%m_%d_%H%M%S')
}
deployment_details = client.deployments.create(model_id, meta_props)
Resultado:
######################################################################################
Synchronous deployment creation for id: '6aa5dd5c-0cc4-44e0-9730-18303e88e14a' started
######################################################################################
initializing.......................
ready
-----------------------------------------------------------------------------------------------
Successfully finished deployment creation, deployment_id='24a97b84-47d0-4490-9f5f-21ed2376fdd6'
-----------------------------------------------------------------------------------------------
Paso 8. Prueba del modelo ajustado.
Ahora, probemos el rendimiento tanto del modelo ajustado como del modelo fundacional original para ver los impactos de nuestro proceso de ajuste. Primero, carguemos el conjunto de datos de prueba. Este conjunto de datos debe ser un subconjunto de datos que no estuvo presente durante el ajuste. A menudo, el conjunto de prueba también es más pequeño que el conjunto de entrenamiento. Además, cada entrada en el conjunto de datos de prueba tiene la instrucción como prefijo del comentario del usuario.
url = "https://raw.githubusercontent.com/AnnaGutowska/think/main/tutorials/prompt-tuning-tutorial/" + test_filename
wget.download(url)
data = pd.read_json(test_filename)
Vamos a mostrar una pequeña parte del conjunto de datos para comprender mejor su estructura.
Resultado:
Al cargar el conjunto de datos de prueba, extraigamos las entradas y salidas.
satisfaction = list(data.output)
prompts_batch = ["\n".join([prompt]) for prompt in prompts]
También podemos imprimir una entrada y salida de prueba de muestra para comprender mejor cómo hemos extraído el contenido del conjunto de datos.
Resultado:
'Extract the satisfaction from the comment. Return simple 1 for satisfied customer or 0 for unsatisfied.\nComment: Long wait times.\nSatisfaction:\n'
En este ejemplo, se presenta la instrucción, seguida de la opinión del cliente sobre los largos tiempos de espera y, finalmente, la satisfacción es 0 para indicar un comentario negativo.
Resultado:
0
Ahora que tenemos el conjunto de datos de prueba, probemos la precisión y la puntuación F1 de nuestro modelo ajustado. La puntuación F1 es la media de la precisión y la recuperación del modelo. Necesitaremos el deployment_id para hacer esto. Tenga en cuenta que concurrency_limit se establece en 2 para evitar alcanzar el límite de velocidad de la API. Este es el número de solicitudes que se enviarán en paralelo.
tuned_model = ModelInference(
deployment_id=deployment_id,
api_client=client
)
tuned_model_results = tuned_model.generate_text(prompt=prompts_batch, concurrency_limit=2)
print(f'accuracy_score: {accuracy_score(satisfaction, [int(float(x)) for x in tuned_model_results])}, f1_score: {f1_score(satisfaction, [int(float(x)) for x in tuned_model_results])}')
Resultado:
accuracy_score: 0.9827586206896551, f1_score: 0.9827586206896551
Dada la alta precisión de nuestro modelo y la puntuación F1, probemos el rendimiento del mismo modelo Granite sin ningún ajuste.
model_id="ibm/granite-3-8b-instruct",
api_client=client
)
base_model_results = base_model.generate_text(prompt=prompts_batch, concurrency_limit=2)
print(f'base model accuracy_score: {accuracy_score(satisfaction, [int(x) for x in base_model_results])}, base model f1_score: {f1_score(satisfaction, [int(x) for x in base_model_results])}')
Resultado:
base model accuracy_score: 0.9310344827586207, base model f1_score: 0.9298245614035088
Nuestro modelo ajustado supera al modelo fundacional previamente ajustado. Dado que el modelo ajustado se especializa en extraer puntuaciones de satisfacción, se puede utilizar para otras tareas de extracción de satisfacción. ¡Gran trabajo!
En este tutorial, realizó un ajuste de instrucciones en un modelo de IBM Granite utilizando la API de watsonx. Su modelo ajustado y desplegado superó con éxito al modelo fundacional con una precisión aproximadamente un 5 % mayor.