prodigy openai recipes
1.0.0
As receitas deste repositório se mudaram para Prodigy e estão sendo mantidas lá. Em breve, eles terão uma atualização com o advento do suporte Spacy-LLM, que apresenta melhores prompts e vários fornecedores de LLM. É por isso que optamos por arquivar esse repositório, para que possamos nos concentrar em manter essas receitas como parte do Spacy e Prodigy diretamente.
Você pode aprender mais verificando a seção de modelos de idiomas grandes nos documentos.
Esse repositório contém código de exemplo sobre como combinar aprendizado zero e de poucos anos com um pequeno esforço de anotação para obter um conjunto de dados de alta qualidade com a máxima eficiência . Especificamente, usamos grandes modelos de idiomas disponíveis no OpenAI para nos fornecer um conjunto inicial de previsões e, em seguida, giramos uma instância prodígio em nossa máquina local para passar por essas previsões e curá -las. Isso nos permite obter um conjunto de dados padrão de ouro rapidamente e treinar um modelo menor e supervisionado que atenda às nossas necessidades e casos de uso exatos.
Certifique -se de instalar o Prodigy e algumas dependências adicionais do Python:
python -m pip install prodigy -f https://[email protected]
python -m pip install -r requirements.txt Com XXXX-XXXX-XXXX-XXXX sendo sua chave de licença de prodígio pessoal.
Em seguida, crie uma nova chave da API no OpenAi.com ou busque uma existente. Registre a chave secreta e a chave da organização e verifique se elas estão disponíveis como variáveis ambientais. Por exemplo, defina -os em um arquivo .env no diretório raiz:
OPENAI_ORG = "org-..."
OPENAI_KEY = "sk-..."
ner.openai.correct : NER Anotation com aprendizado zero ou poucos Esta receita marca as previsões de entidades obtidas de um modelo de idioma grande e permite que você as sinalize como corretas ou para selecioná -las manualmente. Isso permite que você colete rapidamente um conjunto de dados padrão de ouro através de um aprendizado zero ou com poucos anos. É muito parecido com o uso da receita ner.correct padrão no Prodi.Gy, mas estamos usando o GPT-3 como modelo de back-end para fazer previsões.
python -m prodigy ner.openai.correct dataset filepath labels [--options] -F ./recipes/openai_ner.py| Argumento | Tipo | Descrição | Padrão |
|---|---|---|---|
dataset | str | DataSet prodigy para salvar anotações. | |
filepath | Caminho | Caminho para dados .jsonl para anotar. Os dados devem pelo menos conter um campo "text" . | |
labels | str | Lista separada por vírgula que define as etiquetas NER que o modelo deve prever. | |
--lang , -l | str | Idioma dos dados de entrada - será usado para obter um tokenizador relevante. | "en" |
--segment , -S | bool | Sinalizador para definir quando exemplos devem ser divididos em frases. Por padrão, o artigo de entrada completo é mostrado. | False |
--model , -m | str | Modelo GPT-3 a ser usado para previsões iniciais. | "text-davinci-003" |
--prompt_path , -p | Caminho | Caminho para o modelo .jinja2 Prompt. | ./templates/ner_prompt.jinja2 |
--examples-path , -e | Caminho | Caminho para exemplos para ajudar a definir a tarefa. O arquivo pode ser um .yml, .yaml ou .json. Se definido como None , o aprendizado de tiro zero é aplicado. | None |
--max-examples , -n | int | Número máximo de exemplos a serem incluídos no prompt para o OpenAI. Se definido como 0, o aprendizado de tiro zero é sempre aplicado, mesmo quando os exemplos estão disponíveis. | 2 |
--batch-size , -b | int | Tamanho do lote das consultas para enviar para a API OpenAI. | 10 |
--verbose , -v | bool | Sinalizador para imprimir informações extras para o terminal. | False |
Digamos que queremos reconhecer pratos, ingredientes e equipamentos de cozinha de algum texto que obtivemos de um subreddit de culinária. Enviaremos o texto para o GPT-3, hospedado pelo OpenAI, e forneceremos um prompt de anotação para explicar ao modelo de idioma o tipo de previsões 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 a definição desse prompt em um arquivo .jinja2, que também descreve como anexar exemplos à aprendizagem de poucos anos. Você pode criar seu próprio modelo e fornecer -o à receita com a opção --prompt-path ou -p . Além disso, com --examples-path ou -e você pode definir o caminho do arquivo de um arquivo .y (a) ml ou .json que contém exemplos adicionais:
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.pyDepois de receber os resultados da API OpenAI, a receita do Prodigy converte as previsões em uma tarefa de anotação que pode ser renderizada com o Prodigy. A tarefa mostra o prompt original e a resposta bruta que obtivemos do modelo de idioma.
Aqui, vemos que o modelo é capaz de reconhecer corretamente pratos, ingredientes e equipamentos de cozinha desde o início!
A receita também oferece uma opção --verbose ou -v que inclui o prompt exato e a resposta no terminal à medida que o tráfego é recebido. Observe que, como as solicitações para a API estão em lote, talvez seja necessário rolar um pouco para encontrar o prompt atual.
Em algum momento, você pode notar um erro nas previsões do modelo de idioma do Openai. Por exemplo, notamos um erro no reconhecimento de equipamentos de cozinha neste exemplo:
Se você vir esse tipo de erro sistemático, poderá orientar as previsões na direção certa, corrigindo o exemplo e selecionando o pequeno ícone "sinalizador" no canto superior direito da interface do usuário:
Depois de acertar a aceitação na interface prodigy, o exemplo sinalizado será retirado automaticamente e adicionado aos exemplos enviados à API do OpenAI como parte do prompt.
Observação
Como esses lotes prodigiosos essas solicitações, o prompt será atualizado com um pequeno atraso, depois que o próximo lote de instruções é enviado ao OpenAI. Você pode experimentar o tamanho do lote (--batch-sizeou-b) menor para que a alteração entre em vigor mais cedo, mas isso pode afetar negativamente a velocidade do fluxo de trabalho da anotação.
ner.openai.fetch : Exemplos de busca adiante A receita ner.openai.correct busca exemplos do OpenAI durante a anotação, mas também incluímos uma receita que pode buscar um grande lote de exemplos antecipadamente.
python -m prodigy ner.openai.fetch input_data.jsonl predictions.jsonl " dish,ingredient,equipment " -F ./recipes/ner.py Isso criará um arquivo predictions.jsonl que pode ser carregado com a receita ner.manual .
Observe que a API do OpenAI pode retornar erros "429 muitos solicitando" ao solicitar muitos dados de uma só vez - nesse caso, é melhor garantir que você solicite apenas 100 exemplos de cada vez.
Depois de selecionar um conjunto de previsões, você pode exportar os resultados com db-out :
python -m prodigy db-out my_ner_data > ner_data.jsonlO formato das anotações exportadas contém todos os dados necessários para treinar um modelo menor a jusante. Cada exemplo no conjunto de dados contém o texto original, os tokens, as anotações de abrangência que denotam as entidades, etc.
Você também pode exportar os dados para o formato binário da Spacy, usando data-to-spacy . Este formato permite carregar nas anotações como objetos Doc Spacy, que podem ser convenientes para uma conversão adicional. O comando data-to-spacy também facilita o treinamento de um modelo NER com Spacy. Primeiro, você exporta os dados, especificando os dados do trem como 20% do total:
python -m prodigy data-to-spacy ./data/annotations/ --ner my_ner_data -es 0.2Então você pode treinar um modelo com 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 Isso salvará um modelo no ner-model/ diretório.
Também incluímos um script experimental para carregar no formato binário .spacy e treinar um modelo com a Biblioteca transformers do Huggingface. Você pode usar os mesmos dados que você acabou de exportar e executar o script como este:
# 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 O modelo resultante será salvo no diretório hf-ner-model/ .
textcat.openai.correct : Anotação de textcat com aprendizado zero ou poucosEsta receita nos permite classificar os textos mais rapidamente com a ajuda de um grande modelo de idioma. Ele também fornece uma "razão" para explicar por que um rótulo específico foi escolhido.
python -m prodigy textcat.openai.correct dataset filepath labels [--options] -F ./recipes/openai_textcat.py| Argumento | Tipo | Descrição | Padrão |
|---|---|---|---|
dataset | str | DataSet prodigy para salvar anotações. | |
filepath | Caminho | Caminho para dados .jsonl para anotar. Os dados devem pelo menos conter um campo "text" . | |
labels | str | Lista separada por vírgula que define os rótulos de categorização de texto que o modelo deve prever. | |
--lang , -l | str | Idioma dos dados de entrada - será usado para obter um tokenizador relevante. | "en" |
--segment , -S | bool | Sinalizador para definir quando exemplos devem ser divididos em frases. Por padrão, o artigo de entrada completo é mostrado. | False |
--model , -m | str | Modelo GPT-3 a ser usado para previsões iniciais. | "text-davinci-003" |
--prompt-path , -p | Caminho | Caminho para o modelo .jinja2 Prompt. | ./templates/textcat_prompt.jinja2 |
--examples-path , -e | Caminho | Caminho para exemplos para ajudar a definir a tarefa. O arquivo pode ser um .yml, .yaml ou .json. Se definido como None , o aprendizado de tiro zero é aplicado. | None |
--max-examples , -n | int | Número máximo de exemplos a serem incluídos no prompt para o OpenAI. Se definido como 0, o aprendizado de tiro zero é sempre aplicado, mesmo quando os exemplos estão disponíveis. | 2 |
--batch-size , -b | int | Tamanho do lote das consultas para enviar para a API OpenAI. | 10 |
--exclusive-classes , -E | bool | Sinalizador para tornar a tarefa de classificação exclusiva. | False |
--verbose , -v | bool | Sinalizador para imprimir informações extras para o terminal. | False |
As receitas textcat podem ser usadas para categorização de texto binária, multiclasse e multilabel. Você pode definir isso passando o número apropriado de rótulos no parâmetro --labels ; Por exemplo, passar um único rótulo o transforma em classificação binária e assim por diante. Falaremos sobre cada um nas seções de processo.
Suponha que queremos saber se um comentário do Reddit em particular fala sobre uma receita de comida. Enviaremos o texto para o GPT-3 e forneceremos um aviso que instrua as previsões 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 classificação binária, queremos que o GPT-3 retorne "aceite" se um determinado texto for uma receita de alimentos e "rejeitar" caso contrário. A sugestão do GPT-3 é então exibida com destaque na interface do usuário. Podemos pressionar o botão Aceitar (marca de verificação) para incluir o texto como um exemplo positivo ou pressionar o botão Rejeição (Marca Cruzada), se for um exemplo negativo.
python -m prodigy textcat.openai.correct my_binary_textcat_data data/reddit_r_cooking_sample.jsonl --labels recipe -F recipes/openai_textcat.py
Agora, suponha que queremos classificar os comentários do Reddit como uma receita, um feedback ou uma pergunta. Podemos escrever o seguinte prompt:
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:
Em seguida, podemos usar esta receita para lidar com casos multilabel e multiclasse passando os três rótulos para o parâmetro --labels . Também devemos definir o sinalizador --exclusive-classes para renderizar uma interface do usuário de escolha única:
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
Escrevemos esses avisos como um modelo .jinja2 que também pode receber exemplos para o aprendizado de poucos anos. Você pode criar seu próprio modelo e fornecer -o à receita com a opção --prompt-path ou -p . Além disso, com --examples-path ou -e você pode definir o caminho do arquivo de um arquivo .y (a) ml ou .json que contém exemplos adicionais. Você também pode adicionar contexto nesses exemplos, pois o observamos para melhorar a saída:
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 Semelhante à receita NER, esta receita também converte as previsões em uma tarefa de anotação que pode ser renderizada com prodígio. Para classificação binária, usamos a interface classification com elementos HTML personalizados, enquanto para categorização de texto multilabel ou multiclasse, usamos a interface de anotação choice . Observe que incluímos o prompt original e a resposta do OpenAI na interface do usuário.
Por fim, você pode usar o sinalizador --verbose ou -v para mostrar o prompt exato e a resposta no terminal. Observe que, como as solicitações para a API estão em lote, talvez seja necessário rolar um pouco para encontrar o prompt atual.
Semelhante às receitas do NER, você também pode orientar as previsões na direção certa, corrigindo o exemplo e selecionando o pequeno ícone "sinalizador" no canto superior direito da interface do usuário do Prodigy:
Depois de pressionar o botão Aceitar na interface prodigy, o exemplo sinalizado será capturado e adicionado aos exemplos de poucos tiros enviados à API do Openai como parte do prompt.
Observação
Como esses lotes prodigiosos essas solicitações, o prompt será atualizado com um pequeno atraso, depois que o próximo lote de instruções é enviado ao OpenAI. Você pode experimentar o tamanho do lote (--batch-sizeou-b) menor para que a alteração entre em vigor mais cedo, mas isso pode afetar negativamente a velocidade do fluxo de trabalho da anotação.
textcat.openai.fetch : Exemplos de categorização de texto buscar A receita textcat.openai.fetch nos permite buscar um grande lote de exemplos antecipadamente. Isso é útil quando você está com dados altamente imbalançados e interessado apenas em exemplos raros.
python -m prodigy textcat.openai.fetch input_data.jsonl predictions.jsonl --labels Recipe -F ./recipes/openai_textcat.py Isso criará um arquivo predictions.jsonl que pode ser carregado com a receita textcat.manual .
Observe que a API do OpenAI pode retornar "429 muitos erros de solicitação" ao solicitar muitos dados de uma só vez - nesse caso, é melhor garantir que você solicite apenas 100 exemplos de cada vez e dar uma olhada nos limites da taxa da API.
A receita textcat.openai.fetch é adequada para trabalhar com conjuntos de dados onde há um desequilíbrio grave de classe. Geralmente, você deseja encontrar exemplos da classe rara, em vez de anotar uma amostra aleatória. A partir daí, você deseja apoiá -los para treinar um modelo decente e assim por diante.
É aqui que grandes modelos de idiomas como o OpenAI podem ajudar.
Usando o conjunto de dados Reddit R/Cooking, solicitamos o OpenAI a procurar comentários que se assemelhem a uma receita de comida. Em vez de anotar 10.000 exemplos, executamos textcat.openai.fetch e obtivemos 145 classes positivas. Desses 145 exemplos, 114 acabaram sendo verdadeiros positivos (79% de precisão). Em seguida, verificamos 1.000 exemplos negativos e encontramos 12 casos falsos negativos (recall de 98%).
Idealmente, uma vez que anotamos totalmente o conjunto de dados, podemos treinar um modelo supervisionado melhor para usar do que confiar em previsões de tiro zero para produção. O custo de corrida é baixo e é mais fácil de gerenciar.
Depois de selecionar um conjunto de previsões, você pode exportar os resultados com db-out :
python -m prodigy db-out my_textcat_data > textcat_data.jsonlO formato das anotações exportadas contém todos os dados necessários para treinar um modelo menor a jusante. Cada exemplo no conjunto de dados contém o texto original, os tokens, as anotações de abrangência que denotam as entidades, etc.
Você também pode exportar os dados para o formato binário da Spacy, usando data-to-spacy . Este formato permite carregar nas anotações como objetos Doc Spacy, que podem ser convenientes para uma conversão adicional. O comando data-to-spacy também facilita o treinamento de um modelo de categorização de texto com Spacy. Primeiro, você exporta os dados, especificando os dados do trem como 20% do 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.2Então você pode treinar um modelo com 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 Isso salvará um modelo no textcat-model/ .
terms.openai.fetch : busca frases e termos com base em uma consultaEsta receita gera termos e frases obtidas de um grande modelo de idioma. Esses termos podem ser selecionados e transformados em arquivos de padrões, o que pode ajudar nas tarefas de anotação a jusante.
python -m prodigy terms.openai.fetch query filepath [--options] -F ./recipes/openai_terms.py| Argumento | Tipo | Descrição | Padrão |
|---|---|---|---|
query | str | Consulta para enviar para o Openai | |
output_path | Caminho | Caminho para salvar a saída | |
--seeds , -s | str | Uma ou mais frases de sementes separadas por vírgula. | "" |
--n , -n | int | Número mínimo de itens para gerar | 100 |
--model , -m | str | Modelo GPT-3 a ser usado para conclusão | "text-davinci-003" |
--prompt-path , -p | Caminho | Caminho para Jinja2 Modelo Prompt | templates/terms_prompt.jinja2 |
--verbose , -v | bool | Imprima informações extras para o terminal | False |
--resume , -r | bool | Retomar carregando exemplos de texto do arquivo de saída | False |
--progress , -pb | bool | Imprimir progresso da receita. | False |
--temperature , -t | flutuador | Param de temperatura OpenAI | 1.0 |
--top-p , --tp | flutuador | OpenAi top_p param | 1.0 |
--best-of , -bo | int | Openai best_of param " | 10 |
--n-batch , -nb | int | Param de tamanho de lote openai | 10 |
--max-tokens , -mt | int | Tokens máximos para gerar por chamada | 100 |
Suponha que você esteja interessado em detectar truques de skate em texto, então convém começar com uma lista de truques conhecidos. Você pode querer começar com a seguinte 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.pyIsso gerará um aviso para o OpenAI que pede para tentar gerar pelo menos 100 exemplos de "truques de skate". Há um limite superior para a quantidade de tokens que pode ser gerada pelo OpenAI, mas esta receita tentará continuar coletando termos até atingir o valor especificado.
Você pode optar por tornar a consulta mais elaborada se quiser tentar ser mais precisa, mas, alternativamente, também pode optar por adicionar alguns termos de sementes via --seeds . Isso atuará como exemplos iniciais para ajudar a dirigir o OpenAI na direção certa.
# 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 A coleta de muitos exemplos pode demorar um pouco, por isso pode ser útil mostrar o progresso, via --progress à medida que as solicitações são enviadas.
# 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.pyDepois de coletar alguns exemplos, você pode querer gerar mais. Você pode optar por continuar em um arquivo de saída anterior. Isso reutilizará efetivamente esses exemplos como sementes para o prompt para o 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 Quando a receita estiver concluída, você terá um tricks.jsonl arquivo com conteúdo que se parece com o seguinte:
{ "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 " }}
... Agora você tem um tricks.jsonl no disco que contém truques de skate, mas não pode assumir que tudo isso será preciso. A próxima etapa seria revisar os termos e você pode usar a receita textcat.manual que acompanha o Prodigy para isso.
# The tricks.jsonl was fetched from OpenAI beforehand
python -m prodigy textcat.manual skateboard-tricks-list tricks.jsonl --label skateboard-tricksIsso gera uma interface que se parece com o seguinte:
Você pode aceitar ou rejeitar manualmente cada exemplo e, quando terminar de anotar, pode exportar o texto anotado para um arquivo de padrões através da receita 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 Quando a receita estiver concluída, você terá patterns.jsonl arquivo.
{ "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 " }]}
...O OpenAI tem um limite rígido no tamanho rápido. Você não pode ter um rápido maior que 4079 tokens. Infelizmente, isso significa que há um limite para o tamanho das listas de termos que você pode gerar. A receita relatará um erro quando isso acontecer, mas é bom estar ciente dessa limitação.
ab.openai.prompts : Avaliação A/B de PromptsO objetivo desta receita é permitir rapidamente que alguém compare a qualidade das saídas de dois avisos de maneira quantificável e cega.
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 | Descrição | Padrão |
|---|---|---|---|
dataset | str | Conjunto de dados prodigy para salvar respostas em | |
inputs_path | Caminho | Caminho para as entradas JSONL | |
display_template_path | Caminho | Modelo para resumir os argumentos | |
prompt1_template_path | Caminho | Caminho para o primeiro modelo de prompt de Jinja2 | |
prompt2_template_path | Caminho | Caminho para o segundo modelo Jinja2 | |
--model , -m | str | Modelo GPT-3 a ser usado para conclusão | "text-davinci-003" |
--batch-size , -b | int | Tamanho do lote para enviar para o OpenAI API | 10 |
--verbose , -v | bool | Imprima informações extras para o terminal | False |
--no-random , -NR | bool | Não randomize qual anotação é mostrada como correta | False |
--repeat , -r | int | Com que frequência enviar o mesmo prompt para o OpenAI | 1 |
Como exemplo, vamos tentar gerar haikus humorístico. Para fazer isso, precisamos primeiro construir dois arquivos Jinja que representam o prompt para enviar ao OpenAI.
templates/ab/prompt1.jinja2 Write a haiku about {{topic}}.
templates/ab/prompt2.jinja2 Write an incredibly hilarious haiku about {{topic}}. So funny!
Você pode fornecer variáveis para esses avisos construindo um arquivo .jsonl com os parâmetros necessários. Nesse caso, precisamos garantir que {{topic}} seja considerado.
Aqui está um exemplo .jsonl arquivo que poderia 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 " }}Observação
Todos os argumentos em
prompt_argsserão passados para renderizar os modelos Jinja. Oidé obrigatório e pode ser usado para identificar grupos em análise posterior.
Estamos quase prontos para avaliar, mas esta receita requer um modelo final Jinja2. Este não será usado para gerar um prompt, mas gerará um título útil que lembre o anotador da tarefa atual. Aqui está um exemplo desse modelo.
templates/ab/input.jinja2 A haiku about {{topic}}.
Quando você junta todos esses modelos, pode começar a anotar. O comando abaixo inicia a interface de anotação e também usa a opção --repeat 4 . Isso garantirá que cada tópico seja usado para gerar um prompt pelo menos 4 vezes.
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
É assim que a interface de anotação se parece:
Quando você olha para esta interface, você notará que o modelo de título é renderizado e que poderá escolher de duas opções. Ambas as opções são respostas do OpenAI que foram geradas pelos dois modelos de prompt. Você também pode ver os prompt_args renderizados no canto inferior direito do menu Choice.
A partir daqui, você pode anotar seus exemplos favoritos e coletar dados que podem ajudá -lo a decidir sobre qual prompt é o melhor.
Quando terminar de anotar, você receberá uma visão geral dos resultados.
=========================== Evaluation results ===========================
✔ You preferred prompt1.jinja2
prompt1.jinja2 11
prompt2.jinja2 5
Mas você também pode buscar as anotações brutas no banco de dados para análises adicionais.
python -m prodigy db-out haiku
Há muitas experiências interessantes de acompanhamento para isso e muitas maneiras de adaptar a idéia básica a diferentes tarefas ou conjuntos de dados. Também estamos interessados em experimentar instruções diferentes. Não está claro quanto o formato em que as anotações são solicitadas podem alterar as previsões do modelo ou se há um aviso mais curto que possa ter um desempenho tão bom. Também queremos executar alguns experimentos de ponta a ponta.
