Bild vom Autor | Ideogram.ai

# Einführung

Beim Erstellen großer Sprachmodellanwendungen sind Token Geld. Wenn Sie jemals mit einem LLM wie GPT-4 gearbeitet haben, hatten Sie wahrscheinlich den Second, in dem Sie die Rechnung überprüften und dachten: „Wie ist es so hoch geworden?!“ Jeder von Ihnen durchgeführte API-Aufruf verbraucht Token, was sich direkt auf die Latenz und die Kosten auswirkt. Aber ohne sie zu verfolgen, haben Sie keine Ahnung, wofür sie ausgegeben werden und wie Sie sie optimieren können.

Das ist wo LangSmith kommt ins Spiel. Es verfolgt nicht nur Ihre LLM-Aufrufe, sondern ermöglicht Ihnen auch die Protokollierung, Überwachung und Visualisierung der Token-Nutzung für jeden Schritt in Ihrem Workflow. In diesem Leitfaden behandeln wir Folgendes:

1. Warum ist Token-Monitoring wichtig?
2. Wie richte ich die Protokollierung ein?
3. Wie kann der Token-Verbrauch im LangSmith-Dashboard visualisiert werden?

# Warum ist Token-Monitoring wichtig?

Die Nachverfolgung von Token ist wichtig, da jede Interaktion mit einem großen Sprachmodell direkte Kosten verursacht, die von der Anzahl der verarbeiteten Token abhängig sind, sowohl in Ihren Eingaben als auch in den Ausgaben des Modells. Ohne Überwachung können kleine Ineffizienzen bei Eingabeaufforderungen, unnötiger Kontext oder redundante Anfragen Ihre Rechnung in die Höhe treiben und die Leistung verlangsamen.

Durch die Nachverfolgung von Token erhalten Sie einen genauen Überblick darüber, wo sie verbraucht werden. Auf diese Weise können Sie Eingabeaufforderungen optimieren, Arbeitsabläufe rationalisieren und die Kostenkontrolle behalten. Wenn Ihr Chatbot beispielsweise 1.500 Token professional Anfrage verwendet, können die Kosten durch eine Reduzierung auf 800 Token quick halbiert werden. Das Token-Monitoring-Konzept funktioniert irgendwie so:

# Einrichten von LangSmith für die Token-Protokollierung

// Schritt 1: Erforderliche Pakete installieren

pip3 set up langchain langsmith transformers speed up langchain_community

// Schritt 2: Führen Sie alle erforderlichen Importe durch

import os
from transformers import pipeline
from langchain.llms import HuggingFacePipeline
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langsmith import traceable

// Schritt 3: Langsmith konfigurieren

Stellen Sie Ihre ein API-Schlüssel und Projektname:

# Exchange along with your API key
os.environ("LANGCHAIN_API_KEY") = "your-api-key"
os.environ("LANGCHAIN_PROJECT") = "HF_FLAN_T5_Base_Demo"
os.environ("LANGCHAIN_TRACING_V2") = "true"


# Non-compulsory: disable tokenizer parallelism warnings
os.environ("TOKENIZERS_PARALLELISM") = "false"

// Schritt 4: Laden Sie ein Hugging Face-Modell

Verwenden Sie ein CPU-freundliches Modell wie google/flan-t5-base und aktivieren Sie das Sampling für natürlichere Ergebnisse:

model_name = "google/flan-t5-base"
pipe = pipeline(
   "text2text-generation",
   mannequin=model_name,
   tokenizer=model_name,
   system=-1,      # CPU
   max_new_tokens=60,
   do_sample=True, # allow sampling
   temperature=0.7
)
llm = HuggingFacePipeline(pipeline=pipe)

// Schritt 5: Erstellen Sie eine Eingabeaufforderung und eine Kette

Definieren Sie eine Eingabeaufforderungsvorlage und verbinden Sie sie mithilfe von LLMChain mit Ihrer Hugging Face-Pipeline:

prompt_template = PromptTemplate.from_template(
   "Clarify gravity to a 10-year-old in about 20 phrases utilizing a enjoyable analogy."
)


chain = LLMChain(llm=llm, immediate=prompt_template)

// Schritt 6: Machen Sie die Funktion mit LangSmith rückverfolgbar

Verwenden Sie den @traceable-Dekorator, um Eingaben, Ausgaben, Token-Nutzung und Laufzeit automatisch zu protokollieren:

@traceable(identify="HF Clarify Gravity")
def explain_gravity():
   return chain.run({})

// Schritt 7: Führen Sie die Funktion aus und drucken Sie die Ergebnisse aus

reply = explain_gravity()
print("n=== Hugging Face Mannequin Reply ===")
print(reply)

Ausgabe:

=== Hugging Face Mannequin Reply ===
Gravity is a measure of mass of an object.

// Schritt 8: Überprüfen Sie das Langsmith-Dashboard

Gehe zu smith.langchain.com → Projekte verfolgen. Sie werden etwas wie:

Sie können sogar die mit jedem Projekt verbundenen Kosten sehen und so Ihre Abrechnung analysieren. Um nun die Verwendung von Tokens und andere Erkenntnisse zu sehen, klicken Sie auf Ihr Projekt. Und Sie werden sehen:

Das rote Feld hebt die Anzahl der Durchläufe hervor, die Sie für Ihr Projekt durchgeführt haben, und listet diese auf. Klicken Sie auf einen beliebigen Lauf und Sie werden Folgendes sehen:

Hier können Sie verschiedene Dinge sehen, wie z. B. die Gesamtzahl der Token, die Latenz usw. Klicken Sie wie unten gezeigt auf das Dashboard:

Jetzt können Sie Diagramme im Zeitverlauf anzeigen, um Token-Nutzungstrends zu verfolgen, die durchschnittliche Latenz professional Anfrage zu überprüfen, Eingabe- und Ausgabe-Tokens zu vergleichen und Spitzennutzungszeiten zu identifizieren. Diese Erkenntnisse helfen dabei, Eingabeaufforderungen zu optimieren, Kosten zu verwalten und die Modellleistung zu verbessern.

Bitte scrollen Sie nach unten, um alle mit Ihrem Projekt verknüpften Diagramme anzuzeigen.

// Schritt 9: Erkunden Sie das LangSmith-Dashboard

Sie können viele der Erkenntnisse analysieren, wie zum Beispiel:

• Beispielspuren anzeigen: Klicken Sie auf eine Ablaufverfolgung, um die detaillierte Ausführung anzuzeigen, einschließlich Roheingabe, generierter Ausgabe und Leistungsmetriken
• Einzelne Spuren prüfen: Für jede Ablaufverfolgung können Sie jeden Schritt der Ausführung untersuchen und Eingabeaufforderungen, Ausgaben, Token-Nutzung und Latenz anzeigen
• Überprüfen Sie die Token-Nutzung und Latenz: Detaillierte Token-Zählungen und Verarbeitungszeiten helfen dabei, Engpässe zu erkennen und die Leistung zu optimieren
• Bewertungsketten: Verwenden Sie die Evaluierungstools von LangSmith, um Szenarien zu testen, die Modellleistung zu verfolgen und Ergebnisse zu vergleichen
• Experimentieren Sie auf dem Spielplatz: Passen Sie Parameter wie Temperatur, Eingabeaufforderungsvorlagen oder Probenahmeeinstellungen an, um das Verhalten Ihres Modells zu optimieren

Mit diesem Setup haben Sie jetzt im LangSmith-Dashboard vollständige Sicht auf die Ausführungen Ihres Hugging Face-Modells, die Token-Nutzung und die Gesamtleistung.

# Wie erkennt und behebt man Token Hogs?

Sobald Sie über die Protokollierung verfügen, können Sie:

• Überprüfen Sie, ob die Eingabeaufforderungen zu lang sind
• Identifizieren Sie Aufrufe, bei denen das Modell zu viel generiert
• Wechseln Sie für günstigere Aufgaben zu kleineren Modellen
• Antworten zwischenspeichern, um doppelte Anfragen zu vermeiden

Dies ist Gold wert, um lange Ketten oder Agenten zu debuggen. Finden Sie den Schritt, der die meisten Token frisst, und beheben Sie ihn.

# Zusammenfassung

So können Sie Langsmith einrichten und nutzen. Bei der Protokollierung der Token-Nutzung geht es nicht nur darum, Geld zu sparen, sondern auch darum, intelligentere und effizientere LLM-Apps zu entwickeln. Der Leitfaden bietet eine Grundlage. Sie können mehr erfahren, indem Sie Ihre eigenen Arbeitsabläufe erkunden, experimentieren und analysieren.

Kanwal Mehreen ist ein Ingenieur für maschinelles Lernen und ein technischer Redakteur mit einer großen Leidenschaft für Datenwissenschaft und die Schnittstelle zwischen KI und Medizin. Sie ist Mitautorin des E-Books „Maximizing Productiveness with ChatGPT“. Als Google Era Scholar 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie ist außerdem als Teradata Range in Tech Scholar, Mitacs Globalink Analysis Scholar und Harvard WeCode Scholar anerkannt. Kanwal ist ein leidenschaftlicher Verfechter von Veränderungen und hat FEMCodes gegründet, um Frauen in MINT-Bereichen zu stärken.

Definieren Sie zunächst das Ziel für jeden Agenten oder jede Eingabeaufforderung. Bleiben Sie bei ein kognitiver Prozesstyp professional Agentwie etwa: Konzeption einer Zielseite, Auswahl von Komponenten oder Generierung von Inhalten für bestimmte Abschnitte.
Klare Grenzen sorgen für Fokus und Klarheit in Ihren LLM-Interaktionen und passen sich an die Ingenieurtechniken Spitze der LLM Dreiecksprinzip.

„Jeder Schritt in unserem Ablauf ist ein eigenständiger Prozess, der zur Erfüllung unserer Aufgabe erfolgen muss.”

Vermeiden Sie beispielsweise die Kombination verschiedener kognitiver Prozesse in derselben Eingabeaufforderung, da dies zu suboptimalen Ergebnissen führen kann. Teilen Sie diese stattdessen in separate, fokussierte Agenten auf:

def generate_landing_page_concept(input_data: LandingPageInput) -> LandingPageConcept:
"""
Generate a touchdown web page idea primarily based on the enter knowledge.
This perform focuses on the inventive means of conceptualizing the touchdown web page.
"""
cross
def select_landing_page_components(idea: LandingPageConcept) -> Checklist(LandingPageComponent):
"""
Choose applicable parts for the touchdown web page primarily based on the idea.
This perform is accountable just for selecting parts,
not for producing their content material or structure.
"""
cross
def generate_component_content(element: LandingPageComponent, idea: LandingPageConcept) -> ComponentContent:
"""
Generate content material for a selected touchdown web page element.
This perform focuses on creating applicable content material primarily based on the element kind and general idea.
"""
cross

Durch die Definition klare Grenzen Für jeden Agenten können wir sicherstellen, dass jeder Schritt in unserem Workflow auf eine bestimmte mentale Aufgabe zugeschnitten ist. Dies wird Verbesserung der Qualität der Ergebnisse und mach es einfacher zu debuggen und verfeinern.

Definieren klare Ein- und Ausgabe Strukturen, um die Ziele widerzuspiegeln und explizite Datenmodelle zu erstellen. Diese Praxis berührt die LLM Triangle-Prinzipien‚ Ingenieurtechniken Und Kontextdaten Spitzen.

class LandingPageInput(BaseModel):
model: str
product_desc: str
campaign_desc: str
cta_message: str
target_audience: str
unique_selling_points: Checklist(str)
class LandingPageConcept(BaseModel):
campaign_desc_reflection: str
campaign_motivation: str
campaign_narrative: str
campaign_title_types: Checklist(str)
campaign_title: str
tone_and_style: Checklist(str)

Diese Pydantisch Modelle definieren die Struktur unserer Eingabe- und Ausgabedaten und definieren Sie klare Grenzen und Erwartungen für den Agenten.

Führen Sie Validierungen durch, um die Qualität und Moderation der LLM-Ausgaben sicherzustellen. Pydantisch eignet sich hervorragend für die Implementierung dieser Leitplanken und wir können dafür seine nativen Funktionen nutzen.

class LandingPageConcept(BaseModel):
campaign_narrative: str = Area(..., min_length=50)  # native validations
tone_and_style: Checklist(str) = Area(..., min_items=2)  # native validations
# ...remainder of the fields... #
@field_validator("campaign_narrative")
@classmethod
def validate_campaign_narrative(cls, v):
"""Validate the marketing campaign narrative towards the content material coverage, utilizing one other AI mannequin."""
response = consumer.moderations.create(enter=v)
if response.outcomes(0).flagged:
elevate ValueError("The offered textual content violates the content material coverage.")
return v

In diesem Beispiel stellen wir die Qualität unserer Anwendung durch die Definition von zwei Arten von Validierern sicher:

• Verwendung von Pydanitc’s Area einfache Validierungen zu definieren, wie z. B. mindestens 2 Ton-/Stilattribute oder mindestens 50 Zeichen im Textual content
• Mit einem benutzerdefinierten field_validator das sicherstellt, dass die generierte Erzählung unseren Richtlinien zur Inhaltsmoderation entspricht (unter Verwendung von KI)

Strukturieren Sie Ihren LLM-Workflow so, dass er menschliche kognitive Prozesse nachahmt, indem Sie komplexe Aufgaben in kleinere Schritte aufteilen, die einer logischen Abfolge folgen. Folgen Sie dazu den SOP (Standardarbeitsanweisung) Leitprinzip der LLM Triangle-Prinzipien.

„Ohne SOP kann selbst das leistungsstärkste LLM keine durchgängig hochwertigen Ergebnisse liefern.“

4.1 Erfassen Sie versteckte implizite Erkenntnissprünge

In unserem Beispiel erwarten wir, dass das Modell LandingPageConcept als Ergebnis. Indem wir das Modell auffordern, bestimmte Felder auszugeben, leiten wir das LLM ähnlich an, wie ein menschlicher Vermarkter oder Designer an die Erstellung eines Landingpage-Konzepts herangehen würde.

class LandingPageConcept(BaseModel):
campaign_desc_reflection: str  # Encourages evaluation of the marketing campaign description
campaign_motivation: str       # Prompts fascinated by the 'why' behind the marketing campaign
campaign_narrative: str        # Guides creation of a cohesive story for the touchdown web page
campaign_title_types: Checklist(str)# Promotes brainstorming totally different title approaches
campaign_title: str            # The ultimate choice on the title
tone_and_style: Checklist(str)      # Defines the general really feel of the touchdown web page

Der LandingPageConcept Struktur ermutigt den LLM, einem menschlichen Denkprozess zu folgen, der die subtile gedankliche Sprünge (implizite Erkenntnis „springt“), die ein Experte instinktiv treffen würde, genau wie wir es in unserem SOP vorgelebt haben.

4.2 Aufteilung komplexer Prozesse in mehrere Schritte/Agenten

Bei komplexen Aufgaben den Prozess in mehrere Schritte unterteilen, die jeweils von einem separaten LLM-Aufruf ausgeführt werden, oder „Agent“:

async def generate_landing_page(input_data: LandingPageInput) -> LandingPageOutput:
# Step 1: Conceptualize the marketing campaign
idea = await generate_concept(input_data)
# Step 2: Choose applicable parts
selected_components = await select_components(idea)
# Step 3: Generate content material for every chosen element
component_contents = {
element: await generate_component_content(input_data, idea, element)
for element in selected_components
}
# Step 4: Compose the ultimate HTML
html = await compose_html(idea, component_contents)
return LandingPageOutput(idea, selected_components, component_contents, html)

Dieser Multi-Agenten-Ansatz entspricht der Artwork und Weise, wie Menschen komplexe Probleme angehen – indem sie diese in kleinere Teile zerlegen.

YAML ist ein beliebt benutzerfreundliches Datenserialisierungsformat. Es ist so konzipiert, dass es für Menschen leicht lesbar und für Maschinen dennoch leicht zu analysieren ist – was es zum Klassiker für die LLM-Verwendung macht.

Ich habe festgestellt, dass YAML besonders effektiv für LLM-Interaktionen ist und über verschiedene Modelle hinweg viel bessere Ergebnisse liefert. Es konzentriert die Token-Verarbeitung auf wertvolle Inhalte statt auf Syntax.

YAML ist außerdem zwischen verschiedenen LLM-Anbietern wesentlich portabler und ermöglicht Ihnen die Beibehaltung eines strukturierten Ausgabeformats.

async def generate_component_content(input_data: LandingPageInput, idea: LandingPageConcept,element: LandingPageComponent) -> ComponentContent:
few_shots = {
LandingPageComponent.HERO: {
"enter": LandingPageInput(
model="Mustacher",
product_desc="Luxurious mustache cream for grooming and styling",
# ... remainder of the enter knowledge ...
),
"idea": LandingPageConcept(
campaign_title="Have a good time Dad's Sprint of Distinction",
tone_and_style=("Heat", "Barely humorous", "Nostalgic")
# ... remainder of the idea ...
),
"output": ComponentContent(
motivation="The hero part captures consideration and communicates the core worth proposition.",
content material={
"headline": "Honor Dad's Distinction",
"subheadline": "The Artwork of Mustache Care",
"cta_button": "Store Now"
}
)
},
# Add extra element examples as wanted
}
sys = "Craft touchdown web page element content material. Reply in YAML with motivation and content material construction as proven."
messages = ({"position": "system", "content material": sys})
messages.lengthen((
message for instance in few_shots.values() for message in (
{"position": "consumer", "content material": to_yaml({"enter": instance("enter"), "idea": instance("idea"), "element": element.worth})},
{"position": "assistant", "content material": to_yaml(instance("output"))}
)
))
messages.append({"position": "consumer", "content material": to_yaml({"enter": input_data, "idea": idea, "element": element.worth})})
response = await consumer.chat.completions.create(mannequin="gpt-4o", messages=messages)
raw_content = yaml.safe_load(sanitize_code_block(response.decisions(0).message.content material))
return ComponentContent(**raw_content)

Beachten Sie, wie wir Beispiele mit wenigen Versuchen verwenden, um „zeigen, nicht erzählen“ das erwartete YAML-Format. Dieser Ansatz ist effektiver als explizite Anweisungen in der Eingabeaufforderung für die Ausgabestruktur.

Überlegen Sie sorgfältig, wie Sie Daten für den LLM modellieren und präsentieren. Dieser Tipp ist von zentraler Bedeutung für die Kontextdaten Spitze der LLM Triangle-Prinzipien.

„Selbst das leistungsstärkste Modell benötigt relevante und intestine strukturierte Kontextdaten, um zu glänzen.“

Werfen Sie nicht alle Daten weg, die Sie im Modell haben. Geben Sie dem Modell stattdessen die Informationen, die für das von Ihnen definierte Ziel related sind.

async def select_components(idea: LandingPageConcept) -> Checklist(LandingPageComponent):
sys_template = jinja_env.from_string("""
Your activity is to pick essentially the most applicable parts for a touchdown web page primarily based on the offered idea.
Select from the next parts:
{% for element in parts %}
- {{ element.worth }}
{% endfor %}
You MUST reply ONLY in a legitimate YAML listing of chosen parts.
""")
sys = sys_template.render(parts=LandingPageComponent)
immediate = jinja_env.from_string("""
Marketing campaign title: "{{ idea.campaign_title }}"
Marketing campaign narrative: "{{ idea.campaign_narrative }}"
Tone and magnificence attributes: { be a part of(', ') }
""")
messages = ({"position": "system", "content material": sys}) + few_shots + (
{"position": "consumer", "content material": immediate.render(idea=idea)})
response = await consumer.chat.completions.create(mannequin="gpt-4", messages=messages)
selected_components = yaml.safe_load(response.decisions(0).message.content material)
return (LandingPageComponent(element) for element in selected_components)

In diesem Beispiel verwenden wir Jinja Vorlagen zum dynamischen Erstellen unserer Eingabeaufforderungen. Dadurch werden auf elegante Weise fokussierte und relevante Kontexte für jede LLM-Interaktion erstellt.

„Daten sind der Motor nativer LLM-Anwendungen. Ein strategisches Design kontextbezogener Daten erschließt ihr wahres Potenzial.“

Few-Shot-Studying ist eine unverzichtbare Technik im Immediate Engineering. Wenn dem LLM relevante Beispiele zur Verfügung gestellt werden, verbessert sich sein Verständnis der Aufgabe erheblich.

Beachten Sie, dass wir in beiden Ansätzen, die wir unten diskutieren, Wiederverwendung unserer Pydantic-Modelle für die wenigen Aufnahmen — dieser Trick sorgt für Konsistenz zwischen den Beispielen und unserer eigentlichen Aufgabe! Leider musste ich es auf die harte Tour lernen.

6.1.1 Beispiele für Few-Shot-Studying

Schauen Sie sich die few_shots Wörterbuch in Abschnitt 5. Bei diesem Ansatz:

Beispiele werden hinzugefügt zu messages als separate Benutzer- und Assistentennachrichten aufgelistet, gefolgt von der eigentlichen Benutzereingabe.

messages.lengthen((
message for instance in few_shots for message in (
{"position": "consumer", "content material": to_yaml(instance("enter"))},
{"position": "assistant", "content material": to_yaml(instance("output"))}
)
))
# then we will add the consumer immediate
messages.append({"position": "consumer", "content material": to_yaml(input_data)})

Indem wir die Beispiele so platzieren, messagesorientieren wir uns an der Trainingsmethodik von Anweisungsmodellen. Dadurch kann das Modell mehrere „Beispielinteraktionen“ sehen, bevor es die Benutzereingabe verarbeitet – und so das erwartete Eingabe-Ausgabe-Muster besser verstehen.

Wenn Ihre Anwendung wächst, können Sie weitere Few-Pictures hinzufügen, um mehr Anwendungsfälle abzudecken. Für noch anspruchsvollere Anwendungen sollten Sie die Implementierung von dynamische paar-shot Auswahl, wobei auf Grundlage der aktuellen Eingabe die relevantesten Beispiele ausgewählt werden.

6.1.2 Aufgabenspezifisches Lernen mit wenigen Stichproben

Bei dieser Methode werden Beispiele verwendet, die in direktem Zusammenhang mit der aktuellen Aufgabe stehen. innerhalb der immediate selbst. Zur Generierung zusätzlicher Alleinstellungsmerkmale dient beispielsweise diese Eingabeaufforderungsvorlage:

Generate {{ num_points }} extra distinctive promoting factors for our {{ model }} {{ product_desc }}, following this model:
{% for level in existing_points %}
- {{ level }}
{% endfor %}

Dies bietet eine gezielte Anleitung für bestimmte Aufgaben zur Inhaltserstellung durch die Einbeziehung der Beispiele direkt in der Eingabeaufforderung und nicht als separate Nachrichten.

Während ausgefallene Immediate-Engineering-Techniken wie „Gedankenbaum“ oder „Gedankengraph“ vor allem für die Forschung interessant sind, fand ich sie für die Produktion ziemlich unpraktisch und oft übertrieben. Konzentrieren Sie sich bei echten Anwendungen auf den Entwurf einer geeigneten LLM-Architektur (auch bekannt als Workflow-Engineering).

Dies gilt auch für die Verwendung von Agenten in Ihren LLM-Anwendungen. Es ist wichtig, den Unterschied zwischen Standardagenten und autonomen Agenten zu verstehen:

Vertreter: „Convey mich von A → B, indem du XYZ tue.“

Autonome Agenten:„Convey mich von A → B, indem du etwas tust, es ist mir egal wie.“

Autonome Agenten bieten zwar Flexibilität und schnellere Entwicklung, können aber auch Unvorhersehbarkeit und Debugging-Herausforderungen mit sich bringen. Verwenden Sie autonome Agenten mit Bedacht – nur, wenn die Vorteile überwiegen deutlich der potenzielle Kontrollverlust und die zunehmende Komplexität.

Kontinuierliches Experimentieren ist für die Verbesserung Ihrer LLM-nativen Anwendungen unerlässlich. Lassen Sie sich von der Idee von Experimenten nicht einschüchtern – sie können so klein sein wie das Anpassen einer Eingabeaufforderung. Wie in „Erstellen von LLM-Apps: Eine klare Schritt-für-Schritt-Anleitung“, Es ist entscheidend, eine Basislinie festlegen Und Verfolgen Sie entsprechende Verbesserungen.

Wie alles andere in der „KI“ erfordern LLM-native Apps eine Forschung und Experimente Denkweise.

Ein weiterer guter Trick besteht darin, Ihre Eingabeaufforderungen an einem schwächeren Modell auszuprobieren als dem, das Sie in der Produktion verwenden möchten (z. B. Open-Supply-8B-Modelle) – eine Eingabeaufforderung mit „okayer“ Leistung bei einem kleineren Modell wird bei einem größeren Modell viel besser funktionieren.

Manchmal schlägt Ihr „Experiment“ fehl. Dann ändern Sie Ihre Vorgehensweise leicht und dieses andere Experiment ist viel erfolgreicher.

Genau deshalb, Vor Bei der Gestaltung unserer Endspiellösung müssen wir einfach beginnen und unsere Risiken absichern.

1. Definieren Sie ein „Funds“ oder einen Zeitrahmen. Lassen Sie uns sehen, was wir in X Wochen erreichen können, und dann entscheiden, ob und wie wir weitermachen. Normalerweise reichen 2–4 Wochen aus, um den grundlegenden PoC zu verstehen. Wenn es vielversprechend aussieht, investieren Sie weiterhin Ressourcen, um es zu verbessern.
2. Experiment-Unabhängig davon, ob Sie für Ihre Experimentierphase einen Backside-up- oder Prime-down-Ansatz wählen, besteht Ihr Ziel darin, die Ergebnisfolgerate zu maximieren. Am Ende der ersten Experimentieriteration sollten Sie einige PoC (mit denen die Stakeholder spielen können) und eine erreichte Baseline haben.
3. Retrospektive — Am Ende unserer Forschungsphase können wir die Machbarkeit, Einschränkungen und Kosten der Entwicklung einer solchen App verstehen. Dies hilft uns bei der Entscheidung, ob wir sie in die Produktion bringen und wie wir das Endprodukt und seine UX gestalten.
4. Produktisierung — Entwickeln Sie eine produktionsreife Model Ihres Projekts und integrieren Sie sie in den Relaxation Ihrer Lösung, indem Sie die standardmäßigen Finest Practices von SWE befolgen und einen Suggestions- und Datenerfassungsmechanismus implementieren.

Um den experimentorientierten Prozess intestine umzusetzen, müssen wir eine fundierte Entscheidung über die Vorgehensweise und Durchführung dieser Experimente treffen:

Lean starten: Der Backside-Up-Ansatz

Während viele Early Adopters schnell in“ Stand der Technik“ Multichain-Agentensysteme mit vollwertiger Langchain oder etwas Ähnlichem, fand ich „Der Backside-Up-Ansatz“ führt oft zu besseren Ergebnissen.

Schlank anfangen, sehr magerumarmend die „Eine Aufforderung, sie alle zu knechten“ Philosophie. Obwohl diese Strategie unkonventionell erscheinen magazine und wahrscheinlich zunächst schlechte Ergebnisse hervorbringen wird, etabliert sie eine Basislinie für Ihr System.

Von dort aus iterieren und verfeinern Sie Ihre Eingabeaufforderungen kontinuierlich und setzen Sie Techniken des Immediate Engineering ein, um die Ergebnisse zu optimieren. Wenn Sie Schwachstellen in Ihrer schlanken Lösung feststellen, teilen Sie den Prozess auf, indem Sie Zweige hinzufügen, um diese Mängel zu beheben.

Beim Entwerfen jedes „Blattes“ meines LLM-Workflow-Diagramms oder meiner LLM-nativen Architektur folge ich Das magische Dreieck³ um zu bestimmen, wo und wann die Zweige abgeschnitten, geteilt oder die Wurzeln verdickt werden müssen (mithilfe schneller technischer Techniken) und um mehr Zitrone auszupressen.

Um beispielsweise „SQL-Abfragen in nativer Sprache“ mit dem Backside-Up-Ansatz zu implementieren, beginnen wir damit, die Schemata naiv an den LLM zu senden und ihn aufzufordern, eine Abfrage zu generieren.

Normalerweise widerspricht dies nicht dem „Prime-Down-Ansatz“, sondern stellt einen weiteren Schritt davor dar. Dadurch können wir schnelle Erfolge erzielen und mehr Projektinvestitionen anziehen.

Das große Ganze im Voraus: Die Prime-Down-Strategie

„Wir wissen, dass der LLM-Workflow nicht einfach ist, und um unser Ziel zu erreichen, werden wir wahrscheinlich mit einem Workflow oder einer LLM-nativen Architektur enden.“

Der Prime-Down-Ansatz berücksichtigt dies und beginnt mit der Entwicklung der LLM-nativen Architektur vom ersten Tag an und der Implementierung ihrer verschiedenen Schritte/Ketten von Anfang an.

Auf diese Weise können Sie Ihre Workflow-Architektur als Ganzes testen und die ganze Zitrone auspressen, anstatt jedes Blatt einzeln zu verfeinern.

Um beispielsweise „SQL-Abfragen in nativer Sprache“ mit dem Prime-Down-Ansatz zu implementieren, beginnen wir mit dem Entwurf der Architektur, bevor wir überhaupt mit dem Coden beginnen, und springen dann zur vollständigen Implementierung:

Die richtige Stability finden

Wenn Sie anfangen, mit LLMs zu experimentieren, werden Sie wahrscheinlich an einem der Excessive beginnen (überkompliziertes Prime-Down oder supereinfaches One-Shot). In Wirklichkeit gibt es keinen Gewinner.

Im Idealfall definieren Sie ein gutes SoP¹ und modellieren einen Experten, bevor Sie das Modell codieren und damit experimentieren. In der Realität ist die Modellierung sehr schwierig; manchmal haben Sie möglicherweise keinen Zugriff auf einen solchen Experten.

Ich fand es schwierig, beim ersten Versuch eine gute Architektur/einen guten SoP¹ zu finden, additionally lohnt es sich, ein wenig zu experimentieren, bevor man zu großen Geschützen greift. Das bedeutet jedoch nicht, dass alles muß sein zu mager. Wenn Sie bereits ein vorheriges Verständnis dass etwas MUSS in kleinere Stücke zerlegt werden – tun Sie das.

In jedem Fall sollten Sie beim Entwerfen Ihrer Lösung das Paradigma des magischen Dreiecks³ nutzen und den manuellen Prozess richtig modellieren.

Bild vom Herausgeber | Midjourney & Canva

Robin Sharma sagte: „Jeder Meister warfare einmal ein Anfänger. Jeder Profi warfare einmal ein Newbie.“ Sie haben schon seit einiger Zeit davon gehört, dass große Sprachmodelle (LLMs), KI und Transformer-Modelle (GPT) im KI-Bereich für Aufsehen sorgen, und sind sich nicht sicher, wie Sie damit anfangen sollen. Ich kann Ihnen versichern, dass jeder, den Sie heute komplexe Anwendungen erstellen sehen, einmal dort warfare.

Deshalb vermittelt Ihnen dieser Artikel das Wissen, das Sie benötigen, um mit der Entwicklung von LLM-Apps mit der Programmiersprache Python zu beginnen. Er ist ausschließlich für Anfänger geeignet und Sie können beim Lesen dieses Artikels mitprogrammieren.

Was werden Sie in diesem Artikel erstellen? Sie werden einen einfachen persönlichen KI-Assistenten erstellen, der basierend auf der Eingabeaufforderung des Benutzers eine Antwort generiert und diese international bereitstellt. Das Bild unten zeigt, wie die fertige Anwendung aussieht.

Dieses Bild zeigt die Benutzeroberfläche des persönlichen KI-Assistenten, der in diesem Artikel erstellt wird

Voraussetzungen

Damit Sie diesen Artikel durchlesen können, müssen Sie einige Dinge im Griff haben. Dazu gehören:

1. Python (3.5+) und Hintergrundwissen zum Schreiben von Python-Skripten.
2. OpenAI: OpenAI ist eine Forschungsorganisation und ein Technologieunternehmen, das sich zum Ziel gesetzt hat, die künstliche allgemeine Intelligenz (AGI) der gesamten Menschheit zugute kommen zu lassen. Einer seiner wichtigsten Beiträge ist die Entwicklung fortgeschrittener LLMs wie GPT-3 Und GPT-4. Diese Modelle können menschenähnlichen Textual content verstehen und generieren, was sie zu leistungsstarken Instruments für verschiedene Anwendungen wie Chatbots, Content material-Erstellung und mehr macht.
   Melden Sie sich an für OpenAI und kopieren Sie Ihre API-Schlüssel aus dem API-Bereich Ihres Kontos, damit Sie auf die Modelle zugreifen können. Installieren Sie OpenAI mit dem folgenden Befehl auf Ihrem Pc:

3. LangChain:LangChain ist ein Framework, das die Entwicklung von Anwendungen, die LLMs nutzen, vereinfachen soll. Es bietet Instruments und Dienstprogramme zum Verwalten und Optimieren der verschiedenen Aspekte der Arbeit mit LLMs und erleichtert so die Erstellung komplexer und robuster Anwendungen.

Installieren Sie LangChain mit dem folgenden Befehl auf Ihrem Pc:

4. Streamlit: Streamlit ist eine leistungsstarke und benutzerfreundliche Python-Bibliothek zum Erstellen von Webanwendungen. Mit Streamlit können Sie interaktive Webanwendungen nur mit Python erstellen. Sie benötigen keine Fachkenntnisse in der Webentwicklung (HTML, CSS, JavaScript), um funktionale und optisch ansprechende Net-Apps zu erstellen.

   Es ist nützlich für die Entwicklung von Apps für maschinelles Lernen und Datenwissenschaft, einschließlich solcher, die LLMs verwenden. Installieren Sie streamlit mit dem folgenden Befehl auf Ihrem Pc:

Code entlang

Wenn alle erforderlichen Pakete und Bibliotheken installiert sind, können Sie mit dem Erstellen der LLM-Anwendung beginnen. Erstellen Sie eine Datei „requirement.txt“ im Stammverzeichnis Ihres Arbeitsverzeichnisses und speichern Sie die Abhängigkeiten.

streamlit
openai
langchain

Erstellen Sie eine app.py-Datei und fügen Sie den folgenden Code hinzu.

# Importing the required modules from the Streamlit and LangChain packages
import streamlit as st
from langchain.llms import OpenAI

• Importiert die Streamlit-Bibliothek, die zum Erstellen interaktiver Webanwendungen verwendet wird.
• from langchain.llms import OpenAI importiert die OpenAI-Klasse aus dem Modul langchain.llms, das zur Interaktion mit den Sprachmodellen von OpenAI verwendet wird.

# Setting the title of the Streamlit utility
st.title('Easy LLM-App 🤖')

• st.title(‚Easy LLM-App ‘) legt den Titel der Streamlit-Web site fest.

# Making a sidebar enter widget for the OpenAI API key, enter kind is password for safety
openai_api_key = st.sidebar.text_input('OpenAI API Key', kind="password")

• openai_api_key = st.sidebar.text_input(‚OpenAI API Key‘, kind=“password“) erstellt ein Texteingabe-Widget in der Seitenleiste, in das der Benutzer seinen OpenAI API-Schlüssel eingeben kann. Der Eingabetyp ist auf „Passwort“ eingestellt, um den eingegebenen Textual content aus Sicherheitsgründen auszublenden.

# Defining a operate to generate a response utilizing the OpenAI language mannequin
def generate_response(input_text):
    # Initializing the OpenAI language mannequin with a specified temperature and API key
    llm = OpenAI(temperature=0.7, openai_api_key=openai_api_key)
    # Displaying the generated response as an informational message within the Streamlit app
    st.information(llm(input_text))

• def generate_response(input_text) definiert eine Funktion namens generate_response, die input_text als Argument verwendet.
• llm = OpenAI(temperature=0.7, openai_api_key=openai_api_key) initialisiert die OpenAI-Klasse mit einer Temperatureinstellung von 0,7 und dem bereitgestellten API-Schlüssel.

Temperatur ist ein Parameter, der verwendet wird, um die Zufälligkeit oder Kreativität des von einem Sprachmodell generierten Textes zu steuern. Er bestimmt, wie viel Variabilität das Modell in seine Vorhersagen einbringt.

• Niedrige Temperatur (0,0 – 0,5): Dadurch wird das Modell deterministischer und fokussierter.
• Mittlere Temperatur (0,5 – 1,0): Sorgt für ein Gleichgewicht zwischen Zufälligkeit und Determinismus.
• Hohe Temperatur (1,0 und höher): Erhöht die Zufälligkeit der Ausgabe. Höhere Werte machen das Modell kreativer und vielfältiger in seinen Antworten, dies kann jedoch auch zu weniger Kohärenz und mehr unsinnigen oder themenfremden Ausgaben führen.

• st.information(llm(input_text)) ruft das Sprachmodell mit dem bereitgestellten input_text auf und zeigt die generierte Antwort als Informationsmeldung in der Streamlit-App an.

# Making a kind within the Streamlit app for consumer enter
with st.kind('my_form'):
    # Including a textual content space for consumer enter
    textual content = st.text_area('Enter textual content:', '')
    # Including a submit button for the shape
    submitted = st.form_submit_button('Submit')
    # Displaying a warning if the entered API key doesn't begin with 'sk-'
    if not openai_api_key.startswith('sk-'):
        st.warning('Please enter your OpenAI API key!', icon='⚠')
    # If the shape is submitted and the API key's legitimate, generate a response
    if submitted and openai_api_key.startswith('sk-'):
        generate_response(textual content)

• mit st.kind(‚my_form‘) wird ein Formularcontainer mit dem Namen my_form erstellt.
• textual content = st.text_area(‚Textual content eingeben:‘, “) fügt dem Formular ein Textbereich-Eingabe-Widget hinzu, in das der Benutzer Textual content eingeben kann.
• submitted = st.form_submit_button(‚Senden‘) fügt dem Formular eine Senden-Schaltfläche hinzu.
• wenn nicht, prüft openai_api_key.startswith(’sk-‚), ob der eingegebene API-Schlüssel nicht mit sk- beginnt.
• st.warning(‚Bitte geben Sie Ihren OpenAI API-Schlüssel ein!‘, icon=’‘) zeigt eine Warnmeldung an, wenn der API-Schlüssel ungültig ist.
• Wenn übermittelt, prüft openai_api_key.startswith(’sk-‚), ob das Formular übermittelt wurde und der API-Schlüssel gültig ist.
• generate_response(textual content) ruft die generate_response-Funktion mit dem eingegebenen Textual content auf, um die Antwort zu generieren und anzuzeigen.

Zusammengefasst erhalten Sie Folgendes:

# Importing the required modules from the Streamlit and LangChain packages
import streamlit as st
from langchain.llms import OpenAI

# Setting the title of the Streamlit utility
st.title('Easy LLM-App 🤖')

# Making a sidebar enter widget for the OpenAI API key, enter kind is password for safety
openai_api_key = st.sidebar.text_input('OpenAI API Key', kind="password")

# Defining a operate to generate a response utilizing the OpenAI mannequin
def generate_response(input_text):
    # Initializing the OpenAI mannequin with a specified temperature and API key
    llm = OpenAI(temperature=0.7, openai_api_key=openai_api_key)
    # Displaying the generated response as an informational message within the Streamlit app
    st.information(llm(input_text))

# Making a kind within the Streamlit app for consumer enter
with st.kind('my_form'):
    # Including a textual content space for consumer enter with a default immediate
    textual content = st.text_area('Enter textual content:', '')
    # Including a submit button for the shape
    submitted = st.form_submit_button('Submit')
    # Displaying a warning if the entered API key doesn't begin with 'sk-'
    if not openai_api_key.startswith('sk-'):
        st.warning('Please enter your OpenAI API key!', icon='⚠')
    # If the shape is submitted and the API key's legitimate, generate a response
    if submitted and openai_api_key.startswith('sk-'):
        generate_response(textual content)

Ausführen der Anwendung

Die Anwendung ist fertig; Sie müssen das Anwendungsskript mit dem entsprechenden Befehl für das von Ihnen verwendete Framework ausführen.

Indem Sie diesen Code mit streamlit run app.py ausführen, erstellen Sie eine interaktive Webanwendung, in der Benutzer Eingabeaufforderungen eingeben und LLM-generierte Textantworten erhalten können.

Wenn Sie streamlit run app.py ausführen, passiert Folgendes:

• Streamlit-Server startet: Streamlit startet einen lokalen Webserver auf Ihrem Pc, der standardmäßig normalerweise unter „http://localhost:8501“ erreichbar ist.
• Codeausführung: Streamlit liest und führt den Code in „app.py“ aus und rendert die App wie im Skript definiert.
• Weboberfläche: Ihr Webbrowser öffnet automatisch (oder Sie können manuell navigieren) zur von Streamlit bereitgestellten URL (normalerweise http://localhost:8501), wo Sie mit Ihrer LLM-App interagieren können.

Bereitstellen Ihrer LLM-Anwendung

Wenn Sie eine LLM-App bereitstellen, müssen Sie sie über das Web zugänglich machen, damit andere sie verwenden und testen können, ohne auf Ihren lokalen Pc zugreifen zu müssen. Dies ist wichtig für die Zusammenarbeit, das Benutzerfeedback und das Testen in der Praxis, um sicherzustellen, dass die App in unterschiedlichen Umgebungen intestine funktioniert.

Um die App in der Streamlit Cloud bereitzustellen, gehen Sie folgendermaßen vor:

• Erstellen Sie ein GitHub-Repository für Ihre App. Stellen Sie sicher, dass Ihr Repository zwei Dateien enthält: app.py und rAnforderungen.txt
• Gehe zu Streamlit Neighborhood Clouddrücke den „Neue App„-Schaltfläche in Ihrem Arbeitsbereich und geben Sie das Repository, den Zweig und den Hauptdateipfad an.
• Drücke den Einsetzen Schaltfläche, und Ihre LLM-Anwendung wird jetzt in der Streamlit Neighborhood Cloud bereitgestellt und kann weltweit aufgerufen werden.

Abschluss

Herzlichen Glückwunsch! Sie haben Ihre ersten Schritte beim Erstellen und Bereitstellen einer LLM-Anwendung mit Python unternommen. Nachdem Sie die Voraussetzungen verstanden, die erforderlichen Bibliotheken installiert und den Kernanwendungscode geschrieben haben, haben Sie nun einen funktionsfähigen persönlichen KI-Assistenten erstellt. Durch die Verwendung von Streamlit haben Sie Ihre App interaktiv und benutzerfreundlich gemacht und durch die Bereitstellung in der Streamlit Neighborhood Cloud Benutzern weltweit zugänglich gemacht.

Mit den Fähigkeiten, die Sie in diesem Handbuch gelernt haben, können Sie tiefer in LLMs und KI eintauchen, erweiterte Funktionen erkunden und noch anspruchsvollere Anwendungen erstellen. Experimentieren Sie weiter, lernen Sie und teilen Sie Ihr Wissen mit der Neighborhood. Die Möglichkeiten mit LLMs sind zahlreich und Ihre Reise hat gerade erst begonnen. Viel Spaß beim Programmieren!

Shittu Olumide ist ein Softwareentwickler und technischer Autor, der mit Leidenschaft modernste Technologien nutzt, um überzeugende Geschichten zu schreiben, mit einem scharfen Auge für Particulars und einem Händchen für die Vereinfachung komplexer Konzepte. Sie finden Shittu auch auf Þjórsárden.