Geração de dicas

existir Playground acertou em cheio Gerar permite que você gere prompts a partir da descrição da tarefa,função (matemática)responder cantandoconstruir. Este guia explicará passo a passo como isso funciona.

delineado

A criação de prompts e arquiteturas do zero pode ser demorada, e começar gerando-os pode ajudá-lo a começar rapidamente:

1. chamar a atenção para algo: UsamosdicaIncorporar práticas recomendadas para gerar ou aprimorar dicas.
2. construir: Usamosmeta-arquiteturaGerar JSON válido e sintaxe de função.

Atualmente, usamos metaprompts e arquiteturas, mas, no futuro, poderemos integrar técnicas mais avançadas, como DSPy responder cantando "Descida de gradiente".

chamar a atenção para algo

dica Oriente o modelo para criar ótimos prompts ou melhorar os existentes com base na descrição da tarefa. Engenharia de pontasPráticas recomendadas e experiência do usuário no mundo real.

Usamos meta pistas específicas para diferentes tipos de saída (por exemplo, áudio) para garantir que as pistas geradas estejam em conformidade com o formato esperado.

dica

meta-dica textual

from openai import OpenAI



cliente = OpenAI()

META_PROMPT = """
Gerar um prompt detalhado do sistema com base na descrição da tarefa ou nos prompts existentes para orientar efetivamente o modelo de linguagem durante a tarefa.

Diretrizes do #

- Entenda a tarefa: capture os principais objetivos, metas, requisitos, restrições e resultados esperados.
- Alterações mínimas: se um prompt existente for fornecido, melhore-o somente se for simples. Para prompts complexos, aumente a clareza e adicione os elementos que faltam sem alterar a estrutura original.
- RACIOCÍNIO ANTES DA CONCLUSÃO**: Incentive as etapas de raciocínio antes de tirar conclusões. Cuidado! Se um exemplo fornecido pelo usuário tiver raciocínio antes da conclusão, inverta a ordem! Nunca comece com uma conclusão.
    - Ordem de raciocínio: aponte para as seções de raciocínio e conclusão do prompt (por nome de campo) para determinar a ordem de conclusão, invertendo-a se necessário.
    - A conclusão, classificação ou resultado deve sempre aparecer por último.
- Exemplos: se for útil, inclua exemplos de alta qualidade, usando [colchetes] como espaços reservados para elementos complexos.
   - Considere quais exemplos incluir, quantos e se eles são complexos o suficiente para exigir espaços reservados.
- Claro e conciso: use uma linguagem clara e específica. Evite diretivas desnecessárias ou declarações vazias.
- Formatação: use os recursos do Markdown para melhorar a legibilidade. Não use blocos de código ```, a menos que seja explicitamente solicitado.
- Preserve o conteúdo do usuário: se as tarefas de entrada ou os prompts incluírem instruções ou exemplos extensos, mantenha-os o mais completos possível. Se o conteúdo for ambíguo, considere dividi-lo em subetapas. Mantenha todos os detalhes, instruções, exemplos, variáveis ou espaços reservados fornecidos pelo usuário.
- Constantes: inclua constantes em prompts que sejam menos suscetíveis à injeção de prompts, como diretrizes, critérios de pontuação e exemplos.
- Formatos de saída: especifique o formato de saída mais apropriado, incluindo comprimento e sintaxe (por exemplo, frase, parágrafo, JSON, etc.).
    - Para tarefas em que a saída é de dados estruturados (por exemplo, categorias, JSON, etc.), gere preferencialmente JSON.
    - O JSON não deve ser envolvido em blocos de código (````), a menos que seja explicitamente solicitado.

O prompt final que você gera deve seguir a estrutura abaixo, sem comentários adicionais, e gerar apenas o prompt completo do sistema. Em particular, não adicione informações extras no início ou no final do prompt (por exemplo, não use `---').

[descrição concisa da tarefa - esta é a primeira linha do prompt sem títulos de seção]

[Adicione detalhes adicionais, se necessário].

[Seção opcional com títulos detalhados passo a passo ou marcadores].

# Etapa [opcional].

[Opcional: detalhamento das etapas necessárias para realizar a tarefa].

Formato de saída do #

[Especifique o formato da saída, seja o comprimento da resposta, a estrutura (por exemplo, JSON, Markdown, etc.)]

# Exemplo [opcional].

[Opcional: de 1 a 3 exemplos bem definidos, usando espaços reservados, se necessário. Marque claramente o início e o fim dos exemplos e as entradas e saídas. Use espaços reservados, se necessário].
[Se os exemplos forem mais curtos ou mais longos do que o esperado dos exemplos reais, adicione uma explicação de quão longos/diferentes devem ser os exemplos reais. E use marcadores de posição!]

# Notas [opcional].

[Opcional: casos extremos, detalhes e destaque ou repita pontos particularmente importantes a serem considerados].
""".strip()

def generate_prompt(task_or_prompt: str).
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system", "content": META_SYSTEMS
                
            },
            {
                "role": "user", "content": META_PROMPT, }, {
                "content": "Tarefa, meta ou prompt atual:\n" + task_or_prompt,
            }
        ]
    )

    return completion.choices[0].message.content

Meta-dica de áudio

from openai import OpenAI

cliente = OpenAI()

META_PROMPT = """
Com base em uma descrição de tarefa ou em um prompt existente, gere um prompt detalhado do sistema que oriente o modelo de linguagem de saída de áudio em tempo real para concluir a tarefa com eficiência.

Guia #

- Compreensão da tarefa: capture os principais objetivos, os requisitos da tarefa, as restrições e o resultado esperado.
- Tom de voz: indique claramente o tom de voz. O padrão deve ser emocional, amigável e rápido para que o usuário não tenha que esperar muito tempo.
- Limitações de saída de áudio: como o modelo emite áudio, as respostas devem ser curtas e coloquiais.
- Alterações mínimas: se houver um prompt existente, otimize-o apenas em casos simples. Para prompts complexos, aumente a clareza e adicione os elementos que faltam sem alterar a estrutura original.
- Exemplos: se útil, inclua exemplos de alta qualidade com colchetes [entre colchetes] para indicar espaços reservados para elementos complexos.
   - Quais exemplos incluir, quantos e se eles precisam ser complexos o suficiente para justificar o uso de espaços reservados.
   - É muito importante que todos os exemplos reflitam o resultado do diálogo curto do modelo.
Por padrão, as frases devem ser muito curtas. O ajudante não deve fornecer três frases seguidas, e recomenda-se que o usuário e o ajudante dialoguem entre si.
   - O comprimento padrão de cada frase é de cerca de 5 a 20 palavras. Se o usuário solicitar especificamente uma resposta "curta", os exemplos devem ser de 1 a 10 palavras.
   - Os exemplos devem ser várias rodadas de diálogo (pelo menos quatro rodadas de ida e volta por exemplo) em vez de uma única pergunta e resposta. Os exemplos devem refletir um fluxo natural de diálogo.
- Clareza e concisão: Use uma linguagem clara e específica. Evite instruções desnecessárias ou descrições irrelevantes.
- Preserve o conteúdo do usuário: se a tarefa de entrada ou o prompt contiver instruções ou exemplos detalhados, tente preservá-los completamente ou o mais próximo possível. Se o conteúdo for vago, considere dividi-lo em subetapas. Mantenha todos os detalhes, guias, exemplos, variáveis ou espaços reservados fornecidos pelo usuário.
- Constantes: inclua seções constantes porque elas são menos suscetíveis à injeção imediata, como diretrizes, critérios de pontuação e exemplos.

A saída final do prompt deve seguir a estrutura abaixo. Não inclua nenhuma instrução adicional; produza apenas o prompt do sistema concluído. Tome cuidado especial para não acrescentar nenhuma informação adicional no início ou no final do prompt (por exemplo, não há necessidade de "----").

[Instruções sucintas que descrevem a tarefa - essa deve ser a primeira linha do prompt, não são necessários títulos de seção].

[Adicione informações detalhadas, se necessário].

[Seção opcional que pode conter títulos ou listas com marcadores de etapas detalhadas]

# Exemplo [opcional].

[Opcional: inclua de 1 a 3 exemplos claramente definidos, usando espaços reservados, se necessário. Marque claramente onde o exemplo começa e termina, bem como as entradas e saídas. Use marcadores de posição para as informações necessárias]
[Se o exemplo for mais curto do que o exemplo real esperado, use parênteses () para indicar como o exemplo real deve ser mais longo/mais curto/diferente e use espaços reservados!]

# Observações [opcional]

[Opcional: casos de limite, informações detalhadas e observações importantes]
""".strip()

def generate_prompt(task_or_prompt: str).
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system", "content": META_SYSTEMS
                
            },
            {
                "role": "user", "content": META_PROMPT, }, {
                "content": "Tarefa, meta ou prompt atual: \n" + task_or_prompt,
            }
        ]
    )

    return completion.choices[0].message.content

Editor de taco

Para editar a dica, usamos uma meta dica ligeiramente modificada. Embora seja relativamente simples editar o aplicativo diretamente, pode ser um desafio identificar as alterações necessárias em modificações mais abertas. Para resolver esse problema, incluímos uma resposta no início dainferênciaEm um modelo de ajuda, o modelo de ajuda determina quais alterações são necessárias avaliando fatores como a clareza das palavras de alerta existentes, a ordem da cadeia de raciocínio, a estrutura geral e a especificidade. O componente de raciocínio sugere melhorias, que são então analisadas a partir da resposta final.

Meta-indicações de texto para edição

from openai import OpenAI

cliente = OpenAI()

META_PROMPT = """
Gerar um prompt detalhado do sistema com base no prompt atual e na descrição da alteração para orientar efetivamente o modelo de linguagem durante a tarefa.

Seu resultado final será o texto completo e corrigido da palavra do prompt. Mas, antes disso, analise a palavra do prompt usando a tag no início da sua resposta e esclareça o seguinte:

- Mudança simples: (Sim/Não) A descrição da mudança é clara e simples? (Se sim, pule as perguntas seguintes)
- Raciocínio: (Sim/Não) A palavra-chave atual usa raciocínio, análise ou cadeias de pensamento?
    - IDENTIFICAÇÃO: (máximo de 10 palavras) Se sim, em que parte do raciocínio?
    - CONCLUSÃO: (Sim/Não) A conclusão é alcançada por meio de uma cadeia de raciocínio?
    - Ordem: (antes/depois) A cadeia de raciocínio está localizada antes ou depois da conclusão?
- Estrutura: (Sim/Não) Há uma estrutura clara para a palavra-chave de entrada?
- Exemplos: (Sim/Não) A palavra-chave de entrada contém um pequeno número de exemplos?
    - Representatividade: (1-5) Se houver exemplos, qual é o grau de representatividade deles?
- Complexidade: (1 a 5) Qual é a complexidade da palavra-chave de entrada?
    - Tarefa: (1 a 5) Qual é a complexidade da tarefa?
    - Necessidade: ()
- Especificidade: (1-5) Quão detalhadas e específicas são as palavras-chave? (não equivalente ao comprimento)
- Prioridade: (liste) as 1-3 categorias mais importantes que precisam ser abordadas.
- CONCLUSÃO: (30 palavras no máximo) Com base na avaliação acima, descreva brevemente o que e como as mudanças devem ser feitas. Não há necessidade de seguir estritamente as categorias listadas.

Diretrizes do #

- Entenda a tarefa: capture os principais objetivos, requisitos, restrições e resultados desejados.
- Alterações mínimas: se já existirem dicas, melhore apenas quando forem simples; para dicas complexas, aumente a clareza e adicione elementos ausentes sem alterar a estrutura original.
- Raciocínio antes das conclusões**: assegure-se de que a etapa de raciocínio seja executada antes de se chegar a qualquer conclusão. Cuidado! Inverta a ordem se o raciocínio vier depois da conclusão nos exemplos fornecidos pelo usuário! Nunca comece com uma conclusão!
    - Ordem de raciocínio: marque a seção de raciocínio e a seção de conclusão da palavra-chave (especifique os nomes dos campos). Para cada seção, determine se a ordem precisa ser invertida.
    - A conclusão, classificação ou resultado deve sempre aparecer por último.
- Exemplos: se útil, inclua exemplos de alta qualidade e use [colchetes] como espaços reservados para elementos complexos.
   - Indique que tipos de exemplos podem precisar ser incluídos, quantos e se eles são complexos o suficiente para justificar o uso de espaços reservados.
- Clareza e simplicidade: Use uma linguagem clara e específica. Evite instruções desnecessárias ou declarações sem graça.
- Tipografia: use os recursos do Markdown para melhorar a legibilidade. Evite blocos de código ```, a menos que seja explicitamente solicitado.
- Preserve o conteúdo do usuário: se a tarefa de entrada ou o prompt contiver diretrizes ou exemplos extensos, preserve-os completamente ou o máximo possível. Se isso não estiver claro, divida-o em subetapas. Mantenha todos os detalhes, diretrizes, exemplos, variáveis ou espaços reservados fornecidos pelo usuário.
- Constantes: inclua constantes nos prompts, pois elas não são afetadas por ataques de injeção de prompts, como diretrizes, critérios de pontuação e exemplos.
- Formatos de saída: especifique o formato de saída mais apropriado, detalhando o comprimento e a sintaxe da saída (por exemplo, frases curtas, parágrafos, JSON etc.).
    - Para tarefas em que a saída tem dados explícitos ou estruturados (categorias, JSON, etc.), prefira a saída em JSON.
    - O JSON não deve ser envolvido em blocos de código (``), a menos que seja explicitamente solicitado.

As palavras finais do prompt que você enviar devem seguir a estrutura abaixo. Não inclua nenhum comentário adicional, apenas envie a palavra de prompt completa do sistema. Em particular, não adicione nenhuma mensagem adicional no início ou no final do prompt (por exemplo, não use "----").

[Instruções que descrevem brevemente a tarefa - esta é a primeira linha da palavra de prompt, não são necessários títulos de seção].

[Adicione mais detalhes, se necessário].

[Seção opcional com títulos ou marcadores para descrever etapas detalhadas].

Etapas do # [opcional].

[Opcional: detalhamento das etapas necessárias para concluir a tarefa].

Formato de saída do #

[Especifique os requisitos do formato de saída, como comprimento da resposta, estrutura (por exemplo, JSON, markdown, etc.)].

# Exemplo [opcional]

[Opcional: 1-3 exemplos claros, use espaços reservados e marque as posições de entrada e saída se forem necessários elementos complexos. Use parênteses para indicar que o exemplo real deve ser mais longo/mais curto/diferente].

# Nota [opcional].

[Opcional: casos extremos, informações detalhadas ou áreas de destaque de particular importância para consideração].
[OBSERVAÇÃO: deve começar com uma seção, a próxima tag gerada deve ser ]
""".strip()

def generate_prompt(task_or_prompt: str).
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system", "content": META_SYSTEMS
                
            },
            {
                "role": "user", "content": "Task, Goal, or Current Prompt:\n" + task_prompt:\n
                "content": "Tarefa, meta ou prompt atual:\n" + task_or_prompt, }
            }, }
        ]
    )

    return completion.choices[0].message.content

Meta dicas para edição de áudio

from openai import OpenAI

cliente = OpenAI()

META_PROMPT = """
Com um prompt atual e instruções de alteração, um prompt detalhado do sistema é gerado para orientar efetivamente o modelo de linguagem de saída de áudio em tempo real durante a tarefa.

O resultado final será o prompt completo e corrigido no estado em que se encontra. No entanto, logo no início da resposta, use rótulos para analisar o prompt e esclarecer o seguinte:

- Mudança simples: (sim/não) As instruções de mudança são claras e simples? (Se sim, pule as perguntas seguintes)
- Raciocínio: (sim/não) O prompt atual usa raciocínio, análise ou cadeias de pensamento?
    - Rotulagem: (máximo de 10 palavras) Se sim, quais partes usam raciocínio?
    - Conclusão: (sim/não) A cadeia de pensamento é usada para chegar a uma conclusão?
    - Ordem: (antes/depois) A cadeia de raciocínio está localizada antes ou depois?
- Estrutura: (sim/não) O prompt de entrada tem uma estrutura clara?
- Exemplos: (sim/não) O prompt de entrada contém alguns exemplos?
    - Representatividade: (1-5) Se houver exemplos, qual é o grau de representatividade deles?
- Complexidade: (1 a 5) Qual é a complexidade do prompt de entrada?
    - Tarefas: (1 a 5) Qual é a complexidade das tarefas implícitas?
    - Necessidade: ()
- Especificidade: (1-5) Quão detalhados e específicos são os prompts? (não relacionado ao tamanho)
- Prioridade: (lista) Quais são as categorias de 1 a 3 mais importantes.
- Conclusão: (30 palavras no máximo) Descreva brevemente o que precisa ser mudado com base na avaliação anterior. Não precisa se limitar às categorias listadas.

Diretrizes do #

- Entendendo a tarefa: Entenda os principais objetivos, requisitos, restrições e resultados esperados.
- Tom: certifique-se de que o tom esteja claramente definido. O padrão deve ser emotivo e amigável, e de rápida expressão para evitar que o usuário fique esperando.
- Restrições de saída de áudio: como o modelo emite áudio, a resposta deve ser curta e coloquial.
- Alterações mínimas: se os prompts existentes forem fornecidos, melhore-os apenas em casos simples. Para dicas complexas, aumente a clareza e adicione os elementos ausentes sem alterar a estrutura original.
- Exemplos: se útil, inclua exemplos de alta qualidade e use [colchetes] como espaços reservados para elementos complexos.
   - Que tipos de exemplos devem ser incluídos, quantos e se são necessários espaços reservados.
  - Os exemplos devem refletir as respostas de saída do diálogo curto do modelo.
Por padrão, as frases devem ser muito curtas. As 3 frases do auxiliar devem ser separadas para interagir com o usuário.
  - Por padrão, cada frase deve conter apenas um pequeno número de palavras (cerca de 5 a 20 palavras). Se o usuário solicitar explicitamente uma resposta "curta", o exemplo deverá ter apenas de 1 a 10 palavras.
  - Os exemplos devem ter várias rodadas de diálogo (pelo menos quatro idas e vindas entre o usuário e o assistente), refletindo conversas reais.
- Clareza e concisão: use uma linguagem clara e específica. Evite instruções desnecessárias ou declarações sem graça.
- Preserve o conteúdo do usuário: se a tarefa de entrada ou o prompt contiver instruções ou exemplos detalhados, preserve-os o máximo possível. Se o conteúdo for vago, considere dividi-lo em subetapas. Mantenha os detalhes, as instruções, os exemplos, as variáveis ou os espaços reservados fornecidos pelo usuário.
- Constantes: inclua constantes em prompts que sejam menos suscetíveis à injeção de prompts, como diretrizes, critérios de pontuação e exemplos.

O prompt de saída final deve seguir a estrutura abaixo. Não inclua nenhum comentário adicional; envie apenas o prompt de sistema concluído. Em particular, não adicione nenhuma informação adicional no início ou no final do prompt. (por exemplo, não use "----")

[Descrição concisa da tarefa - esta é a primeira linha do prompt, não há necessidade de adicionar um título de subseção].

[Adicione instruções detalhadas conforme necessário].

[Seção opcional contendo etapas detalhadas para títulos ou marcadores].

# Exemplo [Opcional].

[Opcional: 1 a 3 exemplos claramente definidos, usando espaços reservados, se necessário. Marque claramente o início e o fim dos exemplos, bem como as entradas e saídas. Use espaços reservados, se necessário]
[Se o exemplo for mais curto do que o exemplo real esperado, marque com () como o exemplo real deve ser mais longo/mais curto/diferente e use espaços reservados!]

# Notas [opcional].

[Opcional: casos extremos, descrições detalhadas e áreas para invocar ou repetir considerações importantes específicas].
[OBSERVAÇÃO: você deve começar com uma seção. O próximo token que você gerar imediatamente depois deve ser]
""".strip()

def generate_prompt(task_or_prompt: str):
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system", "content": META_SYSTEMS
                
            },
            {
                "role": "user", "content": "Task, Goal, or Current Prompt:\n" + task_prompt:\n
                "content": "Tarefa, meta ou prompt atual:\n" + task_or_prompt, }
            }, }
        ]
    )

    return completion.choices[0].message.content

construir

Saída estruturada Os esquemas e os esquemas de função são objetos JSON, portanto, usamos a saída estruturada para gerá-los. Isso requer a definição de uma arquitetura para a saída desejada, que, nesse caso, é uma arquitetura. Para fazer isso, usamos arquiteturas autodescritivas - a arquiteturameta-arquitetura.

Como a arquitetura de função do parâmetros O campo em si é uma arquitetura, portanto, usamos a mesma meta-arquitetura para gerar a função.

Definição de meta-arquiteturas restritas

Saída estruturada Há suporte para dois modos:strict=true responder cantando strict=falseO "modo estrito" garante apenas a perfeita adesão por meio de amostragem restrita. Ambos os modos usam o mesmo modelo para seguir a arquitetura fornecida, mas somente o "modo estrito" garante a conformidade perfeita por meio de amostragem restrita.

Nosso objetivo é gerar arquiteturas de modo estrito usando o próprio modo estrito. No entanto, a versão oficial Especificação da arquitetura JSON A meta-arquitetura fornecida se baseia no modelo estrito em Recursos não suportados no momento. Isso cria desafios para as arquiteturas de entrada e saída.

1. Arquitetura de entrada: Não podemos usar a arquitetura de entrada em Recursos sem suporte para descrever a arquitetura de saída.
2. Arquitetura de saída: A arquitetura gerada não pode conter Recursos sem suporte.

Como precisamos gerar novas chaves na arquitetura de saída, a meta-arquitetura de entrada deve usar o additionalProperties. Isso significa que atualmente não podemos usar padrões rígidos para gerar arquiteturas. No entanto, ainda queremos gerar arquiteturas que estejam em conformidade com as restrições dos padrões rígidos.

Para superar essa limitação, definimos um arquitetura pseudo-elementar (computação) -- Uma meta-arquitetura que usa recursos que não são compatíveis com o esquema estrito para descrever recursos que são compatíveis apenas com o esquema estrito. Essencialmente, essa abordagem se afasta do modo estrito ao definir a meta-arquitetura, garantindo que a arquitetura resultante siga as restrições do modo estrito.

uma discussão aprofundada

Como projetamos a pseudo-meta-arquitetura

A construção de meta-arquiteturas restritas é uma tarefa desafiadora, por isso utilizamos nossos modelos para ajudar nessa tarefa.

Começamos enviando uma mensagem no modo JSON para o o1-preview responder cantando gpt-4o descreveu nossos objetivos, usando um documento que estruturou o resultado. Após várias iterações, desenvolvemos uma primeira meta-arquitetura viável.

Em seguida, usamos o gpt-4o e resultados estruturados que fornecemestrutura inicialjuntamente com nossa descrição e documentação da tarefa para gerar melhores arquiteturas candidatas. Em cada iteração, usamos a melhor arquitetura para gerar a próxima etapa, até finalmente realizarmos uma análise manual.

Por fim, depois de limpar a saída, validamos a arquitetura em relação a um conjunto de testes de avaliação para garantir a aplicabilidade da arquitetura e das funções.

Limpeza de saída

O modo estrito garante perfeita conformidade arquitetônica. No entanto, como não podemos usar o modo estrito durante a geração, precisamos validar e transformar a saída após a geração.

Depois de gerar a arquitetura, executamos as seguintes etapas:

1. Defina todos os objetos do additionalProperties definido como falso.
2. Marque todos os atributos conforme necessário.
3. Para arquitetura de saída estruturada, embalando-o em json_schema no objeto.
4. Para funções, embalando-o em função no objeto.

= = APIs em tempo real função (matemática) é um pouco diferente da API Chat Completions, mas usa a mesma arquitetura. ==

meta-modelo

Cada metamodo tem uma dica correspondente que contém alguns exemplos. Quando combinamos isso com a confiabilidade da saída estruturada, mesmo sem usar o modo estrito, podemos usar o gpt-4o-mini Executar a geração de padrões.

Modelo de saída estruturado

from openai import OpenAI
importar json
cliente = OpenAI()
META_SCHEMA = {
"name": "metaschema", "schema": {
"schema": {
"type": "object", "properties": {
"properties": {
"name": {
"type": "string", "description": { "name": {
"description": "Nome do esquema"
},
"type": {
"enum": [
"object".
"array".
"string".
"number", "enum": [ "object", "array", "string", "enum".
"boolean", "null
"null"
]
},
"properties": {
"type": "object", "additionalProperties": {
"additionalProperties": {
"$ref": "#/$defs/schema_definition"
}
},
"items": {
"anyOf": [
{
"$ref": "#/$defs/schema_definition"
},
{
"type": "array", {
"items": {
"$ref": "#/$defs/schema_definition"
}
}
]
}, "required": {
"required": {
"type": "array", "items": {
"items": {
"type": "string"
}
}, "additionalProperties": { "type": "array": { "items": { "type": "string" }
"additionalProperties": {
"type": "boolean"
}
}, "additionalProperties": { "type": "boolean" }
"required": [
"type"
], "additionalProperties": False, "type": "boolean" } }
"additionalProperties": False, "if": { "type" }
"if": {
"properties": {
"type": {
"const": "object"
}
}
}, "then": { "type": { "const": "object" }
"then": {
"required": [
"properties"
]
}, "then": { "required": [ "properties" ] }, "then": { "required": [ "properties" ]
"$defs": {
"schema_definition": {
"type": "object", "properties": {
"properties": {
"type": {
"type": "string",
"enum": [
"object".
"array".
"string".
"number", "enum": [ "object", "array", "string", "enum".
"boolean", "null
"null"
]
},
"properties": {
"type": "object", "additionalProperties": {
"additionalProperties": {
"$ref": "#/$defs/schema_definition"
}
},
"items": {
"anyOf": [
{
"$ref": "#/$defs/schema_definition"
},
{
"type": "array", {
"items": {
"$ref": "#/$defs/schema_definition"
}
}
]
}, "required": {
"required": {
"type": "array", "items": {
"items": {
"type": "string"
}
}, "additionalProperties": { "type": "array": { "items": { "type": "string" }
"additionalProperties": {
"type": "boolean"
}
}, "additionalProperties": { "type": "boolean" }
"required": [
"type"
], "additionalProperties": False, "type": "boolean" } }
"additionalProperties": False, "if": { "type" }
"if": {
"properties": {
"type": {
"const": "object"
}
}
}, "then": { "type": { "const": "object" }
"then": {
"required": [
"properties"
]
}
}
}
}
}
META_PROMPT = """
Diretiva #
Retorna um esquema de descrição JSON válido.
Você também precisa se certificar de que:
- Todos os campos do objeto estejam definidos como campos obrigatórios
- Repito, todos os campos devem ser marcados como campos obrigatórios
- todas as additionalProperties do objeto devem ser definidas como false
- Portanto, propriedades como "attributes" (atributos) ou "metadata" (metadados), que normalmente permitem propriedades adicionais, devem ser definidas como um conjunto fixo de propriedades.
- Todos os objetos devem definir propriedades
- A ordem dos campos é importante. Qualquer forma de "pensamento" ou "explicação" deve vir antes da conclusão.
- $defs devem ser definidos nos parâmetros do esquema.
As palavras-chave sem suporte incluem:
- Para cadeias de caracteres: minLength, maxLength, pattern, format
- Para números: minimum, maximum, multipleOf
- Para objetos: patternProperties, unevaluatedProperties, propertyNames, minProperties, maxProperties
- Para arrays: unevaluatedItems, contains, minContains, maxContains, minItems, maxItems, uniqueItems
Outras observações:
- Há suporte para definições e recursão
- Inclua referências somente quando necessário, por exemplo, "$defs", que deve estar dentro do objeto "schema".
Exemplo do #
Entrada: gerar um esquema de raciocínio matemático com etapas e resposta final.
Saída: {
"name": "maths_reasoning",
"type": "object",
"properties": {
"steps" (etapas): {
"type": "array",
"description": "Uma sequência de etapas envolvidas na resposta a uma pergunta de matemática." ,
"items": {
"type": "object", "properties": {
"properties": {
"explanation" (explicação): {
"type": "string", "description": {
"description": "Uma descrição do raciocínio ou método usado nesta etapa."
},
"output": {
"type": "string", "description": "A descrição da etapa específica.
"description": "O resultado ou saída dessa etapa específica."
}
},
"required": [
"explanation" (explicação).
"output"
], "additionalProperties": false
"additionalProperties": false
}
},
"final_answer": {
"type": "string" (tipo),
"description": "A resposta final para a pergunta de matemática".
}
},
"required": [
"steps".
"final_answer"
], "required": [ "steps", "final_answer
"additionalProperties": false
}
Entrada: me dê uma lista vinculada
Saída: {
"name": "linked_list",
"type": "object",
"properties": {
"linked_list": {
"$ref": "#/$defs/linked_list_node",.
"description": "O nó principal da lista vinculada".
}
},.
"$defs": {
"linked_list_node": {
"type": "object",
"description": "Define um nó em uma única lista vinculada." ,
"properties": {
"value": {
"type": "number",
"description": "O valor armazenado nesse nó."
},
"next" (próximo): {
"anyOf": [
{
"$ref": "#/$defs/linked_list_node"
},
{
"type": "null"
}
], { "type": "null" }, { "type": "null" }
"description": "Faz referência ao próximo nó; nulo se for o último nó."
}
},
"required": [
"value".
"next" (próximo)
], "additionalProperties": false
"additionalProperties": false
}
}, "required": [ [ "next" ], "additionalProperties": false }
"required": [
"linked_list"
], "additionalProperties": false
"additionalProperties": false
}
Entrada: UI gerada dinamicamente
Saída: {
"name": "ui",
"type": "object", "properties": {
"properties": {
"type": {
"type": "string", "description": { "type": "ui", "properties": { "type": {
"description": "O tipo do componente da interface do usuário.
"enum": [
"div".
"seção", "campo", [ "seção", "campo", "cabeçalho", "cabeçalho
"campo".
"form"
}, "header" (cabeçalho), "section" (seção), "field" (campo), "form
},
"label" (rótulo): {
"type": "string", "description": "Rótulo do componente da interface do usuário para campos de botão ou formulário", "label": {
"description": "Rótulo do componente da interface do usuário, usado para botões ou campos de formulário"
},
"children": {
"description": "Nested UI component", "items": { "type": "array", "description": "Nested UI component", "description": "Nested UI component".
"itens": {
"$ref": "#"
}
}, "attributes": { "$ref": "#" }
"attributes": {
"type": "array", "description": "Aplica-se a qualquer elemento do componente da interface do usuário.
"description": "Qualquer atributo do componente da interface do usuário que se aplique a qualquer elemento.", "items": {
"items": {
"properties": {
"name": {
"type": "string", "description": "name": {
"description": "O nome da propriedade, como onClick ou className"
}, "description": "nome da propriedade, por exemplo, onClick ou className
"value": {
"description": "O valor da propriedade."
}
}, "value": { "type": "string", "description": "Value of property" }, "value": { "value": { "value": { "description": "Value of property" }
"required": [
"name", "value
"value"
], "additionalProperties": false
"additionalProperties": false
}
}
}, "required": [["value" ], "additionalProperties": false } }
"required": [
"type".
"label".
"crianças", "atributos
"attributes"
], "additionalProperties": false
"additionalProperties": false
}
""".strip()
def generate_schema(description: str).
completion = client.chat.completions.create(
model="gpt-4o-mini",
response_format={"type": "json_schema", "json_schema": META_SCHEMA},
messages=[
{
"função": "sistema",
"content": META_PROMPT,
},
{
"role": "user", "content": "Description:\n" + description, }, {
"content": "Description:\n" + description,
}
]
)
return json.loads(completion.choices[0].message.content)

modelo de função

from openai import OpenAI
importar json
cliente = OpenAI()
META_SCHEMA = {
"name": "function-metaschema",
"schema": {
"type": "object", "properties": {
"properties": {
"name": {
"type": "string", "description": { "name": {
"description": "O nome da função."
},
"description": {
"type": "string",
"description": "Descrição da função"
},
"parameters": {
"$ref": "#/$defs/schema_definition",
"description": "Esquema JSON que define os parâmetros da função"
}
}, "description": "Define o esquema JSON para parâmetros de função" }
"required": [
"name".
"description", "parameters": [ "name", "description", "parameters
"parameters" (parâmetros)
"additionalProperties": Falso,
"$defs": {
"schema_definition": {
"type": "object", "properties": { "schema_definition": {
"properties": {
"type": {
"type": "string",
"enum": [
"object".
"array".
"string".
"number", "enum": [ "object", "array", "string", "enum".
"boolean", "null
"null"
]
},
"properties": {
"type": "object", "additionalProperties": {
"additionalProperties": {
"$ref": "#/$defs/schema_definition"
}
},
"items": {
"anyOf": [
{
"$ref": "#/$defs/schema_definition"
},
{
"type": "array", {
"items": {
"$ref": "#/$defs/schema_definition"
}
}
]
}, "required": {
"required": {
"type": "array", "items": {
"items": {
"type": "string"
}
}, "additionalProperties": { "type": "array": { "items": { "type": "string" }
"additionalProperties": {
"type": "boolean"
}
}, "additionalProperties": { "type": "boolean" }
"required": [
"type"
], "additionalProperties": False, "type": "boolean" } }
"additionalProperties": False, "if": { "type" }
"if": {
"properties": {
"type": {
"const": "object"
}
}
}, "then": { "type": { "const": "object" }
"then": {
"required": [
"properties"
]
}
}
}
}
}
META_PROMPT = """
Instruções #
Retorna um padrão válido que descreve uma função.
Tome cuidado especial para garantir que "required" e "type" estejam sempre no nível de aninhamento correto. Por exemplo, "required" deve estar no mesmo nível de "properties", e não dentro dele.
Certifique-se de que cada propriedade, por mais curta que seja, tenha um tipo e uma descrição corretamente aninhados.
Exemplo do #
Entrada: Atribuição de valores aos hiperparâmetros da rede neural
Saída: {
"nome": "set_hyperparameters",
"description": "Atribuir valores aos hiperparâmetros da rede neural.", "description": "Atribuir valores aos hiperparâmetros da rede neural",
"parameters": {
"type": "object", "required": [ "name": "set_hyperparameters", "description": "Atribuir valores aos hiperparâmetros da rede neural", "parameters": { "type": "object",
"required": [
"learning_rate",
"epochs"
"properties": {
"epochs": {
"type": "number", "description": "A passagem completa do conjunto de dados.
"description": "Número de passagens completas do conjunto de dados."
},
"learning_rate": {
"type": "number", "description": "Número de passagens completas do conjunto de dados" }, "learning_rate": { "type": "number", "description": "Learning_rate": {
"description": "Taxa de aprendizado do modelo"
}
}
}
}
Entrada: Planeje um caminho de movimento para o robô
Saída: {
"description": "Planejar um caminho de movimento para o robô", "parameters": {
"parameters": {
"required": [
"start_position", "end_position": [ "start_position", "end_position
"end_position"
], "properties": { "type": "object".
"properties": {
"end_position": {
"type": "object", "properties": { "end_position": {
"properties": {
"x": {
"type": "number",
"description": "Coordenada x do ponto final"
"y": {
"description": "End point Y coordinate" }, "y": { "type": "number", "description": "End point Y coordinate" }
}
}
}, "obstacles": { "type": "number", "description": "End Y coordinate" }
"obstacles" (obstáculos): {
"type": "array", "description": "Uma matriz de coordenadas de obstáculos.
"description": "Uma matriz de coordenadas de obstáculos.",
"items": {
"type": "object", "properties": {
"properties": {
"x": {
"type": "number", "description".
"description": "Coordenadas X do obstáculo"
}, "y": { "x": { "type": "number", "description": "Obstacle X coordinates
"y": {
"description": "Obstacle Y coordinate" }, "y": { "type": "number", "description": "Obstacle Y coordinate"
}
}
}
}, "description": "Obstacle Y-coordinate" }
"start_position": {
"type": "object", "properties": {
"properties": {
"x": {
"type": "number", "description": { "start_position": {
"description": "Coordenada x do ponto inicial"
}, "y": { "x": { "type": "number", "description": "Start X coordinate
"y": {
"type": "number", "description": "Start Y coordinate" }, "y": { "type": "number", "description": "Start Y coordinate
"description": "Starting point Y coordinate" }, "y": { "type": "number", "description": "Starting point Y coordinate" }
}
}
}
}
}
}
Entrada: calcular vários indicadores técnicos
Saída: {
"description": "Calcula vários indicadores técnicos.", "parameters": {
"parameters": {
"type": "object", "required": [ "type": "object", "description": "Calculate various technical indicators", "parameters": {
"required": [
"ticker", "indicadores": [
"indicators"
], "properties": { "type": "object", "required": [ "ticker", "indicators" ], "properties".
"properties": {
"indicators": {
"type": "array", "description": "Lista de indicadores técnicos a serem calculados".
"description": "Lista de indicadores técnicos a serem calculados",
"items": {
"type": "string", "description": "Lista de indicadores técnicos a serem calculados", "items": { "type": "string",
"description": "Technical Indicators" (Indicadores técnicos),
"enum": [
"RSI".
"MACD".
"Bollinger_Bands", "Stochastic_Oscillator".
"Stochastic_Oscillator"
]
}
}, }
"period": {
"type": "number", "description": "O período de tempo da análise.
"description": "Período de tempo analisado"
},
"ticker": {
"description": "Stock symbol" (símbolo da ação)
}
}
}
}
""".strip()
def generate_function_schema(description: str):
completion = client.chat.completions.create(
model="gpt-4o-mini",
response_format={"type": "json_schema", "json_schema": META_SCHEMA},
messages=[
{
"função": "sistema",
"content": META_PROMPT,
},
{
"role": "user", "content": "description:\n" + description, }, {
"content": "description:\n" + description,
}
]
)
return json.loads(completion.choices[0].message.content)

O guia do leigo para começar a usar a IA

Ajuda você a aprender a utilizar as ferramentas de IA com baixo custo e a partir de uma base zero.A IA, assim como o software de escritório, é uma habilidade essencial para todos. Dominar a IA lhe dará uma vantagem em sua busca de emprego e metade do esforço em seu trabalho e estudos futuros.

Ver detalhes>