Bild vom Herausgeber
# Einführung
Python-Dekoratoren sind maßgeschneiderte Lösungen, die dazu beitragen sollen, komplexe Softwarelogik in einer Vielzahl von Anwendungen, einschließlich LLM-basierten Anwendungen, zu vereinfachen. Der Umgang mit LLMs erfordert oft den Umgang mit unvorhersehbaren, langsamen – und häufig teuren – APIs von Drittanbietern, und Dekorateure haben viel zu bieten, um diese Aufgabe sauberer zu gestalten, indem sie beispielsweise API-Aufrufe mit optimierter Logik umschließen.
Werfen wir einen Blick auf fünf nützliche Python-Dekoratoren, die Ihnen dabei helfen, Ihre LLM-basierten Anwendungen ohne spürbaren Mehraufwand zu optimieren.
Die beigefügten Beispiele veranschaulichen die Syntax und den Ansatz zur Verwendung jedes Dekorators. Sie werden manchmal ohne tatsächliche LLM-Nutzung gezeigt, es handelt sich jedoch um Codeauszüge, die letztendlich als Teil größerer Anwendungen konzipiert sind.
# 1. In-Reminiscence-Caching
Diese Lösung stammt von Python functools Standardbibliothek und ist nützlich für teure Funktionen wie solche, die LLMs verwenden. Wenn wir einen LLM-API-Aufruf in der unten definierten Funktion hätten, fügt das Einschließen in einen LRU-Dekorator (Least Current Used) einen Cache-Mechanismus hinzu, der verhindert, dass redundante Anforderungen identische Eingaben (Eingabeaufforderungen) in derselben Ausführung oder Sitzung enthalten. Dies ist eine elegante Möglichkeit, Latenzprobleme zu optimieren.
Dieses Beispiel veranschaulicht seine Verwendung:
from functools import lru_cache
import time
@lru_cache(maxsize=100)
def summarize_text(textual content: str) -> str:
print("Sending textual content to LLM...")
time.sleep(1) # A simulation of community delay
return f"Abstract of {len(textual content)} characters."
print(summarize_text("The fast brown fox.")) # Takes one second
print(summarize_text("The fast brown fox.")) # Instantaneous# 2. Caching auf persistenter Festplatte
Apropos Caching, die externe Bibliothek diskcache geht noch einen Schritt weiter und implementiert einen persistenten Cache auf der Festplatte, und zwar über eine SQLite-Datenbank: sehr nützlich zum Speichern von Ergebnissen zeitaufwändiger Funktionen wie LLM-API-Aufrufe. Auf diese Weise können Ergebnisse bei späteren Anrufen bei Bedarf schnell abgerufen werden. Erwägen Sie die Verwendung dieses Dekorationsmusters, wenn die Zwischenspeicherung im Arbeitsspeicher nicht ausreicht, weil die Ausführung eines Skripts oder einer Anwendung möglicherweise gestoppt wird.
import time
from diskcache import Cache
# Creating a light-weight native SQLite database listing
cache = Cache(".local_llm_cache")
@cache.memoize(expire=86400) # Cached for twenty-four hours
def fetch_llm_response(immediate: str) -> str:
print("Calling costly LLM API...") # Substitute this by an precise LLM API name
time.sleep(2) # API latency simulation
return f"Response to: {immediate}"
print(fetch_llm_response("What's quantum computing?")) # 1st operate name
print(fetch_llm_response("What's quantum computing?")) # Instantaneous load from disk occurs right here!# 3. Netzwerkstabile Apps
Da LLMs aufgrund vorübergehender Fehler sowie Zeitüberschreitungen und „502 Dangerous Gateway“-Antworten im Web häufig ausfallen können, ist die Verwendung einer Netzwerk-Resilienzbibliothek wie z tenacity zusammen mit dem @retry Decorator kann dabei helfen, diese häufigen Netzwerkfehler abzufangen.
Das folgende Beispiel veranschaulicht diese Implementierung von robustem Verhalten durch zufällige Simulation einer 70-prozentigen Wahrscheinlichkeit eines Netzwerkfehlers. Versuchen Sie es mehrmals, und früher oder später wird dieser Fehler auftreten: völlig erwartet und beabsichtigt!
import random
from tenacity import retry, wait_exponential, stop_after_attempt, retry_if_exception_type
class RateLimitError(Exception): cross
# Retrying as much as 4 instances, ready 2, 4, and eight seconds between every try
@retry(
wait=wait_exponential(multiplier=2, min=2, max=10),
cease=stop_after_attempt(4),
retry=retry_if_exception_type(RateLimitError)
)
def call_flaky_llm_api(immediate: str):
print("Making an attempt to name API...")
if random.random() < 0.7: # Simulating a 70% probability of API failure
increase RateLimitError("Price restrict exceeded! Backing off.")
return "Textual content has been efficiently generated!"
print(call_flaky_llm_api("Write a haiku"))# 4. Clientseitige Drosselung
Dieser kombinierte Dekorateur verwendet die ratelimit Bibliothek zum Steuern der Häufigkeit von Aufrufen einer (normalerweise stark nachgefragten) Funktion: nützlich, um clientseitige Einschränkungen bei der Verwendung externer APIs zu vermeiden. Im folgenden Beispiel werden dazu Grenzwerte für Anfragen professional Minute (RPM) definiert. Der Anbieter lehnt Eingabeaufforderungen einer Clientanwendung ab, wenn zu viele Eingabeaufforderungen gleichzeitig gestartet werden.
from ratelimit import limits, sleep_and_retry
import time
# Strictly imposing a 3-call restrict per 10-second window
@sleep_and_retry
@limits(calls=3, interval=10)
def generate_text(immediate: str) -> str:
print(f"({time.strftime('%X')}) Processing: {immediate}")
return f"Processed: {immediate}"
# First 3 print instantly, the 4th pauses, thereby respecting the restrict
for i in vary(5):
generate_text(f"Immediate {i}")# 5. Strukturierte Ausgabebindung
Der fünfte Dekorateur auf der Liste verwendet die magentic Bibliothek in Verbindung mit Pydantic Bereitstellung eines effizienten Interaktionsmechanismus mit LLMs über API und Erhalt strukturierter Antworten. Es vereinfacht den Prozess des Aufrufs von LLM-APIs. Dieser Prozess ist wichtig, um LLMs dazu zu bringen, formatierte Daten wie JSON-Objekte zuverlässig zurückzugeben. Der Dekorateur würde sich um die zugrunde liegenden Systemeingabeaufforderungen und das von Pydantic geleitete Parsen kümmern, wodurch die Verwendung von Token optimiert und dazu beigetragen würde, eine sauberere Codebasis zu erhalten.
Um dieses Beispiel auszuprobieren, benötigen Sie einen OpenAI-API-Schlüssel.
# IMPORTANT: An OPENAI_API_KEY set is required to run this simulated instance
from magentic import immediate
from pydantic import BaseModel
class CapitalInfo(BaseModel):
capital: str
inhabitants: int
# A decorator that simply maps the immediate to the Pydantic return kind
@immediate("What's the capital and inhabitants of {nation}?")
def get_capital_info(nation: str) -> CapitalInfo:
... # No operate physique wanted right here!
data = get_capital_info("France")
print(f"Capital: {data.capital}, Inhabitants: {data.inhabitants}")# Zusammenfassung
In diesem Artikel haben wir fünf Python-Dekoratoren aufgelistet und illustriert, die auf verschiedenen Bibliotheken basieren und denen eine besondere Bedeutung zukommt, wenn sie im Kontext LLM-basierter Anwendungen verwendet werden, um unter anderem die Logik zu vereinfachen, Prozesse effizienter zu gestalten oder die Netzwerkstabilität zu verbessern.
Iván Palomares Carrascosa ist ein führender Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.