Beherrschung der Wörterbuchkette im Immediate Engineering

Einführung

Die Fähigkeit, schnell zu sein, ist in den sich rasch entwickelnden Bereichen der künstlichen Intelligenz und der Verarbeitung natürlicher Sprache immer wichtiger geworden. Experten und Laien in der KI haben mit der Chain of Dictionary-Methode, einer wirksamen Methode, großen Erfolg. Dieser Artikel wird die Implementierung, Vorteile und Anwendungen dieser faszinierenden Strategie ausführlich behandeln. Machen Sie sich bereit, neue Wege für Ihren KI-Austausch zu entdecken!

Überblick

1. Die Chain-of-Dictionary-Technik organisiert eine Reihe verknüpfter Wörterbücher oder JSON-Objekte, um die KI durch Aufgaben oder Gespräche zu führen.
2. Es bietet strukturierte Daten, kontextuelle Klarheit, Flexibilität und mehr Kontrolle über KI-Reaktionen.
3. Anhand dieser Methode wird anhand eines Beispiels das Erstellen einer Story in mehreren Schritten demonstriert, wobei strukturierte Kreativität und inhaltliche Kontinuität gewährleistet sind.
4. Ein weiteres Beispiel zeigt einen mehrsprachigen Reiseassistenten, der Informationen in verschiedene Sprachen übersetzt und dabei kulturelle Nuancen beibehält.
5. Zu den wichtigsten Vorteilen zählen Modularität, Übersichtlichkeit, Skalierbarkeit und Anpassbarkeit, wodurch es für verschiedene Anwendungen geeignet ist.
6. Zu den zu berücksichtigenden Herausforderungen zählen Token-Einschränkungen, Kohärenz zwischen den Schritten und eine effektive Fehlerbehandlung.

Die Kette der Wörterbuchtechnik

Eine ausgeklügelte Good-Immediate-Engineering-Technik namens Chain of Dictionary-Methode beinhaltet den Aufbau eines Netzwerks verknüpfter Wörterbücher oder JSON-Objekte. Das KI-Modell wird durch die spezifischen Anweisungen, Kontexte oder Daten, die jedes Wörterbuch in der Kette enthält, durch eine schwierige Aufgabe oder Konversation geführt.

Aus diesem Grund sollten Sie es verwenden:

1. Strukturierte Daten: Strukturierte Daten sind Informationen, die der KI in organisierter und hierarchischer Weise präsentiert werden können.
2. Kontextuelle Klarheit: Verleiht jedem Prozessschritt einen klaren Kontext.
3. Flexibilität: Einfach an verschiedene Szenarien oder KI-Modelle anzupassen.
4. Mehr Kontrolle: Bietet eine genauere Kontrolle über die Reaktionen der KI.

Lassen Sie uns ein reales Szenario untersuchen, um diese Strategie in Aktion zu zeigen!

Beispiel 1: Eine Story in mehreren Schritten erstellen

Hier sind die Voraussetzungen und die Einrichtung:

Set up von Abhängigkeiten

!pip set up openai --upgrade

Importieren von Bibliotheken und Einrichten des OpenAI-Shoppers

import os
from openai import OpenAI
consumer = OpenAI()

Einrichten der API-Schlüsselkonfiguration

os.environ("OPENAI_API_KEY")= “Your open-API-Key”

Stellen wir uns das Szenario vor, in dem wir einen KI-gesteuerten Geschichtengenerator entwickeln möchten, der uns durch die verschiedenen Phasen der Geschichtenproduktion führt. Um der KI dabei zu helfen, verwenden wir den Chain of Dictionary-Ansatz.

import openai
from IPython.show import show, Markdown, Picture as IPImage
from PIL import Picture, ImageDraw, ImageFont
import textwrap
import os

# Arrange your OpenAI consumer (be sure to've set your API key)
consumer = openai.OpenAI()

# Outline the steps for the story creation chain
story_chain = {
    "step1": {
        "instruction": "Generate a primary premise for a science fiction story",
        "context": "Consider a novel idea involving house exploration or superior expertise",
        "output": ""
    },
    "step2": {
        "instruction": "Develop the primary character primarily based on the premise",
        "context": "Take into account their background, motivations, and challenges",
        "output": ""
    },
    "step3": {
        "instruction": "Create a plot define",
        "context": "Embody a starting, center, and finish. Introduce battle and determination",
        "output": ""
    },
    "step4": {
        "instruction": "Write the opening paragraph",
        "context": "Set the tone and introduce the primary components of the story",
        "output": ""
    }
}

def generate_story_element(immediate):
    """
    Generate a narrative ingredient primarily based on the given immediate utilizing OpenAI API.

    Args:
        immediate (str): The immediate to generate the story ingredient.

    Returns:
        str: The generated story ingredient in Markdown format.
    """
    response = consumer.chat.completions.create(
        messages=(
            {"position": "system", "content material": "You're a artistic writing assistant. Format your responses in Markdown."},
            {"position": "person", "content material": immediate + " Present your response in Markdown format."}
        ),
        mannequin="gpt-3.5-turbo",
    )
    return response.decisions(0).message.content material.strip()

def text_to_image(textual content, filename, title):
    """
    Convert textual content to a picture and put it aside to a file.

    Args:
        textual content (str): The textual content to transform to a picture.
        filename (str): The filename to save lots of the picture.
        title (str): The title to show on the picture.
    """
    # Create a brand new picture with white background
    img = Picture.new('RGB', (800, 600), colour="white")
    d = ImageDraw.Draw(img)
    
    # Use a default font
    font = ImageFont.load_default()
    title_font = ImageFont.load_default()
    
    # Draw the title
    d.textual content((10, 10), title, font=title_font, fill=(0, 0, 0))
    
    # Wrap the textual content
    wrapped_text = textwrap.wrap(textual content, width=70)
    
    # Draw the textual content
    y_text = 50
    for line in wrapped_text:
        d.textual content((10, y_text), line, font=font, fill=(0, 0, 0))
        y_text += 20
    
    # Save the picture
    img.save(filename)

# Course of every step within the chain
for step, content material in story_chain.objects():
    immediate = f"{content material('instruction')}. {content material('context')}"
    if step != "step1":
        immediate += f" Based mostly on the earlier: {story_chain(f'step{int(step(-1)) - 1}')('output')}"
    content material('output') = generate_story_element(immediate)
    
    # Show the output
    show(Markdown(f"### {step.higher()}:n{content material('output')}"))
    
    # Create and save a picture for this step
    text_to_image(content material('output'), f"{step}.png", step.higher())
    
    # Show the saved picture
    show(IPImage(filename=f"{step}.png"))

# Closing story compilation
final_story = f"""
## Premise:
{story_chain('step1')('output')}

## Principal Character:
{story_chain('step2')('output')}

## Plot Define:
{story_chain('step3')('output')}

## Opening Paragraph:
{story_chain('step4')('output')}
"""

# Show the ultimate story
show(Markdown("# FINAL STORY ELEMENTS:n" + final_story))

# Create and save a picture for the ultimate story
text_to_image(final_story, "final_story.png", "FINAL STORY ELEMENTS")

# Show the ultimate story picture
show(IPImage(filename="final_story.png"))

print("Photographs have been saved as PNG recordsdata within the present listing.")

Code Erklärung

Dieser Code veranschaulicht, wie wir eine KI mithilfe des Chain of Dictionary-Ansatzes durch den Prozess des Geschichtenschreibens leiten können. Lassen Sie uns die aktuelle Scenario analysieren:

1. Wir erstellen ein vierstufiges „Story_Chain“-Wörterbuch mit Anweisungen und Kontext für jede Part.
2. Um Antworten zu erhalten, fragt die Funktion `generate_story_element` die OpenAI-API.
3. Wir durchlaufen jede Kettenphase iterativ, um die Konsistenz aufrechtzuerhalten und frühere Ergebnisse zu verbessern.
4. Abschließend fügen wir alle Teile zu einem nahtlosen Erzählrahmen zusammen.

Ausgabe

Eine schrittweise Ausgabe finden Sie hier: GitHub-Hyperlink

Vorteile dieser Strategie

1. Strukturierte Kreativität: Wir unterteilen den Prozess des Geschichtenschreibens in überschaubare Abschnitte, um alle wichtigen Aspekte abzudecken.
2. Kontextuelle Kontinuität: Jede Aktion baut auf der vorherigen auf und stellt sicher, dass die Erzählung von Anfang bis Ende Sinn ergibt.
3. Flexibilität: Um komplexere Storystrukturen zu ermöglichen, können wir einfach Schritte in der Kette hinzufügen oder ändern.

Sehen wir uns ein weiteres Beispiel an, um die Flexibilität der Chain of Dictionary-Methode zu demonstrieren.

Beispiel 2: Ein mehrsprachiger Reiseleiter

Hier bauen wir einen KI-gestützten Reisehelfer, der mehrere Sprachen spricht und Informationen anbieten kann.

import openai
from IPython.show import show, Markdown, Picture as IPImage
from PIL import Picture, ImageDraw, ImageFont
import textwrap
import os

# Arrange your OpenAI consumer (be sure to've set your API key)
consumer = openai.OpenAI()

# Outline the steps for the journey assistant
travel_assistant = {
    "step1": {
        "instruction": "Counsel a well-liked vacationer vacation spot",
        "context": "Take into account a mixture of tradition, historical past, and pure magnificence",
        "output": ""
    },
    "step2": {
        "instruction": "Present key details about the vacation spot",
        "context": "Embody must-see points of interest, finest time to go to, and native delicacies",
        "output": ""
    },
    "step3": {
        "instruction": "Translate the knowledge to French",
        "context": "Keep the that means and tone of the unique textual content",
        "output": ""
    },
    "step4": {
        "instruction": "Translate the knowledge to Spanish",
        "context": "Guarantee cultural nuances are appropriately conveyed",
        "output": ""
    }
}

def generate_travel_info(immediate):
    """
    Generate journey data primarily based on the given immediate utilizing OpenAI API.

    Args:
        immediate (str): The immediate to generate journey data.

    Returns:
        str: The generated journey data in Markdown format.
    """
    response = consumer.chat.completions.create(
        messages=(
            {"position": "system", "content material": "You're a educated journey assistant. Format your responses in Markdown."},
            {"position": "person", "content material": immediate + " Present your response in Markdown format."}
        ),
        mannequin="gpt-3.5-turbo",
    )
    return response.decisions(0).message.content material.strip()

def text_to_image(textual content, filename, title):
    """
    Convert textual content to a picture and put it aside to a file.

    Args:
        textual content (str): The textual content to transform to a picture.
        filename (str): The filename to save lots of the picture.
        title (str): The title to show on the picture.
    """
    # Create a brand new picture with white background
    img = Picture.new('RGB', (800, 600), colour="white")
    d = ImageDraw.Draw(img)
    
    # Use a default font
    font = ImageFont.load_default()
    title_font = ImageFont.load_default()
    
    # Draw the title
    d.textual content((10, 10), title, font=title_font, fill=(0, 0, 0))
    
    # Wrap the textual content
    wrapped_text = textwrap.wrap(textual content, width=70)
    
    # Draw the textual content
    y_text = 50
    for line in wrapped_text:
        d.textual content((10, y_text), line, font=font, fill=(0, 0, 0))
        y_text += 20
    
    # Save the picture
    img.save(filename)

# Course of every step within the chain
for step, content material in travel_assistant.objects():
    immediate = f"{content material('instruction')}. {content material('context')}"
    if step in ("step3", "step4"):
        immediate += f" Based mostly on the earlier: {travel_assistant('step2')('output')}"
    content material('output') = generate_travel_info(immediate)
    
    # Show the output
    show(Markdown(f"### {step.higher()}:n{content material('output')}"))
    
    # Create and save a picture for this step
    text_to_image(content material('output'), f"{step}.png", step.higher())
    
    # Show the saved picture
    show(IPImage(filename=f"{step}.png"))

# Closing multi-lingual journey information
travel_guide = f"""
## Vacation spot:
{travel_assistant('step1')('output')}

## Info (English):
{travel_assistant('step2')('output')}

## Info (French):
{travel_assistant('step3')('output')}

## Info (Spanish):
{travel_assistant('step4')('output')}
"""

# Show the ultimate journey information
show(Markdown("# MULTI-LINGUAL TRAVEL GUIDE:n" + travel_guide))

# Create and save a picture for the ultimate journey information
text_to_image(travel_guide, "final_travel_guide.png", "MULTI-LINGUAL TRAVEL GUIDE")

# Show the ultimate journey information picture
show(IPImage(filename="final_travel_guide.png"))

print("Photographs have been saved as PNG recordsdata within the present listing.")

Hier ist ein Beispiel für einen von uns entwickelten Reiseassistenten, der Materials in mehrere Sprachen übersetzen und Vorschläge und Informationen zu möglichen Reisezielen anbieten kann. Dies demonstriert die Verwendung des Chain of Dictionary-Ansatzes zur Entwicklung komplexerer, vielschichtigerer künstlicher Intelligenzsysteme.

Code Erklärung

Dieser Code erstellt einen mehrsprachigen Reiseassistenten, der Reiseinformationen generiert und übersetzt, sie in Markdown anzeigt und die Ergebnisse als Bilder speichert.

• Der OpenAI-Consumer wird mit consumer = openai.OpenAI() initialisiert.
• Das travel_assistant-Wörterbuch definiert vier Schritte mit Anweisungen, Kontext und Ausgabefeldern.
• Die Funktion generate_travel_info ruft die OpenAI-API auf, um Textual content basierend auf einer Eingabeaufforderung zu generieren.
• Die Funktion text_to_image wandelt Textual content mittels PIL in ein Bild um und speichert es.
• Die For-Schleife durchläuft jeden Schritt im travel_assistant und generiert und zeigt Textual content und Bilder an.
• Ein fertiger mehrsprachiger Reiseführer wird erstellt, angezeigt und als Bild gespeichert.

Ausgabe

Die endgültige Ausgabe finden Sie hier: GitHub-Hyperlink

Hier sind die ähnlichen Artikel

Weitere Artikel finden Sie hier – Immediate Engineering.

Hauptvorteile der Chain of Dictionary-Methode

Hier ist der Hauptvorteil der Wörterbuchkette:

1. Modularität: Jedes Glied in der Kette kann problemlos ausgetauscht, erweitert oder geändert werden, ohne dass dies Auswirkungen auf die anderen hat.
2. Klarheit: Das methodische Vorgehen erleichtert das Verstehen und Beheben der Denkprozesse der KI.
3. Skalierbarkeit: Sie können beliebig viele Phasen hinzufügen, um komplizierte Jobs oder Dialoge zu verwalten.
4. Anpassungsfähigkeit: Die Methode kann in verschiedenen Kontexten und Anwendungsfällen eingesetzt werden, vom kreativen Schreiben bis zur Sprachübersetzung und darüber hinaus.

Schwierigkeiten und Dinge, über die man nachdenken sollte

Trotz der Effektivität des Chain-of-Dictionary-Ansatzes gibt es mehrere potenzielle Nachteile, die Sie beachten sollten:

1. Token-Einschränkungen: Sie können auf Token-Einschränkungen stoßen, die die Dauer Ihrer Eingabeaufforderungen und Antworten begrenzen, abhängig von der KI-Modell Sie beschäftigen.
2. Kohärenz in allen Schritten: Stellen Sie sicher, dass das Ergebnis jedes Schritts mit dem breiteren Kontext der Aufgabe im Einklang steht.
3. Fehlerbehandlung: Verwenden Sie eine effektive Fehlerbehandlung, um fehlerhafte KI-Antworten oder Probleme mit APIs zu beheben.

Komplexe Anwendungen mit Wörterbuchkette

Noch komplexere Anwendungen sind mit der Chain of Dictionary-Technik möglich:

1. Interaktives Geschichtenerzählen: Schreiben Sie Erzählungen mit Verzweigungen, in denen die Entscheidungen des Benutzers den Verlauf der Ereignisse bestimmen.
2. Multi-Modell-Interaktion: Kombinieren Sie zur Produktion illustrierter Geschichten oder Reiseführer textbasierte künstliche Intelligenz mit Modellen zur Bilderstellung.
3. Automatisierte Recherche: Erstellen Sie einen ausführlichen Bericht, indem Sie Daten aus mehreren Quellen zusammenfassen und in einer Kette organisieren.

Abschluss

Der Chain of Dictionary-Ansatz im Fast Engineering eröffnet viele Möglichkeiten für die Entwicklung komplexer, kontextbezogener KI-Systeme. Indem wir komplizierte Aufgaben in überschaubare Teile zerlegen und bei jedem Schritt präzise Anweisungen und Kontext anbieten, können wir KI-Modelle um genauere, relevantere und einfallsreichere Ergebnisse zu liefern.

Denken Sie beim Üben mit dieser Methode daran, dass das Erstellen klarer, einfacher Anweisungen und das Sicherstellen eines logischen Ablaufs zwischen den einzelnen Gliedern der Kette für den Erfolg unerlässlich sind. Mit Erfahrung und Fantasie können Sie KI-Interaktionen erstellen, die einfühlsamer, ansprechender und effektiver sind.

Häufig gestellte Fragen