Tipp-Erzeugung

existieren Spielplatz den Nagel auf den Kopf treffen Erzeugen Sie können Sie Eingabeaufforderungen aus der Aufgabenbeschreibung generieren,Funktion (math.)im Gesang antwortenbauen. In diesem Leitfaden wird Schritt für Schritt erklärt, wie es funktioniert.

skizziert.

Die Erstellung von Prompts und Architekturen von Grund auf kann sehr zeitaufwändig sein, so dass Sie mit der Generierung von Prompts und Architekturen schnell beginnen können:

1. auf etw. aufmerksam machen: Wir verwendenHinweisEinbindung bewährter Verfahren zur Erstellung oder Verbesserung von Tipps.
2. bauen: Wir verwendenmeta-architekturGenerieren Sie gültige JSON- und Funktionssyntax.

Derzeit verwenden wir Meta-Prompts und Architekturen, aber in Zukunft werden wir möglicherweise fortschrittlichere Techniken integrieren, wie z. B. DSPy im Gesang antworten "Gradientenabstieg".

auf etw. aufmerksam machen

Hinweis Leiten Sie das Modell an, um großartige Prompts zu erstellen oder bestehende Prompts basierend auf Ihrer Aufgabenbeschreibung zu verbessern. Tipp TechnikBewährte Verfahren und reale Benutzererfahrungen.

Wir verwenden spezifische Meta-Cues für verschiedene Ausgabearten (z. B. Audio), um sicherzustellen, dass die generierten Cues dem erwarteten Format entsprechen.

Hinweis

textlicher Meta-Tipp

von openai importieren OpenAI



client = OpenAI()

META_PROMPT = """
Erzeugt einen detaillierten Systemprompt auf der Grundlage der Aufgabenbeschreibung oder vorhandener Prompts, um das Sprachmodell effektiv durch die Aufgabe zu führen.

#-Richtlinien

- Verstehen Sie die Aufgabe: Erfassen Sie die wichtigsten Ziele, Vorgaben, Anforderungen, Einschränkungen und erwarteten Ergebnisse.
- Minimale Änderungen: Wenn ein bestehender Prompt vorhanden ist, verbessern Sie ihn nur, wenn er einfach ist. Bei komplexen Aufforderungen sollten Sie die Klarheit verbessern und fehlende Elemente hinzufügen, ohne die ursprüngliche Struktur zu verändern.
- REASONING BEFORE CONCLUSION**: Fördern Sie Denkschritte, bevor Sie Schlussfolgerungen ziehen. Vorsicht! Wenn ein vom Benutzer geliefertes Beispiel eine Argumentation vor einer Schlussfolgerung enthält, kehren Sie die Reihenfolge um! Beginnen Sie niemals mit einer Schlussfolgerung.
    - Reihenfolge der Argumentation: Zeigen Sie auf die Abschnitte Argumentation und Schlussfolgerung der Aufforderung (nach Feldnamen), um die Reihenfolge der Vervollständigung zu bestimmen, und kehren Sie sie gegebenenfalls um.
    - Die Schlussfolgerung, die Klassifizierung oder das Ergebnis sollten immer als letztes erscheinen.
- Beispiele: Falls hilfreich, fügen Sie hochwertige Beispiele ein und verwenden Sie [eckige Klammern] als Platzhalter für komplexe Elemente.
   - Überlegen Sie, welche Beispiele Sie einfügen wollen, wie viele und ob sie komplex genug sind, um Platzhalter zu benötigen.
- Klar und prägnant: Verwenden Sie eine klare, spezifische Sprache. Vermeiden Sie unnötige Direktiven oder leere Aussagen.
- Formatierung: Verwenden Sie Markdown-Funktionen, um die Lesbarkeit zu verbessern. Verwenden Sie keine ````-Codeblöcke, es sei denn, dies wird ausdrücklich verlangt.
- Bewahren Sie den Inhalt: Wenn Eingabeaufgaben oder Aufforderungen umfangreiche Anweisungen oder Beispiele enthalten, sollten Sie sie so vollständig wie möglich halten. Wenn der Inhalt mehrdeutig ist, sollten Sie ihn in Teilschritte zerlegen. Behalten Sie alle Details, Anweisungen, Beispiele, Variablen oder Platzhalter bei, die der Benutzer angegeben hat.
- Konstanten: Fügen Sie Konstanten in Prompts ein, die weniger anfällig für Prompt-Injektionen sind, z. B. Richtlinien, Bewertungskriterien und Beispiele.
- Ausgabeformate: Geben Sie das am besten geeignete Ausgabeformat an, einschließlich Länge und Syntax (z. B. Phrase, Absatz, JSON usw.).
    - Für Aufgaben, bei denen die Ausgabe strukturierte Daten sind (z. B. Kategorien, JSON usw.), sollten Sie vorzugsweise JSON generieren.
    - JSON sollte nicht in Codeblöcke (```) eingeschlossen werden, es sei denn, dies wird ausdrücklich verlangt.

Die endgültige Eingabeaufforderung, die Sie ausgeben, sollte der nachstehenden Struktur folgen, ohne zusätzliche Kommentare, und nur die vollständige Systemaufforderung ausgeben. Fügen Sie insbesondere keine zusätzlichen Informationen am Anfang oder Ende des Prompts hinzu (verwenden Sie z. B. kein `---').

[knappe Aufgabenbeschreibung - dies ist die erste Zeile des Prompts ohne Abschnittsüberschriften]

[Fügen Sie bei Bedarf weitere Details hinzu].

[Optionaler Abschnitt mit detaillierten Schritt-für-Schritt-Überschriften oder Aufzählungszeichen].

# Schritt [fakultativ].

[fakultativ: Detaillierte Aufschlüsselung der zur Erfüllung der Aufgabe erforderlichen Schritte].

# Ausgabeformat

[Geben Sie das Format der Ausgabe an, sei es die Länge der Antwort, die Struktur (z. B. JSON, Markdown usw.)]

# Beispiel [optional].

[Optional: 1-3 gut definierte Beispiele, ggf. mit Platzhaltern. Markieren Sie deutlich den Anfang und das Ende der Beispiele sowie die Ein- und Ausgänge. Verwenden Sie ggf. Platzhalter].
[Wenn die Beispiele kürzer oder länger sind als von den tatsächlichen Beispielen erwartet, fügen Sie eine Erklärung hinzu, wie lang/anders die tatsächlichen Beispiele sein sollten. Und verwenden Sie Platzhalter!]

# Anmerkungen [fakultativ].

[Optional: Randfälle, Details und Hervorhebung oder Wiederholung besonders wichtiger Punkte, die zu beachten sind]
""".strip()

def generate_prompt(aufgabe_oder_prompt: str).
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "Rolle": "System", "Inhalt": META_SYSTEMS
                
            },
            {
                "role": "user", "content": META_PROMPT, }, {
                "content": "Aufgabe, Ziel oder aktuelle Eingabeaufforderung:\n" + task_or_prompt,
            }
        ]
    )

    return completion.choices[0].message.content

Audio-Meta-Tipp

von openai importieren OpenAI

client = OpenAI()

META_PROMPT = """
Ausgehend von einer Aufgabenbeschreibung oder einem vorhandenen Prompt wird ein detaillierter Systemprompt erzeugt, der das Sprachmodell für die Echtzeit-Audioausgabe anleitet, die Aufgabe effektiv zu erledigen.

#-Leitfaden

- Verstehen der Aufgabe: Erfassen der Hauptziele, Aufgabenanforderungen, Einschränkungen und des erwarteten Outputs.
- Tonfall: Geben Sie den Tonfall klar an. Die Vorgabe sollte emotional, freundlich und schnell sein, damit der Benutzer nicht zu lange warten muss.
- Einschränkungen der Audioausgabe: Da das Modell Audio ausgibt, sollten die Antworten kurz und konversationell sein.
- Minimale Änderungen: Wenn es einen bestehenden Prompt gibt, optimieren Sie ihn nur in einfachen Fällen. Bei komplexen Prompts sollten Sie die Klarheit verbessern und fehlende Elemente hinzufügen, ohne die ursprüngliche Struktur zu verändern.
- Beispiele: Falls hilfreich, fügen Sie qualitativ hochwertige Beispiele mit eckigen Klammern [in Klammern] ein, um Platzhalter für komplexe Elemente anzugeben.
   - Welche Beispiele Sie einfügen, wie viele, und ob sie komplex genug sein müssen, um die Verwendung von Platzhaltern zu rechtfertigen.
   - Es ist sehr wichtig, dass alle Beispiele die kurze Dialogausgabe des Modells widerspiegeln.
Standardmäßig sollten die Sätze sehr kurz sein. Der Helfer sollte nicht drei Sätze hintereinander ausgeben, und es wird empfohlen, dass der Benutzer und der Helfer einen Dialog führen, der hin und her geht.
   - Die Standardlänge eines jeden Satzes beträgt etwa 5-20 Wörter. Wenn der Benutzer ausdrücklich eine "kurze" Antwort verlangt, sollten die Beispiele tatsächlich nur 1-10 Wörter lang sein.
   - Die Beispiele sollten aus mehreren Dialogrunden bestehen (mindestens vier Hin- und Herrunden pro Beispiel) und nicht aus einer einzigen Frage und Antwort. Die Beispiele sollten einen natürlichen Fluss des Dialogs widerspiegeln.
- Klarheit und Prägnanz: Verwenden Sie eine klare, spezifische Sprache. Vermeiden Sie unnötige Anweisungen oder irrelevante Beschreibungen.
- Behalten Sie den Benutzerinhalt bei: Wenn die Eingabeaufgabe oder -aufforderung detaillierte Anweisungen oder Beispiele enthält, versuchen Sie, diese vollständig oder so genau wie möglich beizubehalten. Wenn der Inhalt vage ist, sollten Sie ihn in Teilschritte aufgliedern. Behalten Sie alle vom Benutzer bereitgestellten Details, Anleitungen, Beispiele, Variablen oder Platzhalter bei.
- Konstanten: Fügen Sie konstante Abschnitte ein, da sie weniger anfällig für eine prompte Injektion sind, z. B. Richtlinien, Bewertungskriterien und Beispiele.

Die endgültige Ausgabe des Prompts sollte der nachstehenden Struktur folgen. Fügen Sie keine zusätzlichen Anweisungen ein; geben Sie nur den fertigen Systemprompt aus. Achten Sie besonders darauf, keine zusätzlichen Informationen am Anfang oder Ende des Prompts einzufügen (z. B. kein Bedarf für "----").

[Kurze Anweisungen, die die Aufgabe beschreiben - dies sollte die erste Zeile des Prompts sein, Abschnittsüberschriften sind nicht erforderlich]

[Fügen Sie bei Bedarf detaillierte Informationen hinzu]

[Optionaler Abschnitt, der Überschriften oder Aufzählungen von detaillierten Schritten enthalten kann]

# Beispiel [fakultativ].

[Optional: Fügen Sie 1-3 klar definierte Beispiele ein und verwenden Sie gegebenenfalls Platzhalter. Markieren Sie deutlich, wo das Beispiel beginnt und endet, sowie die Ein- und Ausgänge. Verwenden Sie Platzhalter für notwendige Informationen]
[Wenn das Beispiel kürzer ist als das erwartete reale Beispiel, geben Sie in Klammern () an, wie das reale Beispiel länger/kürzer/anders sein sollte und verwenden Sie Platzhalter!]

# Bemerkungen [fakultativ]

[Optional: Grenzfälle, detaillierte Informationen und wichtige Hinweise]
""".strip()

def generate_prompt(aufgabe_oder_prompt: str).
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "Rolle": "System", "Inhalt": META_SYSTEMS
                
            },
            {
                "role": "user", "content": META_PROMPT, }, {
                "content": "Aufgabe, Ziel oder aktuelle Eingabeaufforderung: \n" + task_or_prompt,
            }
        ]
    )

    return completion.choices[0].message.content

Cue-Editor

Zur Bearbeitung des Hinweises verwenden wir einen leicht modifizierten Meta-Hinweis. Während es relativ einfach ist, die Anwendung direkt zu bearbeiten, kann es schwierig sein, die notwendigen Änderungen bei offeneren Modifikationen zu identifizieren. Um dieses Problem zu lösen, haben wir eine Antwort am Anfang desAbschnitt ArgumentationDas Hilfemodell bestimmt, welche Änderungen erforderlich sind, indem es Faktoren wie die Klarheit der vorhandenen Aufforderungswörter, die Reihenfolge der Gedankenkette, die Gesamtstruktur und die Spezifität bewertet. Die Argumentationskomponente schlägt Verbesserungen vor, die dann aus der endgültigen Antwort herausgefiltert werden.

Text-Metahinweise für die Bearbeitung

von openai importieren OpenAI

client = OpenAI()

META_PROMPT = """
Erzeugt einen detaillierten Systemprompt auf der Grundlage des aktuellen Prompts und der Änderungsbeschreibung, um das Sprachmodell effektiv durch die Aufgabe zu führen.

Die endgültige Ausgabe ist der vollständige, korrigierte Prompt-Text. Zuvor sollten Sie jedoch das Prompt-Wort mit Hilfe des Tags am Anfang Ihrer Antwort analysieren und Folgendes klären:

- Einfache Änderung: (Ja/Nein) Ist die Beschreibung der Änderung klar und einfach? (Wenn ja, überspringen Sie die folgenden Fragen)
- Argumentation: (Ja/Nein) Werden im aktuellen Prompt-Wort Argumente, Analysen oder Gedankenketten verwendet?
    - IDENTIFIZIERUNG: (max. 10 Wörter) Wenn ja, in welchem Teil der Argumentation?
    - SCHLUSSFOLGERUNG: (Ja/Nein) Wird die Schlussfolgerung durch eine Gedankenkette erreicht?
    - Reihenfolge: (vor/nach) Steht die Gedankenkette vor oder nach der Schlussfolgerung?
- Struktur: (Ja/Nein) Gibt es eine klare Struktur für das Eingangswort?
- Beispiele: (Ja/Nein) Enthält das Eingangsstichwort eine kleine Anzahl von Beispielen?
    - Repräsentativität: (1-5) Wenn Beispiele vorhanden sind, wie repräsentativ sind die Beispiele?
- Komplexität: (1-5) Wie komplex ist das Eingabehinweiswort?
    - Aufgabe: (1-5) Wie hoch ist die Komplexität der Aufgabe?
    - Erforderlichkeit: ()
- Spezifität: (1-5) Wie detailliert und spezifisch sind die Stichwörter? (nicht gleichbedeutend mit Länge)
- Priorität: (Liste) die wichtigsten 1-3 Kategorien, die behandelt werden müssen.
- SCHLUSSFOLGERUNG: (max. 30 Wörter) Beschreiben Sie auf der Grundlage der obigen Bewertung kurz, was und wie Änderungen vorgenommen werden sollten. Sie müssen sich nicht streng an die aufgeführten Kategorien halten.

#-Leitlinien

- Verstehen Sie die Aufgabe: Erfassen Sie die wichtigsten Ziele, Anforderungen, Beschränkungen und gewünschten Ergebnisse.
- Minimale Änderungen: Wenn bereits Hinweise vorhanden sind, verbessern Sie diese nur, wenn sie einfach sind; bei komplexen Hinweisen verbessern Sie die Klarheit und fügen fehlende Elemente hinzu, ohne die ursprüngliche Struktur zu verändern.
- Überlegungen vor Schlussfolgerungen**: Stellen Sie sicher, dass der Schritt der Überlegungen durchgeführt wird, bevor irgendwelche Schlussfolgerungen gezogen werden. Vorsicht! Kehren Sie die Reihenfolge um, wenn in den vom Benutzer gelieferten Beispielen die Argumentation nach der Schlussfolgerung folgt! Beginnen Sie niemals mit einer Schlussfolgerung!
    - Reihenfolge der Argumentation: Markieren Sie den Abschnitt "Argumentation" und den Abschnitt "Schlussfolgerung" des Stichworts (geben Sie Feldnamen an). Legen Sie für jeden Abschnitt fest, ob die Reihenfolge umgedreht werden muss.
    - Die Schlussfolgerung, die Klassifizierung oder das Ergebnis sollten immer als letztes erscheinen.
- Beispiele: Falls hilfreich, fügen Sie hochwertige Beispiele ein und verwenden Sie [eckige Klammern] als Platzhalter für komplexe Elemente.
   - Geben Sie an, welche Arten von Beispielen aufgenommen werden müssen, wie viele, und ob sie komplex genug sind, um die Verwendung von Platzhaltern zu rechtfertigen.
- Klarheit und Einfachheit: Verwenden Sie eine klare, spezifische Sprache. Vermeiden Sie unnötige Anweisungen oder fade Aussagen.
- Typografie: Verwenden Sie Markdown-Funktionen, um die Lesbarkeit zu verbessern. Vermeiden Sie ````-Codeblöcke, es sei denn, dies wird ausdrücklich verlangt.
- Bewahren Sie Benutzerinhalte: Wenn die Eingabeaufgabe oder -aufforderung ausführliche Richtlinien oder Beispiele enthält, bewahren Sie diese vollständig oder so weit wie möglich. Wenn dies nicht eindeutig ist, unterteilen Sie die Aufgabe in Teilschritte. Behalten Sie alle vom Benutzer bereitgestellten Details, Richtlinien, Beispiele, Variablen oder Platzhalter bei.
- Konstanten: Nehmen Sie Konstanten in den Prompt auf, da sie nicht von Prompt-Injection-Angriffen betroffen sind, wie z. B. Leitlinien, Bewertungskriterien und Beispiele.
- Ausgabeformate: Geben Sie das am besten geeignete Ausgabeformat an und machen Sie Angaben zu Länge und Syntax der Ausgabe (z. B. kurze Sätze, Absätze, JSON usw.).
    - Für Aufgaben, bei denen die Ausgabe explizite oder strukturierte Daten enthält (Kategorien, JSON usw.), ist die Ausgabe von JSON zu bevorzugen.
    - JSON sollte nicht in Codeblöcke (``) eingeschlossen werden, es sei denn, dies wird ausdrücklich verlangt.

Die abschließenden Prompt-Wörter, die Sie ausgeben, sollten der unten stehenden Struktur folgen. Fügen Sie keine zusätzlichen Kommentare ein, sondern geben Sie nur das vollständige Prompt-Wort des Systems aus. Fügen Sie insbesondere keine zusätzlichen Meldungen am Anfang oder am Ende des Prompts ein (verwenden Sie z. B. nicht "----").

[Anweisungen, die die Aufgabe kurz beschreiben - dies ist die erste Zeile des Promptworts, es werden keine Abschnittsüberschriften benötigt]

[Fügen Sie bei Bedarf weitere Details hinzu].

[Optionaler Abschnitt mit Überschriften oder Aufzählungszeichen zur Beschreibung detaillierter Schritte].

#-Schritte [fakultativ].

[Fakultativ: Detaillierte Aufschlüsselung der für die Durchführung der Aufgabe erforderlichen Schritte].

# Ausgabeformat

[Geben Sie die Anforderungen an das Ausgabeformat an, z. B. Länge der Antwort, Struktur (z. B. JSON, Markdown usw.)]

# Beispiel [optional].

[Optional: 1-3 anschauliche Beispiele, Verwendung von Platzhaltern und Markierung von Eingabe- und Ausgabepositionen, wenn komplexe Elemente erforderlich sind. Verwenden Sie Klammern, um anzugeben, dass das tatsächliche Beispiel länger/kürzer/anders sein sollte].

# Anmerkung [fakultativ].

[fakultativ: Randfälle, detaillierte Informationen oder Hervorhebung von Bereichen, die besonders zu berücksichtigen sind].
[HINWEIS: muss mit einem Abschnitt beginnen, der nächste Tag, den Sie erzeugen, sollte lauten]
""".strip()

def generate_prompt(task_or_prompt: str).
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "Rolle": "System", "Inhalt": META_SYSTEMS
                
            },
            {
                "role": "user", "content": "Aufgabe, Ziel oder aktuelle Eingabeaufforderung:\n" + task_prompt:\n
                "content": "Aufgabe, Ziel oder aktuelle Eingabeaufforderung:\n" + task_or_prompt,
            }, }
        ]
    )

    return completion.choices[0].message.content

Meta-Tipps für die Audiobearbeitung

von openai importieren OpenAI

client = OpenAI()

META_PROMPT = """
Ausgehend von einem aktuellen Prompt und Änderungsanweisungen wird ein detaillierter Systemprompt generiert, um das Sprachmodell für die Echtzeit-Audioausgabe effektiv durch die Aufgabe zu führen.

Die endgültige Ausgabe ist die vollständige, korrigierte Eingabeaufforderung im Ist-Zustand. Zu Beginn der Antwort wird der Prompt jedoch mit Hilfe von Labels analysiert, um Folgendes zu verdeutlichen:

- Einfache Änderung: (ja/nein) Sind die Änderungsanweisungen klar und einfach? (Wenn ja, überspringen Sie die folgenden Fragen)
- Begründungen: (ja/nein) Werden in der aktuellen Aufforderung Begründungen, Analysen oder Gedankenketten verwendet?
    - Beschriftung: (max. 10 Wörter) Wenn ja, welche Teile enthalten Überlegungen?
    - Schlussfolgerung: (ja/nein) Wird die Gedankenkette verwendet, um zu einer Schlussfolgerung zu gelangen?
    - Reihenfolge: (vorher/nachher) Steht die Gedankenkette vorher oder nachher?
- Struktur: (ja/nein) Hat die Eingabeaufforderung eine klare Struktur?
- Beispiele: (ja/nein) Enthält die Eingabeaufforderung ein paar Beispiele?
    - Repräsentativität: (1-5) Wenn es Beispiele gibt, wie repräsentativ sind sie?
- Komplexität: (1-5) Wie hoch ist die Komplexität der Eingabeaufforderung?
    - Aufgaben: (1-5) Wie hoch ist die Komplexität der implizierten Aufgaben?
    - Erforderlichkeit: ()
- Spezifität: (1-5) Wie detailliert und spezifisch sind die Aufforderungen? (unabhängig von der Länge)
- Priorität: (Liste) Welche 1-3 Kategorien sind am wichtigsten.
- Schlussfolgerung: (max. 30 Wörter) Beschreiben Sie kurz, was sich aufgrund der vorangegangenen Bewertung ändern muss. Sie müssen sich nicht auf die aufgeführten Kategorien beschränken.

#-Leitlinien

- Verstehen der Aufgabe: Verstehen Sie die wichtigsten Ziele, Anforderungen, Einschränkungen und erwarteten Ergebnisse.
- Tonfall: Stellen Sie sicher, dass der Tonfall klar formuliert ist. Die Vorgabe sollte gefühlsbetont und freundlich sein und sich schnell äußern, damit der Benutzer nicht warten muss.
- Einschränkungen bei der Audioausgabe: Da das Modell Audio ausgibt, sollte die Antwort kurz und unterhaltsam sein.
- Minimale Änderungen: Wenn bereits Aufforderungen vorhanden sind, sollten diese nur in einfachen Fällen verbessert werden. Bei komplexen Hinweisen sollten Sie die Klarheit verbessern und fehlende Elemente hinzufügen, ohne die ursprüngliche Struktur zu verändern.
- Beispiele: Falls hilfreich, fügen Sie hochwertige Beispiele ein und verwenden Sie [eckige Klammern] als Platzhalter für komplexe Elemente.
   - Welche Arten von Beispielen aufgenommen werden sollen, wie viele, und ob Platzhalter erforderlich sind.
  - Beispiele müssen die kurzen Dialogausgaben des Modells widerspiegeln.
Standardmäßig sollten die Sätze sehr kurz sein. Die 3 Sätze des Helfers sollten getrennt sein, um mit dem Benutzer zu interagieren.
  - Standardmäßig sollte jeder Satz nur eine kleine Anzahl von Wörtern enthalten (5-20 Wörter oder so). Wenn der Benutzer ausdrücklich eine "kurze" Antwort verlangt, sollte das Beispiel nur 1-10 Wörter umfassen.
  - Die Beispiele sollten mehrere Dialogrunden enthalten (mindestens 4 Hin- und Hergespräche zwischen Benutzer und Assistent), die reale Unterhaltungen widerspiegeln.
- Klarheit und Prägnanz: Verwenden Sie eine klare, spezifische Sprache. Vermeiden Sie unnötige Anweisungen oder fade Aussagen.
- Behalten Sie den Benutzerinhalt bei: Wenn die Eingabeaufgabe oder -aufforderung detaillierte Anweisungen oder Beispiele enthält, behalten Sie diese so weit wie möglich bei. Wenn der Inhalt vage ist, sollten Sie ihn in Teilschritte aufgliedern. Behalten Sie vom Benutzer bereitgestellte Details, Anweisungen, Beispiele, Variablen oder Platzhalter bei.
- Konstanten: Nehmen Sie Konstanten in Prompts auf, die weniger anfällig für Prompt-Injektionen sind, z. B. Richtlinien, Bewertungskriterien und Beispiele.

Die endgültige Ausgabeaufforderung sollte der nachstehenden Struktur folgen. Fügen Sie keine zusätzlichen Kommentare ein, sondern geben Sie nur den vollständigen Systemprompt aus. Fügen Sie insbesondere keine zusätzlichen Informationen am Anfang oder Ende des Prompts hinzu. (z.B. verwenden Sie nicht "----")

[Kurze Aufgabenbeschreibung - dies ist die erste Zeile des Prompts, eine Unterabschnittsüberschrift ist nicht erforderlich]

[Fügen Sie bei Bedarf detaillierte Anweisungen hinzu].

[Optionaler Abschnitt mit detaillierten Schritten für Überschriften oder Aufzählungszeichen].

# Beispiel [fakultativ].

[Fakultativ: 1-3 klar definierte Beispiele, ggf. mit Platzhaltern. Markieren Sie deutlich den Anfang und das Ende der Beispiele sowie die Ein- und Ausgänge. Bei Bedarf Platzhalter verwenden]
[Wenn das Beispiel kürzer ist als das erwartete reale Beispiel, markieren Sie mit (), wie das reale Beispiel länger/kürzer/anders sein soll und verwenden Sie Platzhalter!]

# Anmerkungen [fakultativ].

[fakultativ: Randfälle, detaillierte Beschreibungen und Bereiche, in denen bestimmte wichtige Überlegungen hervorgehoben oder wiederholt werden sollen]
[HINWEIS: Sie müssen mit einem Abschnitt beginnen. Das nächste Token, das Sie unmittelbar danach erzeugen, sollte sein:]
""".strip()

def generate_prompt(task_or_prompt: str):
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "Rolle": "System", "Inhalt": META_SYSTEMS
                
            },
            {
                "role": "user", "content": "Aufgabe, Ziel oder aktuelle Eingabeaufforderung:\n
                "content": "Aufgabe, Ziel oder aktuelle Eingabeaufforderung:\n" + task_or_prompt,
            }, }
        ]
    )

    return completion.choices[0].message.content

bauen

Strukturierte Ausgabe Schemata und Funktionsschemata sind selbst JSON-Objekte, so dass wir eine strukturierte Ausgabe verwenden, um sie zu erzeugen. Dies erfordert die Definition einer Architektur für die gewünschte Ausgabe, die in diesem Fall selbst eine Architektur ist. Hierfür verwenden wir selbstbeschreibende Architekturen - diemeta-architektur.

Da die Funktionsarchitektur des Parameter Das Feld selbst ist eine Architektur, also verwenden wir dieselbe Meta-Architektur, um die Funktion zu erzeugen.

Definition von eingeschränkten Meta-Architekturen

Strukturierte Ausgabe Es werden zwei Modi unterstützt:strict=true im Gesang antworten strict=falseDer "strenge Modus" garantiert die perfekte Einhaltung nur durch eingeschränkte Stichproben. Beide Modi verwenden dasselbe Modell, um der vorgegebenen Architektur zu folgen, aber nur der "strenge Modus" garantiert eine perfekte Einhaltung durch eingeschränkte Stichproben.

Unser Ziel ist es, Strict-Mode-Architekturen unter Verwendung des Strict-Mode selbst zu erzeugen. Allerdings ist die offizielle Spezifikation der JSON-Architektur Die bereitgestellte Meta-Architektur stützt sich auf das strenge Modell in Derzeit nicht unterstützte Funktionen. Dies stellt eine Herausforderung für die Eingangs- und Ausgangsarchitekturen dar.

1. Eingangsarchitektur: Wir können die Eingangsarchitektur nicht in Nicht unterstützte Funktionen um die Ausgangsarchitektur zu beschreiben.
2. Output-Architektur: Die erzeugte Architektur kann nicht enthalten Nicht unterstützte Funktionen.

Da wir in der Ausgabe-Architektur neue Schlüssel erzeugen müssen, muss die Eingabe-Meta-Architektur die additionalProperties. Das bedeutet, dass wir derzeit keine strikten Muster zur Erzeugung von Architekturen verwenden können. Wir wollen aber dennoch Architekturen erzeugen, die den Einschränkungen strikter Muster entsprechen.

Um diese Einschränkung zu überwinden, definieren wir eine Pseudo-Elementararchitektur (Computertechnik) -- Eine Meta-Architektur, die Funktionen verwendet, die das strenge Schema nicht unterstützen, um Funktionen zu beschreiben, die nur vom strengen Schema unterstützt werden. Im Wesentlichen weicht dieser Ansatz bei der Definition der Meta-Architektur vom Strict Mode ab, wobei sichergestellt wird, dass die resultierende Architektur den Einschränkungen des Strict Mode folgt.

eine ausführliche Diskussion

Wie wir die Pseudo-Meta-Architektur entworfen haben

Die Konstruktion von eingeschränkten Meta-Architekturen ist eine anspruchsvolle Aufgabe, bei der wir unsere Modelle als Hilfe einsetzen.

Wir beginnen mit dem Senden einer Nachricht im JSON-Modus an die o1-vorschau im Gesang antworten gpt-4o beschrieb unsere Ziele anhand eines Dokuments, das den Output strukturierte. Nach mehreren Iterationen entwickelten wir eine erste brauchbare Meta-Architektur.

Dann verwenden wir die gpt-4o und strukturierte Ausgaben, dieursprüngliche Strukturzusammen mit unserer Aufgabenbeschreibung und Dokumentation, um bessere Kandidatenarchitekturen zu generieren. In jeder Iteration verwenden wir die bessere Architektur, um den nächsten Schritt zu generieren, bis wir schließlich eine manuelle Prüfung durchführen.

Nach der Bereinigung des Outputs validieren wir die Architektur anhand einer Reihe von Bewertungstests, um die Anwendbarkeit der Architektur und der Funktionen sicherzustellen.

Bereinigung der Ausgabe

Der strenge Modus garantiert die perfekte Einhaltung der Architektur. Da wir den strengen Modus jedoch nicht während der Generierung verwenden können, müssen wir die Ausgabe nach der Generierung validieren und transformieren.

Nach der Erstellung der Architektur führen wir die folgenden Schritte durch:

1. Setzen Sie alle Objekte der Kategorie additionalProperties eingestellt auf falsch.
2. Markieren Sie alle Attribute als erforderlich.
3. Für eine strukturierte Output-ArchitekturDas Paket wird verpackt in der json_schema im Objekt.
4. Für FunktionenDas Paket wird verpackt in der Funktion im Objekt.

= = Echtzeit-APIs Funktion (math.) Objekt unterscheidet sich geringfügig von der Chat-Abschluss-API, verwendet aber die gleiche Architektur. ==

Metamodell

Jeder Metamodus hat einen entsprechenden Hinweis, der eine Handvoll Beispiele enthält. Wenn wir dies mit der Zuverlässigkeit der strukturierten Ausgabe kombinieren - auch ohne den Strict-Modus zu verwenden - können wir die gpt-4o-mini Mustergenerierung durchführen.

Strukturiertes Ausgabemodell

von openai importieren OpenAI
json importieren
client = OpenAI()
META_SCHEMA = {
"name": "metaschema", "schema": {
"schema": {
"type": "object", "properties": {
"properties": {
"name": {
"type": "string", "description": { "name": {
"description": "Name des Schemas"
},
"type": {
"enum": [
"object".
"array".
"string".
"Zahl", "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": {
"Typ": "Objekt", "Eigenschaften": {
"properties": {
"type": {
"type": "string",
"enum": [
"object".
"array".
"string".
"Zahl", "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 = """
#-Richtlinie
Gibt ein gültiges JSON-Beschreibungsschema zurück.
Sie müssen auch sicherstellen, dass:
- Alle Felder des Objekts sind als Pflichtfelder gekennzeichnet.
- ich wiederhole, alle Felder müssen als Pflichtfelder gekennzeichnet sein
- alle additionalProperties des Objekts müssen auf false gesetzt sein
- Daher sollten Eigenschaften wie "Attribute" oder "Metadaten", die normalerweise zusätzliche Eigenschaften erlauben, auf einen festen Satz von Eigenschaften gesetzt werden.
- Alle Objekte müssen Eigenschaften definieren
- Die Reihenfolge der Felder ist wichtig. Jede Form des "Denkens" oder "Erklärens" sollte vor der Schlussfolgerung stehen.
- $defs müssen in den Schemaparametern definiert werden.
Nicht unterstützte Schlüsselwörter sind:
- für Zeichenketten: minLength, maxLength, pattern, format
- für Zahlen: minimum, maximum, multipleOf
- für Objekte: patternProperties, unevaluatedProperties, propertyNames, minProperties, maxProperties
- für Arrays: unevaluatedItems, contains, minContains, maxContains, minItems, maxItems, uniqueItems
Andere Hinweise:
- Definitionen und Rekursion werden unterstützt
- Fügen Sie Verweise nur ein, wenn es notwendig ist, z. B. "$defs", das sich innerhalb des "schema"-Objekts befinden muss.
# Beispiel
Eingabe: Generierung eines mathematischen Argumentationsschemas mit Schritten und endgültiger Antwort.
Ausgabe: {
"name": "maths_reasoning",
"Typ": "Objekt",
"properties": {
"steps": {
"type": "array",
"description": "Eine Abfolge von Schritten, die zur Beantwortung einer mathematischen Aufgabe gehören." ,
"items": {
"type": "object", "properties": {
"properties": {
"explanation": {
"type": "string", "description": {
"description": "Eine Beschreibung der in diesem Schritt verwendeten Argumentation oder Methodik."
},
"output": {
"type": "string", "description": "Die Beschreibung des jeweiligen Schritts.
"description": "Das Ergebnis oder die Ausgabe dieses bestimmten Schritts."
}
},
"required": [
"explanation".
"output"
], "additionalProperties": false
"additionalProperties": false
}
},
"final_answer": {
"type": "string",
"description": "Die endgültige Antwort auf die Mathefrage."
}
},
"required": [
"steps".
"final_answer"
], "required": [ "steps", "final_answer
"additionalProperties": false
}
Eingabe: gib mir eine verknüpfte Liste
Ausgabe: {
"name": "linked_list",
"Typ": "Objekt",
"properties": {
"linked_list": {
"$ref": "#/$defs/linked_list_node",.
"description": "Der Kopfknoten der verknüpften Liste".
}
},.
"$defs": {
"linked_list_node": {
"type": "object",
"description": "Definiert einen Knoten in einer einzelnen verknüpften Liste." ,
"properties": {
"value": {
"type": "number",
"description": "Der in diesem Knoten gespeicherte Wert."
},
"next": {
"anyOf": [
{
"$ref": "#/$defs/linked_list_node"
},
{
"type": "null"
}
], { "Typ": "null" }, { "Typ": "null" }
"description": "Verweist auf den nächsten Knoten; null, wenn es der letzte Knoten ist."
}
},
"required": [
"value".
"next"
], "additionalProperties": false
"additionalProperties": false
}
}, "required": [ [ "next" ], "additionalProperties": false }
"required": [
"linked_list"
], "additionalProperties": false
"additionalProperties": false
}
Eingabe: dynamisch generierte Benutzeroberfläche
Ausgabe: {
"name": "ui",
"Typ": "Objekt", "Eigenschaften": {
"properties": {
"type": {
"type": "string", "description": { "type": "ui", "properties": { "type": {
"description": "Der Typ der UI-Komponente.
"enum": [
"div".
"section", "field", [ "section", "field", "header", "header
"feld".
"form"
}, "Kopfzeile", "Abschnitt", "Feld", "Formular
},
"label": {
"type": "string", "description": "UI-Komponentenbeschriftung für Schaltflächen oder Formularfelder", "label": {
"description": "Label für UI-Komponente, verwendet für Schaltflächen oder Formularfelder"
},
"children": {
"description": "Verschachtelte UI-Komponente", "items": { "type": "array", "description": "Verschachtelte UI-Komponente", "description": "Verschachtelte UI-Komponente.
"items": {
"$ref": "#"
}
}, "attributes": { "$ref": "#" }
"attributes": {
"type": "array", "description": "Gilt für jedes Element der UI-Komponente.
"description": "Jedes Attribut der UI-Komponente, das für jedes Element gilt", "items": {
"items": {
"type": "object", "attributes": { "type": "array", "description": "Jedes beliebige Attribut, das auf ein beliebiges Element der UI-Komponente zutrifft", "items": { "type": "object",
"properties": {
"name": {
"type": "string", "description": "name": {
"description": "Der Name der Eigenschaft, z. B. onClick oder className"
}, "description": "Eigenschaftsname, z.B. onClick oder className
"value": {
"description": "Der Wert der Eigenschaft".
}
}, "value": { "type": "string", "description": "Wert der Eigenschaft" }, "value": { "value": { "value": { "description": "Wert der Eigenschaft" }
"required": [
"name", "wert
"value"
], "additionalProperties": false
"additionalProperties": false
}
}
}, "required": [["value" ], "additionalProperties": false } }
"required": [
"Typ".
"label".
"Kinder", "Attribute
"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=[
{
"role": "system",
"inhalt": META_PROMPT,
},
{
"role": "user", "content": "Beschreibung:\n" + description, }, {
"Inhalt": "Beschreibung:\n" + Beschreibung,
}
]
)
return json.loads(completion.choices[0].message.content)

Funktionsmodell

von openai importieren OpenAI
json importieren
client = OpenAI()
META_SCHEMA = {
"name": "funktions-metaschema",
"schema": {
"typ": "objekt", "eigenschaften": {
"properties": {
"name": {
"type": "string", "description": { "name": {
"description": "Der Name der Funktion".
},
"description": {
"type": "string",
"description": "Beschreibung der Funktion"
},
"parameters": {
"$ref": "#/$defs/schema_definition",
"description": "JSON-Schema zur Definition der Funktionsparameter"
}
}, "description": "Definieren Sie das JSON-Schema für Funktionsparameter" }
"required": [
"name".
"Beschreibung", "Parameter": [ "Name", "Beschreibung", "Parameter
"parameter"
"additionalProperties": Falsch,
"$defs": {
"schema_definition": {
"type": "object", "properties": { "schema_definition": {
"properties": {
"type": {
"type": "string",
"enum": [
"object".
"array".
"string".
"Zahl", "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 = """
#-Anweisungen
Gibt ein gültiges Muster zurück, das eine Funktion beschreibt.
Achten Sie besonders darauf, dass "required" und "type" immer auf der richtigen Verschachtelungsebene stehen. Zum Beispiel sollte "required" auf der gleichen Ebene wie "properties" stehen, nicht innerhalb davon.
Stellen Sie sicher, dass jede Eigenschaft, egal wie kurz sie ist, einen korrekt verschachtelten Typ und eine Beschreibung hat.
# Beispiel
Eingabe: Zuweisung von Werten zu Hyperparametern des neuronalen Netzes
Ausgabe: {
"name": "set_hyperparameters",
"description": "Den Hyperparametern des neuronalen Netzes Werte zuweisen", "description": "Den Hyperparametern des neuronalen Netzes Werte zuweisen",
"Parameter": {
"type": "object", "required": [ "name": "set_hyperparameters", "description": "Neural network hyperparameters Werte zuweisen", "parameters": { "type": "object",
"required": [
"learning_rate",
"epochs"
"properties": {
"epochs": {
"type": "number", "description": "Anzahl der vollständigen Durchläufe des Datensatzes.
"description": "Anzahl der vollständigen Durchläufe des Datensatzes."
},
"learning_rate": {
"description": "Modell-Lernrate"
}
}
}
}
Eingabe: Planen einer Bewegungsbahn für den Roboter
Ausgabe: {
"description": "Planen Sie einen Bewegungspfad für den Roboter", "parameters": {
"Parameter": {
"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": "Zahl",
"description": "Endpunkt x-Koordinate"
"y": {
"description": "Endpunkt Y-Koordinate" }, "y": { "type": "number", "description": "Endpunkt Y-Koordinate" }
}
}
}, "obstacles": { "type": "number", "description": "End Y coordinate" }
"obstacles": {
"type": "array", "description": "Ein Array von Hinderniskoordinaten.
"description": "Ein Array von Hinderniskoordinaten.",
"items": {
"Typ": "Objekt", "Eigenschaften": {
"properties": {
"x": {
"type": "number", "description".
"description": "Obstacle X coordinates"
}, "y": { "x": { "Typ": "Zahl", "Beschreibung": "Hindernis X-Koordinaten
"y": {
"description": "Hindernis-Y-Koordinate" }, "y": { "type": "number", "description": "Hindernis-Y-Koordinate"
}
}
}
}, "description": "Hindernis Y-Koordinate" }
"start_position": {
"Typ": "Objekt", "Eigenschaften": {
"properties": {
"x": {
"type": "number", "description": { "start_position": {
"description": "Startpunkt x-Koordinate"
}, "y": { "x": { "type": "number", "description": "Start X-Koordinate
"y": {
"type": "number", "description": "Start Y-Koordinate" }, "y": { "type": "number", "description": "Start Y-Koordinate
"description": "Startpunkt Y-Koordinate" }, "y": { "type": "number", "description": "Startpunkt Y-Koordinate" }
}
}
}
}
}
}
Input: Berechnen verschiedener technischer Indikatoren
Ausgabe: {
"description": "Berechnet verschiedene technische Indikatoren.", "parameters": {
"parameter": {
"type": "object", "required": [ "type": "object", "description": "Berechne verschiedene technische Indikatoren", "parameters": {
"required": [
"ticker", "indicators": [
"indicators"
], "properties": { "type": "object", "required": [ "ticker", "indicators" ], "properties".
"properties": {
"indikatoren": {
"type": "array", "description": "Liste der zu berechnenden technischen Indikatoren.
"description": "Liste der zu berechnenden technischen Indikatoren",
"items": {
"description": "Technische Indikatoren",
"enum": [
"RSI".
"MACD".
"Bollinger_Bands", "Stochastic_Oscillator".
"Stochastic_Oscillator"
]
}
}, }
"period": {
"type": "number", "description": "Die Zeitspanne der Analyse.
"description": "Der analysierte Zeitraum"
},
"ticker": {
"description": "Aktiensymbol"
}
}
}
}
""".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=[
{
"role": "system",
"inhalt": META_PROMPT,
},
{
"role": "user", "content": "description:\n" + description, }, {
"inhalt": "beschreibung:\n" + beschreibung,
}
]
)
return json.loads(completion.choices[0].message.content)

Der Leitfaden für Laien zum Einstieg in die KI

Hilft Ihnen, die Nutzung von KI-Tools kostengünstig und von Null an zu erlernen.KI ist, wie Bürosoftware, eine wesentliche Fähigkeit für jeden. Die Beherrschung von KI verschafft Ihnen einen Vorteil bei der Stellensuche und die Hälfte des Aufwands bei Ihrer zukünftigen Arbeit und Ihrem Studium.

Details ansehen>