prodigy openai recipes
1.0.0
Les recettes de ce référentiel sont depuis passées à Prodigy et y sont entretenues. Ils obtiendront bientôt une mise à niveau avec l'avènement de la prise en charge de Spacy-LLM, qui propose de meilleures invites et plusieurs fournisseurs de LLM. C'est pourquoi nous avons choisi d'archiver ce repo, afin que nous puissions nous concentrer sur le maintien directement de ces recettes dans le cadre de Spacy et Prodigy.
Vous pouvez en savoir plus en consultant la section Modèles de grande langue sur les documents.
This repository contains example code on how to combine zero- and few-shot learning with a small annotation effort to obtain a high-quality dataset with maximum efficiency . Plus précisément, nous utilisons de grands modèles de langage disponibles auprès d'OpenAI pour nous fournir un ensemble initial de prédictions, puis avons fait tourner une instance prodige sur notre machine locale pour parcourir ces prédictions et les organiser. Cela nous permet d'obtenir un ensemble de données standard en or assez rapidement et de former un modèle plus petit et supervisé qui correspond à nos besoins exacts et à nos cas d'utilisation.
Assurez-vous d'installer Prodigy ainsi que quelques dépendances Python supplémentaires:
python -m pip install prodigy -f https://[email protected]
python -m pip install -r requirements.txt With XXXX-XXXX-XXXX-XXXX being your personal Prodigy license key.
Ensuite, créez une nouvelle clé API à partir d'Openai.com ou récupérez une nouvelle existante. Enregistrez la clé secrète ainsi que la clé de l'organisation et assurez-vous qu'elles sont disponibles en tant que variables environnementales. For instance, set them in a .env file in the root directory:
OPENAI_ORG = "org-..."
OPENAI_KEY = "sk-..."
ner.openai.correct : NER annotation with zero- or few-shot learning Cette recette marque les prévisions d'entités obtenues à partir d'un modèle grand langage et vous permet de les signaler comme corrects, ou de les organiser manuellement. Cela vous permet de rassembler rapidement un ensemble de données standard en or grâce à un apprentissage zéro ou à quelques coups. It's very much like using the standard ner.correct recipe in Prodi.gy, but we're using GPT-3 as a backend model to make predictions.
python -m prodigy ner.openai.correct dataset filepath labels [--options] -F ./recipes/openai_ner.py| Argument | Taper | Description | Défaut |
|---|---|---|---|
dataset | Str | Ensemble de données Prodigy pour enregistrer des annotations. | |
filepath | Chemin | Path to .jsonl data to annotate. The data should at least contain a "text" field. | |
labels | Str | Liste séparée par des virgules définissant les étiquettes NER que le modèle devrait prédire. | |
--lang , -l | Str | La langue des données d'entrée - sera utilisée pour obtenir un tokenizer pertinent. | "en" |
--segment , -S | bool | Flag à définir lorsque des exemples doivent être divisés en phrases. Par défaut, l'article d'entrée complet est affiché. | False |
--model , -m | Str | Modèle GPT-3 à utiliser pour les prédictions initiales. | "text-davinci-003" |
--prompt_path , -p | Chemin | Path to the .jinja2 prompt template. | ./templates/ner_prompt.jinja2 |
--examples-path , -e | Chemin | Chemin vers des exemples pour aider à définir la tâche. Le fichier peut être un .yml, .yaml ou .json. If set to None , zero-shot learning is applied. | None |
--max-examples , -n | int | Nombre maximum d'exemples à inclure dans l'invite à OpenAI. S'il est réglé sur 0, l'apprentissage zéro est toujours appliqué, même lorsque des exemples sont disponibles. | 2 |
--batch-size , -b | int | Taille du lot des requêtes à envoyer à l'API OpenAI. | 10 |
--verbose , -v | bool | Flag pour imprimer des informations supplémentaires au terminal. | False |
Disons que nous voulons reconnaître les plats, les ingrédients et l'équipement de cuisson à partir de certains textes que nous avons obtenus à partir d'un subreddit de cuisson. Nous enverrons le texte à GPT-3, hébergé par OpenAI, et fournirons une invite d'annotation pour expliquer au modèle de langue le type de prédictions que nous voulons. Quelque chose comme:
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:
...
Nous définissons la définition de cette invite dans un fichier .jinja2 qui décrit également comment ajouter des exemples pour l'apprentissage à quelques coups. You can create your own template and provide it to the recipe with the --prompt-path or -p option. Additionally, with --examples-path or -e you can set the file path of a .y(a)ml or .json file that contains additional examples:
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.pyAprès avoir reçu les résultats de l'API OpenAI, la recette de prodige convertit les prédictions en une tâche d'annotation qui peut être rendue avec Prodigy. La tâche montre même l'invite d'origine ainsi que la réponse brute que nous avons obtenue à partir du modèle de langue.
Ici, nous voyons que le modèle est capable de reconnaître correctement les plats, les ingrédients et l'équipement de cuisson dès le début!
The recipe also offers a --verbose or -v option that includes the exact prompt and response on the terminal as traffic is received. Notez que parce que les demandes de l'API sont par lots, vous devrez peut-être faire défiler un peu pour trouver l'invite actuelle.
À un moment donné, vous remarquerez peut-être une erreur dans les prévisions du modèle de langue Openai. Par exemple, nous avons remarqué une erreur dans la reconnaissance de l'équipement de cuisson dans cet exemple:
Si vous voyez ce type d'erreurs systématiques, vous pouvez diriger les prédictions dans la bonne direction en corrigeant l'exemple, puis en sélectionnant la petite icône "Flag" en haut à droite de l'interface utilisateur Prodigy:
Once you hit accept on the Prodigy interface, the flagged example will be automatically picked up and added to the examples that are sent to the OpenAI API as part of the prompt.
Note
Étant donné que Prodigy lance ces demandes, l'invite sera mise à jour avec un léger retard, après que le prochain lot d'invites sera envoyé à OpenAI. You can experiment with making the batch size (--batch-sizeor-b) smaller to have the change come into effect sooner, but this might negatively impact the speed of the annotation workflow.
ner.openai.fetch : Fetch examples up-front The ner.openai.correct recipe fetches examples from OpenAI while annotating, but we've also included a recipe that can fetch a large batch of examples upfront.
python -m prodigy ner.openai.fetch input_data.jsonl predictions.jsonl " dish,ingredient,equipment " -F ./recipes/ner.py This will create a predictions.jsonl file that can be loaded with the ner.manual recipe.
Notez que l'API OpenAI peut renvoyer les erreurs "429 trop de demande" lors de la demande de trop de données à la fois - dans ce cas, il est préférable de vous assurer que vous ne demandez que 100 exemples à la fois.
After you've curated a set of predictions, you can export the results with db-out :
python -m prodigy db-out my_ner_data > ner_data.jsonlLe format des annotations exportées contient toutes les données dont vous avez besoin pour former un modèle plus petit en aval. Chaque exemple de l'ensemble de données contient le texte d'origine, les jetons, les annotations de span dénotant les entités, etc.
You can also export the data to spaCy's binary format, using data-to-spacy . This format lets you load in the annotations as spaCy Doc objects, which can be convenient for further conversion. The data-to-spacy command also makes it easy to train an NER model with spaCy. Vous exportez d'abord les données, en spécifiant les données de train comme 20% du total:
python -m prodigy data-to-spacy ./data/annotations/ --ner my_ner_data -es 0.2Ensuite, vous pouvez entraîner un modèle avec Spacy ou Prodigy:
python -m spacy train ./data/annotations/config.cfg --paths.train ./data/annotations/train.spacy --paths.dev ./data/annotations/dev.spacy -o ner-model This will save a model to the ner-model/ directory.
We've also included an experimental script to load in the .spacy binary format and train a model with the HuggingFace transformers library. Vous pouvez utiliser les mêmes données que vous venez d'exporter et exécuter le script comme ceci:
# 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 The resulting model will be saved to the hf-ner-model/ directory.
textcat.openai.correct : Textcat annotation with zero- or few-shot learningCette recette nous permet de classer les textes plus rapidement à l'aide d'un modèle grand langage. Il fournit également une «raison» pour expliquer pourquoi une étiquette particulière a été choisie.
python -m prodigy textcat.openai.correct dataset filepath labels [--options] -F ./recipes/openai_textcat.py| Argument | Taper | Description | Défaut |
|---|---|---|---|
dataset | Str | Ensemble de données Prodigy pour enregistrer des annotations. | |
filepath | Chemin | Path to .jsonl data to annotate. The data should at least contain a "text" field. | |
labels | Str | Liste séparée par des virgules définissant les étiquettes de catégorisation de texte que le modèle devrait prédire. | |
--lang , -l | Str | La langue des données d'entrée - sera utilisée pour obtenir un tokenizer pertinent. | "en" |
--segment , -S | bool | Flag à définir lorsque des exemples doivent être divisés en phrases. Par défaut, l'article d'entrée complet est affiché. | False |
--model , -m | Str | Modèle GPT-3 à utiliser pour les prédictions initiales. | "text-davinci-003" |
--prompt-path , -p | Chemin | Path to the .jinja2 prompt template. | ./templates/textcat_prompt.jinja2 |
--examples-path , -e | Chemin | Chemin vers des exemples pour aider à définir la tâche. Le fichier peut être un .yml, .yaml ou .json. If set to None , zero-shot learning is applied. | None |
--max-examples , -n | int | Nombre maximum d'exemples à inclure dans l'invite à OpenAI. S'il est réglé sur 0, l'apprentissage zéro est toujours appliqué, même lorsque des exemples sont disponibles. | 2 |
--batch-size , -b | int | Taille du lot des requêtes à envoyer à l'API OpenAI. | 10 |
--exclusive-classes , -E | bool | Flag pour rendre la tâche de classification exclusive. | False |
--verbose , -v | bool | Flag pour imprimer des informations supplémentaires au terminal. | False |
The textcat recipes can be used for binary, multiclass, and multilabel text categorization. You can set this by passing the appropriate number of labels in the --labels parameter; Par exemple, passer une seule étiquette le transforme en classification binaire et ainsi de suite. Nous parlerons de chacun dans les sections de la procédure.
Supposons que nous voulons savoir si un commentaire Reddit particulier parle d'une recette alimentaire. Nous enverrons le texte à GPT-3 et fournirons une invite qui instruit les prédictions que nous voulons.
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:
Pour la classification binaire, nous voulons que GPT-3 rende "accepter" si un texte donné est une recette alimentaire et "rejeter" autrement. La suggestion de GPT-3 est ensuite affichée en bonne place dans l'interface utilisateur. We can press the ACCEPT (check mark) button to include the text as a positive example or press the REJECT (cross mark) button if it is a negative example.
python -m prodigy textcat.openai.correct my_binary_textcat_data data/reddit_r_cooking_sample.jsonl --labels recipe -F recipes/openai_textcat.py
Maintenant, supposons que nous voulons classer les commentaires de Reddit comme une recette, une rétroaction ou une question. Nous pouvons écrire l'invite suivante:
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:
Then, we can use this recipe to handle multilabel and multiclass cases by passing the three labels to the --labels parameter. We should also set the --exclusive-classes flag to render a single-choice UI:
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
Nous écrivons ces invites comme un modèle .jinja2 qui peut également prendre des exemples pour l'apprentissage à quelques coups. You can create your own template and provide it to the recipe with the --prompt-path or -p option. Additionally, with --examples-path or -e you can set the file path of a .y(a)ml or .json file that contains additional examples. Vous pouvez également ajouter un contexte dans ces exemples car nous l'avons observé pour améliorer la sortie:
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 Semblable à la recette NER, cette recette convertit également les prédictions en une tâche d'annotation qui peut être rendue avec Prodigy. For binary classification, we use the classification interface with custom HTML elements, while for multilabel or multiclass text categorization, we use the choice annotation interface. Notez que nous incluons l'invite d'origine et la réponse OpenAI dans l'interface utilisateur.
Lastly, you can use the --verbose or -v flag to show the exact prompt and response on the terminal. Notez que parce que les demandes de l'API sont par lots, vous devrez peut-être faire défiler un peu pour trouver l'invite actuelle.
Semblable aux recettes NER, vous pouvez également diriger les prédictions dans la bonne direction en corrigeant l'exemple, puis en sélectionnant la petite icône "drapeau" en haut à droite de l'interface utilisateur Prodigy:
Once you hit the accept button on the Prodigy interface, the flagged example will be picked up and added to the few-shot examples sent to the OpenAI API as part of the prompt.
Note
Étant donné que Prodigy lance ces demandes, l'invite sera mise à jour avec un léger retard, après que le prochain lot d'invites sera envoyé à OpenAI. You can experiment with making the batch size (--batch-sizeor-b) smaller to have the change come into effect sooner, but this might negatively impact the speed of the annotation workflow.
textcat.openai.fetch : Fetch text categorization examples up-front The textcat.openai.fetch recipe allows us to fetch a large batch of examples upfront. Ceci est utile lorsque vous êtes avec des données hautement définies et ne vous intéresse que par de rares exemples.
python -m prodigy textcat.openai.fetch input_data.jsonl predictions.jsonl --labels Recipe -F ./recipes/openai_textcat.py This will create a predictions.jsonl file that can be loaded with the textcat.manual recipe.
Notez que l'API OpenAI peut renvoyer les erreurs "429 trop de demande" lors de la demande de trop de données à la fois - dans ce cas, il est préférable de vous assurer que vous ne demandez que 100 exemples à la fois et jetez un œil aux limites de taux de l'API.
The textcat.openai.fetch recipe is suitable for working with datasets where there is severe class imbalance. Habituellement, vous souhaitez trouver des exemples de la classe rare plutôt que d'annoter un échantillon aléatoire. À partir de là, vous voulez les échantillonner pour former un modèle décent et ainsi de suite.
C'est là que de grands modèles de langue comme Openai pourraient aider.
À l'aide de l'ensemble de données Reddit R / Cooking, nous avons incité OpenAI à rechercher des commentaires qui ressemblent à une recette alimentaire. Instead of annotating 10,000 examples, we ran textcat.openai.fetch and obtained 145 positive classes. Sur ces 145 exemples, 114 se sont avérés être de vrais positifs (79% de précision). Nous avons ensuite vérifié 1 000 exemples négatifs et trouvé 12 cas faux négatifs (rappel à 98%).
Idéalement, une fois que nous avons complètement annoté l'ensemble de données, nous pouvons former un modèle supervisé qui est mieux à utiliser que de compter sur des prévisions de production zéro pour la production. Le coût de fonctionnement est faible et il est plus facile à gérer.
After you've curated a set of predictions, you can export the results with db-out :
python -m prodigy db-out my_textcat_data > textcat_data.jsonlLe format des annotations exportées contient toutes les données dont vous avez besoin pour former un modèle plus petit en aval. Chaque exemple de l'ensemble de données contient le texte d'origine, les jetons, les annotations de span dénotant les entités, etc.
You can also export the data to spaCy's binary format, using data-to-spacy . This format lets you load in the annotations as spaCy Doc objects, which can be convenient for further conversion. The data-to-spacy command also makes it easy to train a text categorization model with spaCy. Vous exportez d'abord les données, en spécifiant les données de train comme 20% du 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.2Ensuite, vous pouvez entraîner un modèle avec Spacy ou Prodigy:
python -m spacy train ./data/annotations/config.cfg --paths.train ./data/annotations/train.spacy --paths.dev ./data/annotations/dev.spacy -o textcat-model This will save a model to the textcat-model/ directory.
terms.openai.fetch : Fetch phrases and terms based on a queryCette recette génère des termes et des phrases obtenus à partir d'un modèle grand langage. Ces termes peuvent être organisés et transformés en fichiers de motifs, ce qui peut aider avec les tâches d'annotation en aval.
python -m prodigy terms.openai.fetch query filepath [--options] -F ./recipes/openai_terms.py| Argument | Taper | Description | Défaut |
|---|---|---|---|
query | Str | Requête à envoyer à Openai | |
output_path | Chemin | Chemin pour enregistrer la sortie | |
--seeds , -s | Str | Une ou plusieurs phrases de semences séparées par des virgules. | "" |
--n , -n | int | Nombre minimum d'articles à générer | 100 |
--model , -m | Str | Modèle GPT-3 à utiliser pour l'achèvement | "text-davinci-003" |
--prompt-path , -p | Chemin | Chemin vers Jinja2 Modèle d'invite | templates/terms_prompt.jinja2 |
--verbose , -v | bool | Imprimez des informations supplémentaires au terminal | False |
--resume , -r | bool | Reprendre en chargeant dans des exemples de texte à partir du fichier de sortie | False |
--progress , -pb | bool | Imprimez la progression de la recette. | False |
--temperature , -t | flotter | Param de température Openai | 1.0 |
--top-p , --tp | flotter | Openai top_p param | 1.0 |
--best-of , -bo | int | Openai best_of param " | 10 |
--n-batch , -nb | int | Param de taille du lot Openai | 10 |
--max-tokens , -mt | int | Jetons max à générer par appel | 100 |
Supposons que vous soyez intéressé à détecter les astuces de skateboard dans le texte, alors vous voudrez peut-être commencer par une liste de termes de trucs connus. Vous voudrez peut-être commencer par la requête suivante:
# 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.pyCela générera une invite pour OpenAI qui demande à essayer de générer au moins 100 exemples de "tours de skate". Il y a une limite supérieure à la quantité de jetons qui peuvent être générés par OpenAI, mais cette recette essaiera de continuer à collecter des termes jusqu'à ce qu'elle atteigne le montant spécifié.
You can choose to make the query more elaborate if you want to try to be more precise, but you can alternatively also choose to add some seed terms via --seeds . Ceux-ci agiront comme des exemples de départ pour aider à diriger Openai dans la bonne direction.
# 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 Collecting many examples can take a while, so it can be helpful to show the progress, via --progress as requests are sent.
# 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.pyAprès avoir collecté quelques exemples, vous voudrez peut-être en générer plus. Vous pouvez choisir de continuer à partir d'un fichier de sortie précédent. Cela réutilisera efficacement ces exemples sous forme de graines pour l'invite à 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 When the recipe is done, you'll have a tricks.jsonl file that has contents that look like this:
{ "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 " }}
... You now have a tricks.jsonl file on disk that contains skateboard tricks, but you cannot assume that all of these will be accurate. The next step would be to review the terms and you can use the textcat.manual recipe that comes with Prodigy for that.
# The tricks.jsonl was fetched from OpenAI beforehand
python -m prodigy textcat.manual skateboard-tricks-list tricks.jsonl --label skateboard-tricksCela génère une interface qui ressemble à ceci:
You can manually accept or reject each example and when you're done annotating you can export the annotated text into a patterns file via the terms.to-patterns recipe.
# Generate a `patterns.jsonl` file.
python -m prodigy terms.to-patterns skateboard-tricks-list patterns.jsonl --label skateboard-tricks --spacy-model blank:en When the recipe is done, you'll have a patterns.jsonl file that has contents that look like this:
{ "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 a une limite dure à la taille rapide. Vous ne pouvez pas avoir une invite de plus de 4079 jetons. Malheureusement, cela signifie qu'il y a une limite à la taille des listes de terme que vous pouvez générer. La recette rapportera une erreur lorsque cela se produit, mais il est bon d'être conscient de cette limitation.
ab.openai.prompts : A/B evaluation of promptsL'objectif de cette recette est de permettre rapidement à quelqu'un de comparer la qualité des sorties de deux invites d'une manière quantifiable et aveugle.
python -m prodigy ab.openai.prompts dataset inputs_path display_template_path prompt1_template_path prompt2_template_path [--options] -F ./recipes/openai_ab.py| Argument | Taper | Description | Défaut |
|---|---|---|---|
dataset | Str | Ensemble de données Prodigy pour enregistrer des réponses dans | |
inputs_path | Chemin | Chemin vers les entrées JSONL | |
display_template_path | Chemin | Modèle pour résumer les arguments | |
prompt1_template_path | Chemin | Chemin vers le premier modèle d'invite Jinja2 | |
prompt2_template_path | Chemin | Chemin vers le deuxième modèle d'invite Jinja2 | |
--model , -m | Str | Modèle GPT-3 à utiliser pour l'achèvement | "text-davinci-003" |
--batch-size , -b | int | Taille du lot à envoyer à l'API Openai | 10 |
--verbose , -v | bool | Imprimez des informations supplémentaires au terminal | False |
--no-random , -NR | bool | Ne randomisez pas quelle annotation est indiquée comme correcte | False |
--repeat , -r | int | À quelle fréquence envoyer la même invite à Openai | 1 |
Par exemple, essayons de générer des haïkus humoristiques. Pour ce faire, nous devons d'abord construire deux fichiers Jinja qui représentent l'invite à envoyer à OpenAI.
templates/ab/prompt1.jinja2 Write a haiku about {{topic}}.
templates/ab/prompt2.jinja2 Write an incredibly hilarious haiku about {{topic}}. So funny!
Vous pouvez fournir des variables pour ces invites en construisant un fichier .jsonl avec les paramètres requis. In this case we need to make sure that {{topic}} is accounted for.
Here's an example .jsonl file that could work.
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 " }}Note
All the arguments under
prompt_argswill be passed to render the jinja templates. Theidis mandatory and can be used to identify groups in later analysis.
Nous sommes presque prêts à évaluer, mais cette recette nécessite un dernier modèle Jinja2. Celui-ci ne sera pas utilisé pour générer une invite, mais il générera un titre utile qui rappelle à l'annotateur la tâche actuelle. Voici un exemple d'un tel modèle.
templates/ab/input.jinja2 A haiku about {{topic}}.
Lorsque vous assemblez tous ces modèles, vous pouvez commencer à annoter. The command below starts the annotation interface and also uses the --repeat 4 option. Cela garantira que chaque sujet sera utilisé pour générer une invite au moins 4 fois.
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
C'est à quoi ressemble l'interface d'annotation:
Lorsque vous regardez cette interface, vous remarquerez que le modèle de titre est rendu et que vous pouvez choisir parmi deux options. Les deux options sont des réponses d'OpenAI qui ont été générées par les deux modèles rapides. You can also see the prompt_args rendered in the lower right corner of the choice menu.
De là, vous pouvez annoter vos exemples préférés et recueillir des données qui pourraient vous aider à décider de quelle invite est la meilleure.
Une fois que vous avez terminé, vous avez été présenté avec un aperçu des résultats.
=========================== Evaluation results ===========================
✔ You preferred prompt1.jinja2
prompt1.jinja2 11
prompt2.jinja2 5
Mais vous pouvez également récupérer les annotations brutes de la base de données pour une analyse plus approfondie.
python -m prodigy db-out haiku
Il y a beaucoup d'expériences de suivi intéressantes à cela et de nombreuses façons d'adapter l'idée de base à différentes tâches ou ensembles de données. Nous sommes également intéressés à essayer différentes invites. On ne sait pas dans quelle mesure le format dans lequel le format est demandé pourrait modifier les prédictions du modèle, ou s'il y a une invite plus courte qui pourrait aussi bien fonctionner. Nous voulons également exécuter des expériences de bout en bout.
