prodigy openai recipes
1.0.0
Desde entonces, las recetas en este repositorio se han mudado al prodigio y se están manteniendo allí. Pronto recibirán una actualización con el advenimiento del soporte de Spacy-LLM, que presenta mejores indicaciones y múltiples proveedores de LLM. Es por eso que hemos optado por archivar este repositorio, para que podamos centrarnos en mantener estas recetas como parte de Spacy and Prodigy directamente.
Puede obtener más información revisando la sección de modelos de idiomas grandes en los documentos.
Este repositorio contiene un código de ejemplo sobre cómo combinar el aprendizaje de cero y pocos disparos con un pequeño esfuerzo de anotación para obtener un conjunto de datos de alta calidad con la máxima eficiencia . Específicamente, utilizamos modelos de idiomas grandes disponibles de OpenAI para proporcionarnos un conjunto inicial de predicciones, luego girar una instancia de prodigio en nuestra máquina local para pasar por estas predicciones y curarlas. Esto nos permite obtener un conjunto de datos estándar de oro bastante rápido y entrenar un modelo más pequeño y supervisado que se ajuste a nuestras necesidades exactas y un caso de uso.
Asegúrese de instalar Prodigy, así como algunas dependencias adicionales de Python:
python -m pip install prodigy -f https://[email protected]
python -m pip install -r requirements.txt Con XXXX-XXXX-XXXX-XXXX es su clave de licencia de prodigio personal.
Luego, cree una nueva clave API desde OpenAI.com o obtenga una existente. Registre la clave secreta, así como la clave de la organización y asegúrese de que estén disponibles como variables ambientales. Por ejemplo, configúalos en un archivo .env en el directorio raíz:
OPENAI_ORG = "org-..."
OPENAI_KEY = "sk-..."
ner.openai.correct : anotación ner con aprendizaje de cero o pocos disparos Esta receta marca las predicciones de entidad obtenidas de un modelo de lenguaje grande y le permite marcarlas como correctas o curarlas manualmente. Esto le permite reunir rápidamente un conjunto de datos estándar de oro a través de aprendizaje de cero disparo o pocos disparos. Es muy parecido a usar la receta estándar ner.correct en prodi.gy, pero estamos usando GPT-3 como modelo de backend para hacer predicciones.
python -m prodigy ner.openai.correct dataset filepath labels [--options] -F ./recipes/openai_ner.py| Argumento | Tipo | Descripción | Por defecto |
|---|---|---|---|
dataset | stri | Conjunto de datos de prodigio para guardar anotaciones. | |
filepath | Camino | Camino a los datos .jsonl para anotar. Los datos deben al menos contener un campo "text" . | |
labels | stri | Lista separada por comas Definición de las etiquetas NER El modelo debe predecir. | |
--lang , -l | stri | El lenguaje de los datos de entrada: se utilizará para obtener un tokenizador relevante. | "en" |
--segment , -S | bool | La bandera para establecer cuando los ejemplos deben dividirse en oraciones. Por defecto, se muestra el artículo de entrada completa. | False |
--model , -m | stri | Modelo GPT-3 para usar para predicciones iniciales. | "text-davinci-003" |
--prompt_path , -p | Camino | Camino a la plantilla de inmediato .jinja2 . | ./templates/ner_prompt.jinja2 |
--examples-path , -e | Camino | Camino hacia los ejemplos para ayudar a definir la tarea. El archivo puede ser un .yml, .yaml o .json. Si se establece en None , se aplica el aprendizaje de disparo cero. | None |
--max-examples , -n | intencionalmente | Número máximo de ejemplos para incluir en la solicitud a OpenAI. Si se establece en 0, siempre se aplica el aprendizaje de disparo cero, incluso cuando hay ejemplos disponibles. | 2 |
--batch-size , -b | intencionalmente | Tamaño de lote de consultas para enviar a la API de OpenAI. | 10 |
--verbose , -v | bool | Indicador para imprimir información adicional en la terminal. | False |
Supongamos que queremos reconocer los platos, los ingredientes y el equipo de cocción de algún texto que obtuvimos de un subreddit de cocina. Enviaremos el texto a GPT-3, alojado por OpenAI, y proporcionaremos un mensaje de anotación para explicar al modelo de idioma el tipo de predicciones que queremos. Algo como:
From the text below, extract the following entities in the following format:
dish: <comma delimited list of strings>
ingredient: <comma delimited list of strings>
equipment: <comma delimited list of strings>
Text:
...
Definimos la definición de este indicador en un archivo .jinja2 que también describe cómo agregar ejemplos para el aprendizaje de pocos disparos. Puede crear su propia plantilla y proporcionarla a la receta con la opción --prompt-path o -p . Además, con --examples-path o -e puede establecer la ruta del archivo de un archivo .y (a) ml o .json que contiene ejemplos adicionales:
python -m prodigy ner.openai.correct my_ner_data ./data/reddit_r_cooking_sample.jsonl " dish,ingredient,equipment " -p ./templates/ner_prompt.jinja2 -e ./examples/ner.yaml -n 2 -F ./recipes/openai_ner.pyDespués de recibir los resultados de la API de OpenAI, la receta de prodigio convierte las predicciones en una tarea de anotación que se puede representar con el prodigio. La tarea incluso muestra el aviso original, así como la respuesta bruta que obtuvimos del modelo de idioma.
¡Aquí, vemos que el modelo puede reconocer correctamente los platos, los ingredientes y el equipo de cocción desde el principio!
La receta también ofrece una opción --verbose o -v que incluye el mensaje exacto y la respuesta en la terminal a medida que se recibe el tráfico. Tenga en cuenta que debido a que las solicitudes a la API están lotes, es posible que deba desplazarse un poco para encontrar el mensaje actual.
En algún momento, puede notar un error en las predicciones del modelo de idioma Operai. Por ejemplo, notamos un error en el reconocimiento del equipo de cocción en este ejemplo:
Si ve este tipo de errores sistemáticos, puede dirigir las predicciones en la dirección correcta corrigiendo el ejemplo y luego seleccionando el pequeño icono de "bandera" en la parte superior derecha de la interfaz de usuario del prodigio:
Una vez que presione Aceptar en la interfaz Prodigy, el ejemplo marcado se recogerá automáticamente y se agregará a los ejemplos que se envían a la API de OpenAI como parte del aviso.
Nota
Debido a que el prodigio lanza estas solicitudes, el aviso se actualizará con un ligero retraso, después de que se envíe el próximo lote de indicaciones a OpenAI. Puede experimentar que el tamaño del lote (--batch-sizeo-b) sea más pequeño para que el cambio entre en vigencia antes, pero esto podría afectar negativamente la velocidad del flujo de trabajo de anotación.
ner.openai.fetch : busca ejemplos por adelantado La receta ner.openai.correct obtiene ejemplos de OpenAi mientras se anotan, pero también hemos incluido una receta que puede obtener un gran lote de ejemplos por adelantado.
python -m prodigy ner.openai.fetch input_data.jsonl predictions.jsonl " dish,ingredient,equipment " -F ./recipes/ner.py Esto creará un archivo predictions.jsonl que se puede cargar con la receta ner.manual .
Tenga en cuenta que la API de OpenAI podría devolver los errores de "429 demasiados solicitudes" al solicitar demasiados datos a la vez; en este caso, es mejor asegurarse de solicitar solo 100 ejemplos a la vez.
Después de haber curado un conjunto de predicciones, puede exportar los resultados con db-out :
python -m prodigy db-out my_ner_data > ner_data.jsonlEl formato de las anotaciones exportadas contiene todos los datos que necesita para entrenar un modelo más pequeño aguas abajo. Cada ejemplo en el conjunto de datos contiene el texto original, los tokens, anotaciones de span que denotan las entidades, etc.
También puede exportar los datos al formato binario de Spacy, utilizando data-to-spacy . Este formato le permite cargar en las anotaciones como objetos Doc Spacy, que pueden ser convenientes para una conversión adicional. El comando data-to-spacy también facilita entrenar a un modelo NER con Spacy. Primero exporta los datos, especificando los datos del tren como el 20% del total:
python -m prodigy data-to-spacy ./data/annotations/ --ner my_ner_data -es 0.2Entonces puedes entrenar un modelo con Spacy o Prodigy:
python -m spacy train ./data/annotations/config.cfg --paths.train ./data/annotations/train.spacy --paths.dev ./data/annotations/dev.spacy -o ner-model Esto guardará un modelo en el directorio ner-model/ .
También hemos incluido un script experimental para cargar en el formato binario .spacy y entrenar un modelo con la Biblioteca transformers Huggingface. Puede usar los mismos datos que acaba de exportar y ejecutar el script así:
# First you need to install the HuggingFace library and requirements
pip install -r requirements_train.txt
python ./scripts/train_hf_ner.py ./data/annotations/train.spacy ./data/annotations/dev.spacy -o hf-ner-model El modelo resultante se guardará en el hf-ner-model/ .
textcat.openai.correct : TextCat Annotation con aprendizaje de cero o pocos disparosEsta receta nos permite clasificar los textos más rápido con la ayuda de un modelo de idioma grande. También proporciona una "razón" para explicar por qué se eligió una etiqueta en particular.
python -m prodigy textcat.openai.correct dataset filepath labels [--options] -F ./recipes/openai_textcat.py| Argumento | Tipo | Descripción | Por defecto |
|---|---|---|---|
dataset | stri | Conjunto de datos de prodigio para guardar anotaciones. | |
filepath | Camino | Camino a los datos .jsonl para anotar. Los datos deben al menos contener un campo "text" . | |
labels | stri | Lista separada por comas Definición de las etiquetas de categorización de texto El modelo debe predecir. | |
--lang , -l | stri | El lenguaje de los datos de entrada: se utilizará para obtener un tokenizador relevante. | "en" |
--segment , -S | bool | La bandera para establecer cuando los ejemplos deben dividirse en oraciones. Por defecto, se muestra el artículo de entrada completa. | False |
--model , -m | stri | Modelo GPT-3 para usar para predicciones iniciales. | "text-davinci-003" |
--prompt-path , -p | Camino | Camino a la plantilla de inmediato .jinja2 . | ./templates/textcat_prompt.jinja2 |
--examples-path , -e | Camino | Camino hacia los ejemplos para ayudar a definir la tarea. El archivo puede ser un .yml, .yaml o .json. Si se establece en None , se aplica el aprendizaje de disparo cero. | None |
--max-examples , -n | intencionalmente | Número máximo de ejemplos para incluir en la solicitud a OpenAI. Si se establece en 0, siempre se aplica el aprendizaje de disparo cero, incluso cuando hay ejemplos disponibles. | 2 |
--batch-size , -b | intencionalmente | Tamaño de lote de consultas para enviar a la API de OpenAI. | 10 |
--exclusive-classes , -E | bool | Indicador para hacer la tarea de clasificación exclusiva. | False |
--verbose , -v | bool | Indicador para imprimir información adicional en la terminal. | False |
Las recetas textcat se pueden usar para la categorización de texto binario, multiclase y multilabel. Puede establecer esto pasando el número apropiado de etiquetas en el parámetro --labels ; Por ejemplo, pasar una sola etiqueta la convierte en clasificación binaria, etc. Hablaremos de cada uno en las secciones de procedimiento.
Supongamos que queremos saber si un comentario en particular Reddit habla sobre una receta de comida. Enviaremos el texto a GPT-3 y proporcionaremos un mensaje que instruya las predicciones que queremos.
From the text below, determine wheter or not it contains a recipe. If it is a
recipe, answer "accept." If it is not a recipe, answer "reject."
Your answer should only be in the following format:
answer: <string>
reason: <string>
Text:
Para la clasificación binaria, queremos que GPT-3 devuelva "aceptar" si un texto determinado es una receta de alimentos y "rechazar" de lo contrario. La sugerencia de GPT-3 se muestra prominentemente en la UI. Podemos presionar el botón Aceptar (Marca de verificación) para incluir el texto como un ejemplo positivo o presionar el botón Rechazar (marca cruzada) si es un ejemplo negativo.
python -m prodigy textcat.openai.correct my_binary_textcat_data data/reddit_r_cooking_sample.jsonl --labels recipe -F recipes/openai_textcat.py
Ahora, supongamos que queremos clasificar los comentarios de Reddit como una receta, comentarios o una pregunta. Podemos escribir el siguiente mensaje:
Classify the text below to any of the following labels: recipe, feedback, question.
The task is exclusive, so only choose one label from what I provided.
Your answer should only be in the following format:
answer: <string>
reason: <string>
Text:
Luego, podemos usar esta receta para manejar casos de múltiples y multiclase pasando las tres etiquetas al parámetro --labels . También debemos establecer la bandera --exclusive-classes para representar una interfaz de usuario de opción:
python -m prodigy textcat.openai.correct my_multi_textcat_data data/reddit_r_cooking_sample.jsonl
--labels recipe,feedback,question
--exclusive-classes
-F recipes/openai_textcat.py
Escribimos estas indicaciones como una plantilla .Jinja2 que también puede tomar ejemplos para un aprendizaje de pocos disparos. Puede crear su propia plantilla y proporcionarla a la receta con la opción --prompt-path o -p . Además, con --examples-path o -e puede establecer la ruta del archivo de un archivo .y (a) ml o .json que contiene ejemplos adicionales. También puede agregar contexto en estos ejemplos tal como lo observamos para mejorar la salida:
python -m prodigy textcat.openai.correct my_binary_textcat_data
./data/reddit_r_cooking_sample.jsonl
--labels recipe
--prompt-path ./templates/textcat_prompt.jinja2
--examples-path ./examples/textcat_binary.yaml -n 2
-F ./recipes/openai_textcat.py Similar a la receta NER, esta receta también convierte las predicciones en una tarea de anotación que se puede representar con el prodigio. Para la clasificación binaria, utilizamos la interfaz classification con elementos HTML personalizados, mientras que para la categorización de texto multilabel o multiclase, utilizamos la interfaz de anotación choice . Tenga en cuenta que incluimos el aviso original y la respuesta de OpenAI en la interfaz de usuario.
Por último, puede usar el indicador --verbose o -v para mostrar el aviso exacto y la respuesta en el terminal. Tenga en cuenta que debido a que las solicitudes a la API están lotes, es posible que deba desplazarse un poco para encontrar el mensaje actual.
Similar a las recetas NER, también puede dirigir las predicciones en la dirección correcta corrigiendo el ejemplo y luego seleccionando el pequeño icono de "bandera" en la parte superior derecha de la interfaz de usuario del prodigio:
Una vez que presione el botón Aceptar en la interfaz Prodigy, el ejemplo marcado se recogerá y se agregará a los ejemplos de pocos disparos enviados a la API de OpenAI como parte del aviso.
Nota
Debido a que el prodigio lanza estas solicitudes, el aviso se actualizará con un ligero retraso, después de que se envíe el próximo lote de indicaciones a OpenAI. Puede experimentar que el tamaño del lote (--batch-sizeo-b) sea más pequeño para que el cambio entre en vigencia antes, pero esto podría afectar negativamente la velocidad del flujo de trabajo de anotación.
textcat.openai.fetch : buscar ejemplos de categorización de texto La receta textcat.openai.fetch nos permite obtener un gran lote de ejemplos por adelantado. Esto es útil cuando está con datos altamente ilustrados y solo está interesado en ejemplos raros.
python -m prodigy textcat.openai.fetch input_data.jsonl predictions.jsonl --labels Recipe -F ./recipes/openai_textcat.py Esto creará un archivo predictions.jsonl que se puede cargar con la receta textcat.manual .
Tenga en cuenta que la API de OpenAI podría devolver los errores de "429 demasiadas solicitudes" al solicitar demasiados datos a la vez; en este caso, es mejor asegurarse de solicitar solo 100 ejemplos a la vez y echar un vistazo a los límites de tarifa de la API.
La receta textcat.openai.fetch es adecuada para trabajar con conjuntos de datos donde hay un desequilibrio de clase severo. Por lo general, desea encontrar ejemplos de la clase rara en lugar de anotar una muestra aleatoria. A partir de ahí, desea mejorarlos para entrenar un modelo decente, etc.
Aquí es donde podrían ayudar modelos de idiomas grandes como OpenAI.
Usando el conjunto de datos de Reddit R/Cooking, solicitamos a OpenAI a buscar comentarios que se parezcan a una receta de alimentos. En lugar de anotar 10,000 ejemplos, ejecutamos textcat.openai.fetch y obtuvimos 145 clases positivas. De esos 145 ejemplos, 114 resultó ser verdaderos positivos (79% de precisión). Luego verificamos 1,000 ejemplos negativos y encontramos 12 casos falsos negativos (98% de retiro).
Idealmente, una vez que anotamos completamente el conjunto de datos, podemos capacitar a un modelo supervisado que es mejor usar que depender de las predicciones de disparo cero para la producción. El costo de ejecución es bajo y es más fácil de administrar.
Después de haber curado un conjunto de predicciones, puede exportar los resultados con db-out :
python -m prodigy db-out my_textcat_data > textcat_data.jsonlEl formato de las anotaciones exportadas contiene todos los datos que necesita para entrenar un modelo más pequeño aguas abajo. Cada ejemplo en el conjunto de datos contiene el texto original, los tokens, anotaciones de span que denotan las entidades, etc.
También puede exportar los datos al formato binario de Spacy, utilizando data-to-spacy . Este formato le permite cargar en las anotaciones como objetos Doc Spacy, que pueden ser convenientes para una conversión adicional. El comando data-to-spacy también facilita entrenar un modelo de categorización de texto con Spacy. Primero exporta los datos, especificando los datos del tren como el 20% del total:
# For binary textcat
python -m prodigy data-to-spacy ./data/annotations/ --textcat my_textcat_data -es 0.2
# For multilabel textcat
python -m prodigy data-to-spacy ./data/annotations/ --textcat-multilabel my_textcat_data -es 0.2Entonces puedes entrenar un modelo con Spacy o Prodigy:
python -m spacy train ./data/annotations/config.cfg --paths.train ./data/annotations/train.spacy --paths.dev ./data/annotations/dev.spacy -o textcat-model Esto guardará un modelo en el directorio textcat-model/ .
terms.openai.fetch : obtenga frases y términos basados en una consultaEsta receta genera términos y frases obtenidas de un modelo de lenguaje grande. Estos términos se pueden seleccionar y convertirse en archivos de patrones, lo que puede ayudar con las tareas de anotación aguas abajo.
python -m prodigy terms.openai.fetch query filepath [--options] -F ./recipes/openai_terms.py| Argumento | Tipo | Descripción | Por defecto |
|---|---|---|---|
query | stri | Consulta para enviar a OpenAi | |
output_path | Camino | Ruta para guardar la salida | |
--seeds , -s | stri | Una o más frases de semillas separadas por comas. | "" |
--n , -n | intencionalmente | Número mínimo de elementos para generar | 100 |
--model , -m | stri | Modelo GPT-3 para su finalización | "text-davinci-003" |
--prompt-path , -p | Camino | PATH TO JINJA2 Plantilla de inmediato | templates/terms_prompt.jinja2 |
--verbose , -v | bool | Imprima información adicional a la terminal | False |
--resume , -r | bool | Reanudar cargando ejemplos de texto desde el archivo de salida | False |
--progress , -pb | bool | Imprimir progreso de la receta. | False |
--temperature , -t | flotar | Parámetro de temperatura de OpenAI | 1.0 |
--top-p , --tp | flotar | OPERAI TOP_P PARAM | 1.0 |
--best-of , -bo | intencionalmente | OPERAI best_of param " | 10 |
--n-batch , -nb | intencionalmente | Param de tamaño por lotes de OpenAi | 10 |
--max-tokens , -mt | intencionalmente | Tokens máximos para generar por llamada | 100 |
Supongamos que está interesado en detectar trucos de skate en texto, entonces es posible que desee comenzar con una lista de trucos conocidos. Es posible que desee comenzar con la siguiente consulta:
# Base behavior, fetch at least 100 terms/phrases
python -m prodigy terms.openai.fetch " skateboard tricks " tricks.jsonl --n 100 --prompt-path templates/terms_prompt.jinja2 -F recipes/openai_terms.pyEsto generará un aviso a OpenAi que solicite intentar generar al menos 100 ejemplos de "trucos de skate". Hay un límite superior para la cantidad de tokens que puede generar OpenAI, pero esta receta intentará seguir recolectando términos hasta que alcance la cantidad especificada.
Puede optar por hacer que la consulta sea más elaborada si desea intentar ser más precisa, pero alternativamente también puede optar por agregar algunos términos de semillas a través de --seeds . Estos actuarán como ejemplos iniciales para ayudar a dirigir OpenAi en la dirección correcta.
# Base behavior but with seeds
python -m prodigy terms.openai.fetch " skateboard tricks " tricks.jsonl --n 100 --seeds " kickflip,ollie " --prompt-path templates/terms_prompt.jinja2 -F recipes/openai_terms.py La recopilación de muchos ejemplos puede llevar un tiempo, por lo que puede ser útil mostrar el progreso, a través de --progress a medida que se envían las solicitudes.
# Adding progress output as we wait for 500 examples
python -m prodigy terms.openai.fetch " skateboard tricks " tricks.jsonl --n 500 --progress --seeds " kickflip,ollie " --prompt-path templates/terms_prompt.jinja2 -F recipes/openai_terms.pyDespués de recolectar algunos ejemplos, es posible que desee generar más. Puede elegir continuar desde un archivo de salida anterior. Esto reutilizará efectivamente esos ejemplos como semillas para el aviso a OpenAi.
# Use the `--resume` flag to re-use previous examples
python -m prodigy terms.openai.fetch " skateboard tricks " tricks.jsonl --n 50 --resume --prompt-path templates/terms_prompt.jinja2 -F recipes/openai_terms.py Cuando se haga la receta, tendrá un archivo tricks.jsonl que tiene contenido que se ve así:
{ "text" : " pop shove it " , "meta" :{ "openai_query" : " skateboard tricks " }}
{ "text" : " switch flip " , "meta" :{ "openai_query" : " skateboard tricks " }}
{ "text" : " nose slides " , "meta" :{ "openai_query" : " skateboard tricks " }}
{ "text" : " lazerflip " , "meta" :{ "openai_query" : " skateboard tricks " }}
{ "text" : " lipslide " , "meta" :{ "openai_query" : " skateboard tricks " }}
... Ahora tiene un archivo de tricks.jsonl en el disco que contiene trucos de skate, pero no puede asumir que todo esto será preciso. El siguiente paso sería revisar los términos y puede usar la receta textcat.manual que viene con Prodigy para eso.
# The tricks.jsonl was fetched from OpenAI beforehand
python -m prodigy textcat.manual skateboard-tricks-list tricks.jsonl --label skateboard-tricksEsto genera una interfaz que se ve así:
Puede aceptar o rechazar manualmente cada ejemplo y cuando haya terminado de anotar puede exportar el texto anotado en un archivo de patrones a través de los terms.to-patterns .
# Generate a `patterns.jsonl` file.
python -m prodigy terms.to-patterns skateboard-tricks-list patterns.jsonl --label skateboard-tricks --spacy-model blank:en Cuando se realice la receta, tendrá un archivo de patterns.jsonl que tiene contenido que se ve así:
{ "label" : " skateboard-tricks " , "pattern" :[{ "lower" : " pop " },{ "lower" : " shove " },{ "lower" : " it " }]}
{ "label" : " skateboard-tricks " , "pattern" :[{ "lower" : " switch " },{ "lower" : " flip " }]}
{ "label" : " skateboard-tricks " , "pattern" :[{ "lower" : " nose " },{ "lower" : " slides " }]}
{ "label" : " skateboard-tricks " , "pattern" :[{ "lower" : " lazerflip " }]}
{ "label" : " skateboard-tricks " , "pattern" :[{ "lower" : " lipslide " }]}
...OpenAI tiene un límite difícil en el tamaño de inmediato. No puede tener un aviso de más de 4079 tokens. Desafortunadamente, eso significa que hay un límite para el tamaño de las listas de términos que puede generar. La receta informará un error cuando esto sucede, pero es bueno estar al tanto de esta limitación.
ab.openai.prompts : A/B Evaluación de indicacionesEl objetivo de esta receta es permitir rápidamente a alguien comparar la calidad de las salidas de dos indicaciones de una manera cuantificable y ciega.
python -m prodigy ab.openai.prompts dataset inputs_path display_template_path prompt1_template_path prompt2_template_path [--options] -F ./recipes/openai_ab.py| Argumento | Tipo | Descripción | Por defecto |
|---|---|---|---|
dataset | stri | Conjunto de datos de prodigio para guardar respuestas en | |
inputs_path | Camino | Camino a las entradas JSONL | |
display_template_path | Camino | Plantilla para resumir los argumentos | |
prompt1_template_path | Camino | Camino a la primera plantilla de inmediato Jinja2 | |
prompt2_template_path | Camino | Camino a la segunda plantilla de inmediato Jinja2 | |
--model , -m | stri | Modelo GPT-3 para su finalización | "text-davinci-003" |
--batch-size , -b | intencionalmente | Tamaño por lotes para enviar a la API de OpenAI | 10 |
--verbose , -v | bool | Imprima información adicional a la terminal | False |
--no-random , -NR | bool | No se aleje al azar qué anotación se muestra como correcta | False |
--repeat , -r | intencionalmente | Con qué frecuencia enviar el mismo mensaje a OpenAi | 1 |
Como ejemplo, intentemos generar haikus humorístico. Para hacerlo, primero debemos construir dos archivos Jinja que representen la solicitud para enviar a OpenAI.
templates/ab/prompt1.jinja2 Write a haiku about {{topic}}.
templates/ab/prompt2.jinja2 Write an incredibly hilarious haiku about {{topic}}. So funny!
Puede proporcionar variables para estas indicaciones construyendo un archivo .jsonl con los parámetros requeridos. En este caso, debemos asegurarnos de que {{topic}} se tenga en cuenta.
Aquí hay un ejemplo .jsonl que podría funcionar.
data/ab_example.jsonl{ "id" : 0 , "prompt_args" : { "topic" : " star wars " }}
{ "id" : 0 , "prompt_args" : { "topic" : " kittens " }}
{ "id" : 0 , "prompt_args" : { "topic" : " the python programming language " }}
{ "id" : 0 , "prompt_args" : { "topic" : " maths " }}Nota
Todos los argumentos bajo
prompt_argsse pasarán para representar las plantillas de Jinja. Laides obligatoria y puede usarse para identificar grupos en análisis posteriores.
Estamos casi listos para evaluar, pero esta receta requiere una plantilla final Jinja2. Este no se usará para generar un aviso, pero generará un título útil que recuerde al anotador la tarea actual. Aquí hay un ejemplo de tal plantilla.
templates/ab/input.jinja2 A haiku about {{topic}}.
Cuando juntas todas estas plantillas, puedes comenzar a anotar. El siguiente comando inicia la interfaz de anotación y también usa la opción --repeat 4 . Esto asegurará que cada tema se utilizará para generar un aviso al menos 4 veces.
python -m prodigy ab.openai.prompts haiku data/ab_example.jsonl templates/ab/input.jinja2 templates/ab/prompt1.jinja2 templates/ab/prompt2.jinja2 --repeat 5 -F recipes/openai_ab.py
Así es como se ve la interfaz de anotación:
Cuando mire esta interfaz, notará que la plantilla de título se representa y que puede elegir entre dos opciones. Ambas opciones son respuestas de OpenAI que fueron generadas por las dos plantillas de inmediato. También puede ver los prompt_args renderizados en la esquina inferior derecha del menú de elección.
Desde aquí, puede anotar sus ejemplos favoritos y recopilar datos que puedan ayudarlo a decidir qué aviso es mejor.
Una vez que haya terminado de anotar, se le presentará una descripción general de los resultados.
=========================== Evaluation results ===========================
✔ You preferred prompt1.jinja2
prompt1.jinja2 11
prompt2.jinja2 5
Pero también puede obtener las anotaciones sin procesar de la base de datos para su posterior análisis.
python -m prodigy db-out haiku
Hay muchos experimentos de seguimiento interesantes para esto, y muchas formas de adaptar la idea básica a diferentes tareas o conjuntos de datos. También estamos interesados en probar diferentes indicaciones. No está claro cuánto se solicita el formato las anotaciones podrían cambiar las predicciones del modelo, o si hay un mensaje más corto que podría funcionar igual de bien. También queremos ejecutar algunos experimentos de extremo a extremo.
