Die offene Spracherkennung ist seit einiger Zeit keine Whisper-Monokultur mehr. Im März 2026 Cohere hat Transcribe veröffentlichtein 2B Apache 2.0-Modell, das die Spitze einnahm Umarmendes Gesicht Öffnen Sie die ASR-Bestenliste bei einer durchschnittlichen Wortfehlerrate von 5,42 %. Fünf Wochen später IBM hat Granite Speech 4.1 2B ausgeliefert bei 5,33 %. Seitdem ARK-ASR-3B Und MOSS-Transcribe-preview-2B haben noch niedrigere Zahlen gemeldet.

Die Spitze dieser Bestenliste ist jetzt durch weniger als einen WER-Punkt getrennt. Das hat für jeden, der sich für ein Modell entscheidet, eine konkrete Konsequenz: Der Rang ist nicht mehr die entscheidende Variable. Lizenz, Sprachabdeckung, Streaming-Unterstützung und Kosten professional Audiostunde sind. Diese Zusammenfassung vergleicht das Feld auf allen vier.

Erstens ein Downside mit der Bestenlistennummer, die jeder zitiert

Beim Open ASR Leaderboard-Durchschnitt handelt es sich nicht um eine einzelne feste Größe, und die derzeit nebeneinander aufgeführten Modelle wurden nicht alle auf die gleiche Weise bewertet.

Die 5,42 % von Cohere sind ein Durchschnitt aus acht englischen Testsätzen, einschließlich TED-LIUM. Das ergibt: AMI 8,13, Earnings-22 10,86, GigaSpeech 9,34, LibriSpeech clear 1,25, LibriSpeech different 2,37, SPGISpeech 3,08, TED-LIUM 2,49, VoxPopuli 5,87 im Durchschnitt genau 5,42.

Die 5,04 % von ARK-ASR-3B sind ein Durchschnitt Sieben Sätze. TED-LIUM fehlt. Die MOSS-Transcribe-preview-2B-Karte besagt dies ausdrücklich: TED-LIUM ist derzeit nicht Teil des Bestenlistenlaufs und daher ausgeschlossen.

TED-LIUM ist eines der einfacheren Units in der Suite, daher erhöht sich der Durchschnitt, wenn man es weglässt. Berechnen Sie die veröffentlichten Ergebnisse professional Datensatz von Cohere über dieselben sieben Sätze, die ARK berichtet, neu, und Cohere landet bei 5,84 und nicht bei 5,42. Machen Sie dasselbe mit Granite Speech 4.1 2B und es bewegt sich von 5,33 auf 5,65. Auf vergleichbarer Foundation liegt der Vorsprung von ARK bei größer als die Schlagzeilen vermuten lassen, nicht kleiner – aber der Punkt ist, dass man eine veröffentlichte Zahl nicht von einer anderen subtrahieren kann, um eine aussagekräftige Antwort zu erhalten.

Zwei weitere Vorbehalte gehören auf die gleiche Seite:

Einige Ergebnisse sind offen für die Bestenliste geeignet: Die MOSS-Transcribe-preview-2B-Karte besagt, dass das Modell mit Reinforcement Studying auf den Open ASR Leaderboard-Trainingssplits verfeinert wurde. Das wird offengelegt, was mehr ist als die meisten anderen, aber es bedeutet, dass die Punktzahl eher den Maßstab als die Leistungsfähigkeit misst.

Non-public-Observe-Daten ordnen das Board neu: Appen beigesteuerte zurückgehaltene Auswertungssätze Abdeckung australischer, kanadischer, indischer und amerikanischer Akzente in Skript- und Konversationssituationen. Wenn diese privaten Units aktiviert sind, wechselt zoom/scribe_v1 von Platz 4 auf Platz 1 und der Anführer der öffentlichen Bestenliste verliert eine Place. Modelle, die auf saubere Lesesprache abgestimmt sind, verschlechtern sich bei spontanem Gesprächsaudio unverhältnismäßig stark.

Nutzen Sie die Bestenliste, um eine Auswahlliste zu erstellen. Verwenden Sie es nicht, um einen Gewinner auszuwählen.

Die Genauigkeitsstufe

Kohärente Transkription (2B, Apache 2.0, 14 Sprachen) ist das Modell, das tatsächlich in Produktion ging. Es wurde im letzten Monat über 620.000 Mal heruntergeladen und bietet umfassende Laufzeitunterstützung transformersvLLM, mlx-audio für Apple Silicon, einen Rust-Port und einen WebGPU-Construct. Es handelt sich um einen Conformer-Encoder mit einem leichten Transformer-Decoder, der von Grund auf trainiert wurde. Cohere führte auch eine menschliche Präferenzbewertung durch, bei der geschulte Annotatoren Transkripte hinsichtlich Bedeutungserhalt, Halluzination und benannter Entitäten bewerteten: eine durchschnittliche Gewinnrate von 61 %, 78 % gegen IBM Granite 4.0 1B Speech und 64 % gegen Whisper Massive-v3.

Der Abschnitt zu den Einschränkungen auf der Modellkarte ist ungewöhnlich ehrlich und sollte vor der Entscheidung gelesen werden. Es gibt keine automatische Spracherkennung, keine Zeitstempel und keine Tagebuchführung, und das Modell ist bestrebt, Stille zu transkribieren, daher empfiehlt Cohere, ein VAD oder Noise Gate voranzustellen. Das Repo ist trotz der Apache 2.0-Lizenz auch durch eine Kontaktinformationsvereinbarung geschützt.

Granite Speech 4.1 2B (2B, Apache 2.0) ist die bessere Wahl, wenn Sie mehr Kapazität benötigen, als eine niedrigere Anzahl. Sechs Sprachen für ASR plus bidirektionale Sprachübersetzung, Key phrase-Pay attention-Biasing für Namen und Fachjargon, Interpunktion und Truecasing, einschließlich deutscher Groß- und Kleinschreibung von Substantiven. Auf 174.000 Stunden trainiert. RTFx 231.29. IBM liefert auch zwei Geschwister aus: -plus fügt sprecherattributierte ASR und Zeitstempel auf Wortebene hinzu und -nar wird weiter unten besprochen.

Canary-Qwen-2.5B (2.5B, CC-BY-4.0, Englisch) koppelt einen FastConformer-Encoder mit einem Qwen3-1.7B-Decoder und läuft in zwei Modi – reine Transkription oder LLM-Modus, in dem der Decoder Fragen zum Transkript zusammenfasst und beantwortet. 5,63 % WER bei RTFx 418. Beachten Sie, dass AMI auf etwa 15 % der Trainingsdaten überabgetastet wurde, was die Ausgabe in Richtung wörtlicher, disfluenzerhaltender Transkripte verzerrt. Das ist ein Function für juristische Arbeiten und ein Ärgernis für Besprechungsnotizen.

Qwen3-ASR-1.7B (Apache 2.0) deckt 52 Sprachen und Dialekte ab – 30 Sprachen plus 22 chinesische Dialekte – bei 5,76 %. Es wird mit einem vollständigen Inferenz-Toolkit und einem separaten erzwungenen Ausrichtungsmodell für Zeitstempel in 11 Sprachen geliefert. Für alles, was Mandarin oder die regionale chinesische Sprache berührt, ist dies der offensichtliche Ausgangspunkt.

Die Durchsatzstufe

Die Genauigkeit im oberen Bereich des Feldes variiert jetzt um etwa einen WER-Punkt. Der Durchsatz variiert um mehr als eine Größenordnung, was bedeutet, dass der Durchsatz in der Regel über die Rechnung entscheidet.

Sittich TDT 0.6B v3 (0,6B, CC-BY-4.0) ist der Durchsatzführer unter den mehrsprachigen offenen Modellen mit RTFx 3332,74 in 25 europäischen Sprachen mit automatischer Spracherkennung und bewältigt bis zu 24 Minuten in einem einzigen Durchgang auf einem A100 80 GB. Es kostet 6,32 % WER – etwa einen Punkt mehr als Granite 4.1 2B für etwa das Vierzehnfache des Audios professional GPU-Sekunde.

Granite Speech 4.1 2B-NAR ist das interessantere technische Ergebnis. Es ist nicht autoregressiv: Es bearbeitet eine CTC-Hypothese in einem einzigen Vorwärtsdurchlauf mithilfe eines bidirektionalen LLM und erreicht RTFx ~1820 auf einem H100 bei Stapelgröße 128. Um dorthin zu gelangen, verzichtet es auf Japanisch, Sprachübersetzung und Key phrase-Biasing.

Qwen3-ASR-0.6B Behält alle 52 Sprachen bei und erreicht einen 2000-fachen Durchsatz bei Parallelität 128.

Die Streaming-Stufe

Ein Batch-WER scheint der falsche Check für ein Streaming-Modell zu sein, und die Bestenliste bewertet sie trotzdem. Voxtral Realtime liegt bei 7,68 % und Kyutai STT 2.6B bei 6,40 % – beide unter Whisper – und keine der beiden Zahlen sagt etwas Nützliches über ihren Verwendungszweck aus.

Voxtral Mini 4B Realtime 2602 (Apache 2.0, 13 Sprachen) ist ein 3.4B-Sprachmodell mit einem von Grund auf trainierten kausalen 970M-Audio-Encoder mit Schiebefenster-Aufmerksamkeit auf beiden Hälften für effektiv unbegrenztes Streaming. Die Transkriptionsverzögerung ist in 80-ms-Schritten von 80 ms bis 1200 ms konfigurierbar, plus einer eigenständigen 2400-ms-Possibility; Mistral empfiehlt 480 ms als Candy Spot und berichtet, dass es bei dieser Einstellung mit führenden offenen Offline-Modellen mithalten kann. Es läuft auf einer einzelnen 16-GB-GPU und hatte Day-0-vLLM-Echtzeit-API-Unterstützung.

Kyutai STT (CC-BY-4.0) gibt es in zwei Formen: als ~1B-Englisch/Französisch-Modell mit einer Verzögerung von 0,5 Sekunden und einem integrierten semantischen Sprachaktivitätsdetektor und als 2,6B-Modell nur für Englisch mit einer Verzögerung von 2,5 Sekunden. Für Sprachagenten ist der semantische VAD wichtiger als die Transkriptionsverzögerung – er sagt voraus, wann der Sprecher tatsächlich fertig ist, was die wahrgenommene Latenz beim Abwechseln bestimmt. Ein H100 bedient 400 gleichzeitige Streams in Echtzeit.

Die Deckungsstufe

Metas omnilingualer ASR (Apache 2.0, Korpus CC-BY) konkurriert nicht auf WER und sollte nicht so bewertet werden, als ob dies der Fall wäre. Es deckt nativ mehr als 1.600 Sprachen ab und erweitert sich durch Zero-Shot-In-Context-Lernen auf mehr als 5.400 Sprachen. Es basiert auf einem wav2vec 2.0-Encoder, der auf 7B skaliert und in etwa 4,3 Millionen Stunden vorab trainiert wurde. Die 7B LLM-ASR-Variante erreicht eine Zeichenfehlerrate von unter 10 % bei 78 % der unterstützten Sprachen, darunter 500+, die noch nie zuvor von einem ASR-System unterstützt wurden. Die Encodergrößen reichen von 300M bis 7B. Meta veröffentlichte außerdem den Omnilingual ASR Corpus, der mehr als 350 unterversorgte Sprachen abdeckt.

Whisper Massive-v3 (1.55B, MIT, 99 Sprachen) wurde hinsichtlich der Genauigkeit von etwa zehn offenen Modellen überholt und bleibt für eine große Klasse von Projekten der korrekte Standardwert. MIT ist die am wenigsten belastete Lizenz auf diesem Gebiet. Das Laufzeit-Ökosystem – Whisper.cpp, Sooner-Whisper, WhisperX – hat unter den neueren Versionen kein Äquivalent. Wenn Ihre Anforderung „etwas Sprache, etwas {Hardware}, kein Lizenzanwalt“ lautet, ist dies immer noch die Antwort.

Der Vorsprung der Forschung

diffusion-gemma-asr-klein vom YC-Startup Interfaze ist die architektonisch kreativste Veröffentlichung des Jahres. Es erzeugt Transkripte durch paralleles Diffusions-Diffusions-Rauschunterdrücken über einen 256-Token-Canvas in 8 bis 16 Schritten, sodass die Dekodierungskosten nicht mit der Länge des Transkripts steigen. Es wurden nur ~42 Millionen Parameter trainiert – 0,16 % der Gewichte – auf einem eingefrorenen 26B DiffusionGemma und einem eingefrorenen Flüsterklein-Encoder. Beim LibriSpeech-Check-Clear erreicht es 6,6 % WER bei etwa 11- bis 17-facher Echtzeit. Es erreicht außerdem 15,7 % bei FLEURS Englisch und 29,6 % CER bei FLEURS Mandarin. Behandeln Sie daher die LibriSpeech-Zahl als Obergrenze. Niemand sollte dies einsetzen. Jeder, der an ASR arbeitet, sollte es lesen.

MOSS-Transkribieren-Diarisieren 0,9B (Apache 2.0, 50+ Sprachen) löst das Downside, das die meisten Zusammenfassungen ignorieren: Es gibt Sprecherbezeichnungen, Wortzeitstempel und Transkript in einer Era aus, anstatt ASR an einen separaten Diarisierungsstapel zu verketten. 128.000 Kontext, etwa 90 Minuten Audio in einem Durchgang, RTF ~0,017 auf einer RTX 4090, mit Hotword-Bias.

Die Lizenzaufteilung liest bis zur Bereitstellung niemand

Dies ist der Abschnitt, der den Versand tatsächlich blockiert, und das Feld ist sauber unterteilt:

Apache 2.0: Cohere Transcribe, Granite Speech 4.1 (alle drei Varianten), Qwen3-ASR (beide Größen), Voxtral Mini Realtime, Omnilingual ASR, ARK-ASR, MOSS-Transcribe. Keine Quellenangabepflicht, kommerzielle Nutzung uneingeschränkt. Beachten Sie, dass das Repo von Cohere einer Kontaktinformationsvereinbarung unterliegt, obwohl die Lizenz selbst Apache 2.0 ist.

MIT: Whisper Massive-v3. Die freizügigste Possibility auf diesem Gebiet.

CC-BY-4.0: Canary-Qwen-2.5B, Parakeet TDT 0.6B v3, Kyutai STT. Gewerblich nutzbar, Namensnennung erforderlich. Für ein eingebettetes Produkt oder eine White-Label-API stellt dies eine echte Compliance-Verpflichtung dar und ist der häufigste Grund dafür, dass Groups am Ende ein Modell ausliefern, das nicht das genaueste ist, das sie getestet haben.

Metas Omnilingual ASR trennt die beiden: Apache 2.0 für Modelle, CC-BY für den Korpus.

Wie man tatsächlich wählt

Führen Sie diese Reihenfolge aus, nicht nur die Ranglistenreihenfolge:

1. Lizenz: Wenn die Namensnennung ein Blocker ist, entfernt CC-BY-4.0 Parakeet, Canary-Qwen und Kyutai, bevor Sie irgendetwas vergleichen.
2. Sprachabdeckung: Die 14 Sprachen von Cohere, die 6 von Granite und die Nur-Englisch-Sprache von Canary sind harte Grenzen, keine weichen. Darüber hinaus verfügt Cohere über keine automatische Spracherkennung, sodass Sie die Sprache im Voraus kennen müssen.
3. Streaming oder Batch: Das ist architektonisch. Kein Aufwand an Optimierung verwandelt einen Offline-Encoder-Decoder in ein Streaming-Modell mit geringer Latenz.
4. Dann messen Sie WER auf Ihrem eigenen Audio: Der Abstand zwischen den Prime-Ten-Modellen im öffentlichen Benchmark beträgt weniger als einen Punkt. Die Streuung Ihres akzentuierten, verrauschten, domänenspezifischen Audios wird um ein Vielfaches höher sein und die Modelle werden nicht in derselben Reihenfolge eingestuft.
5. Berechnen Sie dann die Kosten professional Audiostunde auf Ihren eigenen GPUs: RTFx-Zahlen werden bei großen Batchgrößen auf Rechenzentrumshardware gemessen und nicht übertragen.

Die nützliche Zusammenfassung des Jahres 2026 ist nicht, dass ein einzelnes Modell gewonnen hat. Es liegt daran, dass ein 2B-Modell mit offenem Gewicht und einer freizügigen Lizenz jetzt die Preise übertrifft, die geschlossene APIs vor 18 Monaten verlangten, und dass die verbleibende Entscheidung eher eine Beschaffungsfrage als eine Forschungsfrage ist.

Quellen:

Die Positionen in der Bestenliste sind stay und ändern sich häufig. Alle Zahlen wurden am 23. Juli 2026 anhand von Primärquellen überprüft.

Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.

Ihr KI-Agent leistet beim Testen hervorragende Arbeit. Dann verschicken Sie es und etwas geht irgendwie kaputt. Ein Instrument namens Loops läuft ewig, als würde es nie lernen. Ein Abrufschritt bringt Müll zurück und die Kosten steigen. Sie haben überhaupt keine Ahnung, warum.

Das ist das Downside der Agentenbeobachtbarkeit. Und wenn Sie mit LLMs bauen, müssen Sie das Downside vor der Produktion lösen, nicht danach. In diesem Beitrag werden drei der am häufigsten verwendeten Observability-Instruments näher erläutert: LangSmith, Langfuse Und Arize. Wir richten jeden einzelnen ein, verfolgen denselben Agenten und vergleichen, was Sie tatsächlich erhalten.

Was ist Agent Observability?

Die herkömmliche Anwendungsüberwachung verfolgt Anfragen, Fehler und Latenz, aber das reicht für Agenten nicht aus.

Ein Agent kann mehrere Instruments nacheinander aufrufen, wobei jeder LLM-Schritt seine eigene Eingabeaufforderung, Token-Nutzung, Latenz und potenzielle Fehlerstelle hat. Ein einzelner fehlgeschlagener Abruf oder Instrument-Aufruf kann zu einer falschen Endantwort führen.

Beobachtbarkeit des Agenten erfasst das vollständige Ausführungsdiagramm: jeden Schritt, jede Entscheidung, jede LLM-Eingabe und -Ausgabe, jeden Instrument-Aufruf, Argumente, Ergebnisse, Token-Nutzung, Latenz und Bewertungsergebnis. Ohne diese Sichtbarkeit wird das Verhalten des Debug-Agenten zur Vermutung.

Einrichten des Testagenten

Wir werden einen sehr einfachen LangChain-Agenten verwenden, um sie zu vergleichen. Der Agent empfängt eine Frage des Benutzers, ruft den relevanten Kontext ab und antwortet mithilfe eines oder mehrerer Instruments, um eine Antwort bereitzustellen.

Zunächst müssen Sie den Testagenten erstellen und dafür alle erforderlichen Bibliotheken installieren.

Schauen wir uns den Basisagenten mit zwei Methoden an (search_docs Und get_order_status). Dies dient als Grundlage für den Vergleich mit den drei Observability-Instruments.

"""
Base agent used throughout all three observability demos.

Swap the OPENAI_API_KEY env var or name build_agent() from any demo file.
"""

import os

from dotenv import load_dotenv
from langchain.brokers import AgentExecutor, create_openai_tools_agent
from langchain.instruments import device
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai import ChatOpenAI

load_dotenv()


@device
def search_docs(question: str) -> str:
    """Search inside docs for related data."""
    # Simulated retrieval — swap together with your precise vector retailer
    docs = {
        "refund": (
            "Refunds are processed inside 5-7 enterprise days. "
            "Gadgets should be returned inside 30 days."
        ),
        "transport": (
            "Commonplace transport takes 3-5 enterprise days. "
            "Specific is 1-2 days."
        ),
        "account": (
            "You possibly can reset your password by way of the login web page. "
            "Contact assist for account points."
        ),
    }

    for key phrase, content material in docs.gadgets():
        if key phrase in question.decrease():
            return content material

    return f"Discovered basic docs associated to: {question}"


@device
def get_order_status(order_id: str) -> str:
    """Lookup the standing of an order by ID."""
    # Simulated order lookup
    statuses = {
        "ORD-001": "Shipped — anticipated supply 2026-05-30",
        "ORD-002": "Processing — not but shipped",
        "ORD-003": "Delivered on 2026-05-25",
    }

    return statuses.get(
        order_id,
        f"Order {order_id} not discovered within the system.",
    )


def build_agent() -> AgentExecutor:
    llm = ChatOpenAI(
        mannequin="gpt-4o",
        temperature=0,
        api_key=os.environ("OPENAI_API_KEY"),
    )

    instruments = (search_docs, get_order_status)

    immediate = ChatPromptTemplate.from_messages(
        (
            (
                "system",
                "You're a useful buyer assist assistant. "
                "Use instruments when wanted.",
            ),
            ("person", "{enter}"),
            MessagesPlaceholder(variable_name="agent_scratchpad"),
        )
    )

    agent = create_openai_tools_agent(llm, instruments, immediate)

    return AgentExecutor(
        agent=agent,
        instruments=instruments,
        verbose=False,
    )


TEST_QUESTIONS = (
    "What are the refund insurance policies?",
    "What's the standing of order ORD-002?",
    "How lengthy does transport take?",
)


if __name__ == "__main__":
    executor = build_agent()

    for query in TEST_QUESTIONS:
        print(f"nQ: {query}")

        outcome = executor.invoke({"enter": query})

        print(f"A: {outcome('output')}")

Dadurch wird ein Kandidatenagent erstellt, der auch mit jedem der Instruments verwendet werden kann. Das erste Instrument, das wir untersuchen werden, wird das von LangSmith bereitgestellte sein.

LangSmith: Native Langchain-Tracing

Das LangChain-Group hat sich weiterentwickelt LangSmith. Wenn Sie LangChain verwenden, erfolgt die Integration schnell und einfach.

"""
LangSmith observability demo.

Setup:

pip set up langsmith

Set LANGCHAIN_API_KEY in your .env file.

The way it works:

LangSmith hooks into LangChain's callback system by way of env vars, so no code
modifications are wanted past the 2 os.environ traces beneath.
"""

import os

from dotenv import load_dotenv

from agent_base import TEST_QUESTIONS, build_agent

load_dotenv()

# Allow LangSmith tracing. These two vars are all you want.
os.environ("LANGCHAIN_TRACING_V2") = "true"
os.environ("LANGCHAIN_PROJECT") = "agent-observability-demo"

# LANGCHAIN_API_KEY should be set in your .env or setting.


def run_with_metadata(
    executor,
    query: str,
    user_id: str = "demo-user",
):
    """Run the agent and fix per-run metadata by way of config."""
    return executor.invoke(
        {"enter": query},
        config={
            "metadata": {
                "user_id": user_id,
                "supply": "langsmith_demo",
            },
            # Optionally available: tag runs for filtering within the dashboard.
            "tags": ("observability-blog", "demo"),
        },
    )


def predominant():
    print("=== LangSmith Demo ===")
    print("Traces will seem at: https://smith.langchain.com")
    print(f"Venture: {os.environ('LANGCHAIN_PROJECT')}n")

    executor = build_agent()

    for query in TEST_QUESTIONS:
        print(f"Q: {query}")

        outcome = run_with_metadata(executor, query)

        print(f"A: {outcome('output')}n")

    print("Carried out. Open LangSmith to examine the complete hint tree for every run.")


if __name__ == "__main__":
    predominant()

LangSmith stellt automatisch eine Verbindung zum Rückrufsystem von LangChain her, ohne dass Dekorateure oder Wrapper erforderlich sind, um jede Ausführung in Ihrem Projekt-Dashboard anzuzeigen.

Was Sie auf dem Dashboard sehen werden:

Die Hint-Ansicht von LangSmith zeigt den vollständigen Agentenausführungsbaum, vom ersten Aufruf über die Instrument-Nutzung, LLM-Antworten bis hin zur endgültigen Ausgabe. Jeder Knoten umfasst Eingaben, Ausgaben und Latenz.

Sie können Läufe mit Tags versehen, Metadaten hinzufügen, nach Ergebnissen filtern, Läufe als Datensätze speichern und Auswertungen durchführen. Dies ist nützlich, wenn Sie Eingabeaufforderungen oder die Abruflogik verbessern.

Der prompte Spielplatz ist ein weiteres starkes Merkmal. Sie können eine beliebige Ablaufverfolgung öffnen, die Eingabeaufforderung inline bearbeiten und sie erneut ausführen, um eine schlechte LLM-Leistung zu beheben.

Die Einschränkungen von LangSmith zeigen sich im großen Maßstab. Für das kostenlose Kontingent gelten Obergrenzen und die Integration erfordert mehr Aufwand, wenn Sie LangChain nicht verwenden, obwohl OpenTelemetry unterstützt wird.

Langfuse: Open Supply und Framework-Agnostiker

Langfuse ist hier die Open-Supply-Various. Sie können es entweder auf Ihrem Server hosten oder deren Cloud-Dienst nutzen. Es lässt sich auch in alle Frameworks wie LangChain, LlamaIndex, rohe OpenAI-APIs usw. integrieren.

# Learn this Doc-string for putting in the dependencies and their setup 
"""
Langfuse observability demo.

Setup:

pip set up langfuse

Set LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY in your .env file.

LANGFUSE_HOST defaults to https://cloud.langfuse.com; override for self-hosted.

Key variations from LangSmith:

- Callback handler is handed per-invoke for extra express management.
- Native session grouping for multi-turn conversations.
- You possibly can rating any hint after the very fact by way of the Langfuse consumer.
"""

import os

from dotenv import load_dotenv
from langfuse import Langfuse
from langfuse.callback import CallbackHandler

from agent_base import TEST_QUESTIONS, build_agent

load_dotenv()


def build_handler(
    session_id: str,
    user_id: str = "demo-user",
) -> CallbackHandler:
    return CallbackHandler(
        public_key=os.environ("LANGFUSE_PUBLIC_KEY"),
        secret_key=os.environ("LANGFUSE_SECRET_KEY"),
        host=os.getenv("LANGFUSE_HOST", "https://cloud.langfuse.com"),
        session_id=session_id,
        user_id=user_id,
        metadata={"supply": "langfuse_demo"},
        tags=("observability-blog", "demo"),
    )


def score_trace(
    trace_id: str,
    rating: float,
    remark: str = "",
):
    """Add a correctness rating to a hint after reviewing the output."""
    lf = Langfuse(
        public_key=os.environ("LANGFUSE_PUBLIC_KEY"),
        secret_key=os.environ("LANGFUSE_SECRET_KEY"),
        host=os.getenv("LANGFUSE_HOST", "https://cloud.langfuse.com"),
    )

    lf.rating(
        trace_id=trace_id,
        title="correctness",
        worth=rating,
        remark=remark,
    )

    lf.flush()

    print(f"Scored hint {trace_id}: {rating}")


def run_single_session(
    executor,
    session_id: str,
):
    """Run all check questions in a single session so that they're linked within the UI."""
    handler = build_handler(session_id=session_id)
    trace_ids = ()

    for query in TEST_QUESTIONS:
        print(f"Q: {query}")

        outcome = executor.invoke(
            {"enter": query},
            config={"callbacks": (handler)},
        )

        print(f"A: {outcome('output')}n")

        # handler.get_trace_id() returns the hint ID for the final run.
        trace_ids.append(handler.get_trace_id())

    # Flush ensures traces are despatched earlier than the method exits.
    # That is essential in batch jobs.
    handler.flush()

    return trace_ids


def predominant():
    print("=== Langfuse Demo ===")
    print(f"Dashboard: {os.getenv('LANGFUSE_HOST', 'https://cloud.langfuse.com')}n")

    executor = build_agent()
    session_id = "demo-session-001"

    trace_ids = run_single_session(executor, session_id)

    # Instance: programmatically rating the primary hint.
    if trace_ids and trace_ids(0):
        print("nScoring first hint for example:")
        score_trace(trace_ids(0), rating=0.9, remark="Reply was correct")

    print(f"nDone. Discover all runs beneath session '{session_id}' in your Langfuse dashboard.")


if __name__ == "__main__":
    predominant()

Sie können bei jedem Lauf Callback-Handler übergeben, was etwas expliziter ist als bei LangSmith, aber mehr Flexibilität bietet, da Sie beim Aufruf Benutzer-IDs, Sitzungs-IDs und benutzerdefinierte Metadaten zuweisen können.

Bewertungsworkflow

Langfuse verfügt auch über einen wirklich guten Bewertungsworkflow; Sie können Punkte hinzufügen, nachdem die Verfolgung abgeschlossen ist.

from langfuse import Langfuse

lf = Langfuse()

# Rating a particular hint by ID.
lf.rating(
    trace_id="trace-abc123",
    title="correctness",
    worth=0.9,
    remark="Reply was correct however barely verbose",
)

Dies funktioniert in Verbindung mit menschlichen Überprüfungen der von Ihrem Group erzielten Antworten, sodass Sie im Laufe der Zeit aggregierte Bewertungsmetriken erhalten.

Benutzer können ihre Sitzungen organisieren, indem sie sie verbinden, sodass Agenten Gespräche über mehrere Runden hinweg problemlos verfolgen können. Alle Spuren einer einzelnen Benutzersitzung werden in der Anwendung verknüpft, sodass Sie ein gesamtes Gespräch an einem Ort verfolgen können.

Arize: ML-Beobachtbarkeit auf Produktionsniveau

Arize wurde ursprünglich als Plattform zur Überwachung herkömmlicher Modelle des maschinellen Lernens entwickelt und ist nun in der Lage, sowohl Sprachmodelle als auch Agenten zu beobachten. Die Tatsache, dass es ursprünglich entwickelt wurde, um Groups bei der maßstabsgetreuen Bereitstellung von Modellen in der Produktion zu unterstützen, ist bis heute erhalten geblieben.

Nutzung von OpenInference

Zusätzlich zur Verwendung des OpenInference-Requirements als Messschema lässt sich Arize zur Instrumentierung in OpenTelemetry integrieren. Die Konfiguration von Arize ist komplizierter als bei den meisten Anbietern.

# Learn this Doc-string for putting in the dependencies and their setup 
"""
Arize observability demo.

Setup:

pip set up arize-otel openinference-instrumentation-langchain

Set ARIZE_SPACE_ID and ARIZE_API_KEY in your .env file.

Key variations from the others:

- Makes use of OpenTelemetry beneath the hood, so it integrates with present OTel stacks.
- Instrumentation is international like LangSmith, not per-invoke like Langfuse.
- Greatest-in-class manufacturing monitoring: drift detection, cohort evaluation, alerting.
- Phoenix, arize-phoenix, is the free native sibling for growth use.
"""

import os

from arize.otel import register
from dotenv import load_dotenv
from openinference.instrumentation.langchain import LangChainInstrumentor

from agent_base import TEST_QUESTIONS, build_agent

load_dotenv()


def setup_arize_tracing():
    """Register Arize because the OTel tracer supplier and instrument LangChain globally."""
    tracer_provider = register(
        space_id=os.environ("ARIZE_SPACE_ID"),
        api_key=os.environ("ARIZE_API_KEY"),
        project_name="agent-observability-demo",
    )

    LangChainInstrumentor().instrument(tracer_provider=tracer_provider)

    return tracer_provider


def run_with_attributes(
    executor,
    query: str,
    user_segment: str = "commonplace",
):
    """Run the agent and fix span attributes for cohort evaluation in Arize."""
    from opentelemetry import hint

    tracer = hint.get_tracer(__name__)

    with tracer.start_as_current_span("agent_run") as span:
        span.set_attribute("person.phase", user_segment)
        span.set_attribute("question.textual content", query)
        span.set_attribute("demo.supply", "arize_demo")

        outcome = executor.invoke({"enter": query})

        span.set_attribute("response.textual content", outcome("output"))

        return outcome


def predominant():
    print("=== Arize Demo ===")
    print("Traces will seem at: https://app.arize.com")
    print("Venture: agent-observability-demon")

    setup_arize_tracing()

    executor = build_agent()

    # Simulate two person segments to reveal cohort evaluation in Arize.
    segments = ("premium", "commonplace", "commonplace")

    for query, phase in zip(TEST_QUESTIONS, segments):
        print(f"Q: {query} (phase={phase})")

        outcome = run_with_attributes(
            executor,
            query,
            user_segment=phase,
        )

        print(f"A: {outcome('output')}n")

    print("Carried out. In Arize, use the cohort filter to check premium vs commonplace responses.")
    print("Arrange screens on the Arize dashboard to alert on response high quality drift.")


if __name__ == "__main__":
    predominant()

Die Instrumentierung ist international wie die von LangSmith, wird jedoch zu einem Bestandteil des gesamten Messrahmens von OpenTelemetry. Daher kann Arize den vorhandenen Observability Stack Ihrer Organisation nutzen, unabhängig vom tatsächlich verwendeten Framework (z. B. Jaeger, Grafana usw.).

Welches sollten Sie für die Beobachtbarkeit von Agenten auswählen?

Um ganz offen zu sein: Es gibt kein einziges richtiges Instrument für alle Anwendungsfälle. Es hängt alles davon ab, wo Sie sich im Entwicklungszyklus befinden und was Ihr Group braucht.

• Verwenden LangSmith wenn Sie mit LangChain erstellen und die schnellste Einrichtung für schnelles Debuggen und Iteration wünschen.
• Verwenden Langfuse wenn Sie Selbsthosting, stärkeres Dateneigentum, Multi-Framework-Unterstützung oder Monitoring auf Sitzungsebene für Konversationsagenten benötigen.
• Verwenden Arize wenn Ihr Agent in die Produktion übergeht und Sie Überwachung, Abweichungserkennung, Kohorten und Warnungen benötigen.

Abschluss

Die Beobachtbarkeit von Agenten gehört zu den Dingen, die Sie nur dann bereuen, wenn in der Produktion ein Fehler auftritt. Das Nachverfolgen einer Agentenausführung ohne jegliche Instrumentierung ist wie das Debuggen eines verteilten Programs mit Druckanweisungen.

Alle drei hier behandelten Werkzeuge sind produktionsbereit. Sie haben jeweils einen freien Zugang. Und die Integration mit einem LangChain-Agenten dauert jeweils weniger als 30 Minuten. Es gibt keinen guten Grund mehr, einen unbeobachtbaren Agenten zu entsenden.

Wählen Sie das Werkzeug, das zu Ihrer aktuellen Section passt. Fügen Sie frühzeitig Punkte hinzu, auch informell. Und wenn Ihr Agent um 2 Uhr morgens anfängt, etwas Seltsames zu tun, werden Sie es nicht bereuen.

Information Science Trainee bei Analytics Vidhya
Derzeit arbeite ich als Information Science Trainee bei Analytics Vidhya, wo ich mich auf die Entwicklung datengesteuerter Lösungen und die Anwendung von KI/ML-Techniken zur Lösung realer Geschäftsprobleme konzentriere. Meine Arbeit ermöglicht es mir, fortschrittliche Analysen, maschinelles Lernen und KI-Anwendungen zu erforschen, die es Unternehmen ermöglichen, intelligentere, evidenzbasierte Entscheidungen zu treffen.
Mit einem starken Fundament in den Bereichen Informatik, Softwareentwicklung und Datenanalyse ist es mir eine Leidenschaft, KI zu nutzen, um wirkungsvolle, skalierbare Lösungen zu schaffen, die die Lücke zwischen Technologie und Geschäft schließen.
Du kannst mich auch erreichen unter (electronic mail protected)

Mit der zunehmenden Leistungsfähigkeit von KI-Programmierern ist ein strukturelles Drawback aufgetaucht: Geschwindigkeit ohne Klarheit. Entwickler generieren innerhalb von Minuten funktionierenden Code, nur um Tage später festzustellen, dass er nicht mit dem übereinstimmt, was das System tatsächlich benötigt. Die spezifikationsgesteuerte Entwicklung (SDD) geht dieses Drawback direkt an – indem sie eine strukturierte Spezifikation als Quelle der Wahrheit und Code als generierte Ausgabe behandelt und nicht umgekehrt.

Diese Liste umfasst die 9 KI-Instruments, die Entwickler im Jahr 2026 tatsächlich zur Implementierung von SDD-Workflows verwenden.

AWS Kiro

kiro.dev | Dokumente | Modelle

Kiro ist eine Agenten-IDE, die auf spezifikationsgesteuerter Entwicklung basiert und Entwickler mit strukturierter Strenge statt iterativer Eingabeaufforderung vom Konzept bis zur Produktion führen soll. Anstatt Code zu schreiben und dabei eine KI um Hilfe zu bitten, verlangt Kiro von den Entwicklern, dass sie zunächst ihre Absicht formalisieren. Es führt sie durch einen dreiphasigen Prozess – Anforderungen, Design und Aufgaben – und erzeugt drei strukturierte Artefakte: „necessities.md“, „design.md“ und „duties.md“. Ein bemerkenswertes technisches Element: Kiro generiert Consumer Tales mithilfe der EARS-Notation (Straightforward Method to Necessities Syntax), die strukturierte Akzeptanzkriterien erstellt, die Grenzfälle abdecken, die Entwickler sonst manuell bearbeiten würden.

Ein wesentliches Unterscheidungsmerkmal ist das Agent-Hooks-System – ereignisgesteuerte Automatisierungen, die beim Speichern oder Erstellen von Dateien ausgelöst werden und Aufgaben wie Testaktualisierungen, README-Aktualisierungen und Sicherheitsscans ohne manuelle Eingabeaufforderung erledigen. Bei der Modellauswahl verwendet Kiro standardmäßig einen Auto-Router, der mehrere Frontier-Modelle kombiniert – darunter Claude Sonnet, Qwen, DeepSeek, GLM und MiniMax – und das optimale Modell professional Aufgabe auswählt, um Qualität und Kosten in Einklang zu bringen. Entwickler können auch ein bestimmtes Modell für konsistentes Verhalten festlegen. VS Code-Benutzer basieren auf Code OSS und werden sich sofort zu Hause fühlen. Kiro unterstützt außerdem eine CLI und eine Webschnittstelle und erfordert zur Nutzung kein AWS-Konto. Am besten für Groups geeignet, die formale Spezifikationsworkflows in einer vertrauten Entwicklungsumgebung benötigen.

GitHub-Spezifikationskit

github.com/github/spec-kit | Blogbeitrag

GitHub Spec Equipment ist die von der Group am häufigsten angenommene Open-Supply-Choice für spezifikationsgesteuerte Entwicklung – eine Python-CLI mit über 93.000 Sternen, die neueste Model ist v0.8.7 (7. Mai 2026), die mehr als 30 KI-Coding-Brokers unterstützt, darunter Claude Code, GitHub Copilot, Amazon Q und Gemini CLI. Der Workflow durchläuft vier Phasen mit klaren Prüfpunkten: Spezifizieren (erfasst Geschäftskontext und Erfolgskriterien), Planen (übersetzt Spezifikationen in Architekturentscheidungen), Aufgaben (zerlegt Pläne in testbare, überprüfbare Einheiten) und Implementieren (führt KI-Agenten unter diesen Einschränkungen aus).

Die Grundlage jedes Spec-Equipment-Workflows ist eine „Verfassung“ – eine Datei mit Markdown-Regeln, die unveränderliche Prinzipien auf hoher Ebene enthält, die für jede Änderung in jeder Sitzung gelten. Dies wird zum dauerhaften Vertrag zwischen dem Entwickler und dem Agenten. Die Philosophie von Spec Equipment, wie GitHub sie formuliert hat, besteht darin, dass Code jetzt die Ausgabe auf der letzten Meile ist: Absicht ist die Quelle der Wahrheit und Spezifikationen sind ausführbar. Es ist der Standardstartpunkt für Groups, die neu bei SDD sind, und die portabelste Choice für Groups, die ihre bestehende IDE behalten möchten.

BMAD-METHODE

github.com/bmad-code-org/BMAD-METHOD | Dokumente

BMAD-METHOD (Construct Extra Architect Desires) ist ein MIT-lizenziertes Open-Supply-Framework, das mehr als 12 spezialisierte KI-Agenten über den gesamten Softwareentwicklungslebenszyklus orchestriert. Model 6.6.0 wurde am 29. April 2026 ausgeliefert, wobei das Projekt mehr als 46.700 GitHub-Sterne und mehr als 5.500 Forks erreichte. Die über 12 Agenten decken unterschiedliche SDLC-Rollen ab – einschließlich Produktmanagement, Architektur, UX, Entwicklung, Qualitätssicherung und Scrum-Grasp-Funktionen – und arbeiten durch strukturierte, dateibasierte Übergaben zusammen: Jeder Agent liest das Ausgabedokument des vorherigen Agenten und schreibt sein eigenes und sorgt so für eine nachvollziehbare Kette von den Anforderungen bis zur Lieferung.

Mit V6 wurde das Cross Platform Agent Group eingeführt, das den Betrieb derselben Agentenkonfiguration auf Claude Code, Cursor, Codex und anderen Hosts ohne Neukonfiguration ermöglicht. Die V6-Architektur unterteilt Anliegen außerdem in drei Schichten: BMad Core (das universelle Framework für die Zusammenarbeit zwischen Mensch und KI), BMad Methodology (das auf Core basierende agile Entwicklungsmodul) und BMad Builder (mit dem Groups benutzerdefinierte Agenten und Workflows erstellen und teilen können). BMAD ist das Framework der Wahl für Groups, die hochstrukturierte, rollengetrennte Multi-Agent-Workflows ohne Anbieterbindung wünschen. Das Framework ist völlig kostenlos und ohne Paywalls.

Erweiterungscode

augmentcode.com | SDD-Leitfaden

Increase Code nähert sich der spezifikationsgesteuerten Entwicklung von der Kontextebene und nicht von der Spezifikationserstellungsebene. Seine Context Engine behält ein konsistentes Architekturverständnis über mehr als 400.000 Dateien bei und schließt damit die Repository-übergreifende Kontextlücke, die die meisten Spezifikationsworkflows im großen Maßstab zum Erliegen bringt, insbesondere in Brownfield-Codebasen mit mehreren Diensten. Increase meldet 70,6 % auf der SWE-Benchmark (im Vergleich zu einem Branchendurchschnitt von 54 %) und einen F-Rating von 59 % auf einem AI-Code-Evaluate-Benchmark; Diese Zahlen werden vom Anbieter gemeldet und sollten entsprechend behandelt werden.

Das BYOA-Modell (Convey Your Personal Agent) ermöglicht es Groups, neben dem nativen Auggie-Agenten auch Claude Code, Codex oder OpenCode einzubinden. Increase Code erstellt Spezifikationen nicht nativ – Groups benötigen immer noch ein Instrument wie Spec Equipment oder Kiro für die strukturierte Spezifikationsverwaltung – aber es bietet die semantische Grundlage, die diese Spezifikationen über große Codebasen hinweg präzise macht. Am besten geeignet für Unternehmensteams, die komplexe Multi-Service-Architekturen betreiben, bei denen Kontextdrift und nicht die Spezifikationserstellung die primäre Fehlerursache ist.

Claude Code

claude.ai/code | Dokumente

Claude Code ist das agentische Befehlszeilentool von Anthropic und im Gegensatz zu Instruments wie Cursor oder GitHub Copilot, die den Arbeitsablauf eines Entwicklers erweitern, ist es für eine vollständig autonome Entwicklung konzipiert – Planung, Orchestrierung mehrstufiger Arbeitsabläufe und Stellen von Folgefragen ohne ständige Aufforderung. Für spezifikationsgesteuerte Arbeitsabläufe verarbeitet Claude Code große Spezifikationsdokumente intestine in einer einzigen Sitzung, verarbeitet vollständige Anforderungssätze und generiert Implementierungen in einem kohärenten Durchgang.

Entwickler verwenden in der Regel CLAUDE.md-Dateien als Spezifikationsebene – ein einfacher Ansatz, der in jeder Sitzung einen dauerhaften Projektkontext, Codierungsstandards und Architekturbeschränkungen erzwingt. Dies bedeutet, dass viele Entwickler bereits eine Kind von SDD mit Claude Code praktizieren, ohne es offiziell als solches zu kennzeichnen. Claude Code dient auch als allgemein unterstützter Ausführungsagent für alle SDD-Frameworks, einschließlich BMAD, GSD und GitHub Spec Equipment.

GSD (Get Shit Carried out)

github.com/gsd-build/get-shit-done

GSD ist ein spezifikationsgesteuertes Meta-Prompting- und Kontext-Engineering-Framework, das hauptsächlich für Claude Code und kompatible Agenten entwickelt wurde und sich als schlanke Various zu BMAD mit geringem Aufwand positioniert. Das Projekt hat 61.000 GitHub-Sterne überschritten und ist seit seiner ersten Veröffentlichung im Dezember 2025 in weniger als fünf Monaten von null auf diese Zahl gewachsen. Die Set up erfolgt über npx get-shit-done-cc@newest und funktioniert mit Claude Code, OpenCode, Gemini CLI, Codex, Copilot, Cursor, Windsurf, Increase und Cline.

Seine Multi-Agenten-Orchestrierung bringt parallele Forscher, Planer, Ausführende und Prüfer hervor, die jeweils in einem neuen Kontextfenster mit bis zu 200.000 Token für die Implementierung arbeiten. Das modellunabhängige Design – einschließlich der Unterstützung von OpenRouter und lokalen Modellen – entkoppelt den Workflow von jedem einzelnen LLM-Anbieter. Während BMAD Dash-Zeremonien und Stakeholder-Koordination hinzufügt, ist die Philosophie von GSD, dass Komplexität im System leben sollte, nicht im Arbeitsablauf. Es schließt auch eine Lücke, die Claude Code selbst nicht nativ abdeckt: Kontextrotation, High quality Gates und Persistenz des Planungszustands über Sitzungen hinweg.

Cursor (mit Planmodus + Projektregeln)

Cursor.com | Finest Practices für Agenten

Cursor ist nach wie vor einer der am weitesten verbreiteten KI-Editoren und sein Planmodus macht ihn zu einem praktischen Einstiegspunkt für Groups, die Spec-First-Gewohnheiten übernehmen, ohne die Toolchains zu wechseln. Der Planmodus erstellt einen detaillierten Implementierungsplan, bevor Code geschrieben wird. Er stellt klärende Fragen, ordnet betroffene Dateien zu und erstellt einen überprüfbaren Plan, den der Entwickler genehmigt, bevor der Agent handelt. Dies verhindert eine vorzeitige Codegenerierung für Funktionen, die mehrere Dateien betreffen oder Architekturentscheidungen erfordern.

Für einen dauerhaften spezifikationsähnlichen Kontext verwendet das aktuelle Regelsystem von Cursor die unter gespeicherten Projektregeln .cursor/guidelines/ (je älter .cursorrules Die Konvention gilt heute als Vermächtnis). In Kombination mit Projektregeln unterstützt Cursor einen einfachen, tragbaren Spezifikationsworkflow für mittelgroße bis große Greenfield-Options. Der Nachteil besteht darin, dass die Spezifikationsunterstützung von Cursor nicht nativ in der Architektur verankert ist, wie dies bei Kiro der Fall ist – es gibt keinen integrierten Spezifikationslebenszyklus, keine Drifterkennung oder keine lebende Spezifikationssynchronisierung. Für Groups, die eine strukturierte KI-Entwicklung in einem vertrauten, hochwertigen Editor ohne vollen SDD-Overhead wünschen, ist Cursor mit Planmodus ein geeigneter Mittelweg.

OpenSpec

github.com/Fission-AI/OpenSpec

OpenSpec zielt auf einen bestimmten und unterversorgten Anwendungsfall ab: Groups, bei denen das Änderungsmanagement eine explizite, überprüfbare Dokumentation erfordert, bevor mit der Implementierung begonnen wird. Es verwendet einen vorschlagszentrierten Workflow mit strukturierten Artefakten für Änderungen und befasst sich speziell mit der Brownfield-Iteration mit Delta-Markern (ADDED/MODIFIED/REMOVED), die verfolgen, welche Änderungen relativ zur vorhandenen Funktionalität statt mit Greenfield-Beschreibungen vorgenommen werden. Wichtig ist, dass OpenSpec in seiner eigenen Dokumentation es als leichtgewichtig und flexibel und nicht als starres Section-Gate-System positioniert – es bietet Struktur, ohne harte Genehmigungstore zwischen den Phasen zu erzwingen.

In einer unabhängigen Bewertung im Februar 2026 in 13 Bewertungskategorien auf einem mittelgroßen serverlosen Python-Backend erzielte OpenSpec insgesamt die höchste Punktzahl – allerdings verschiebt sich diese Rangfolge je nach Priorität erheblich. Groups, für die die Verantwortlichkeit für Änderungen und Dokumentationspfade wichtiger sind als die Synchronisierung mit lebenden Spezifikationen, werden feststellen, dass es am besten geeignet ist. Für größere Multi-Service-Initiativen wird die Kombination von OpenSpec mit einer Residing-Spec-Plattform empfohlen, da die vorschlagsbasierte Struktur statische Dokumente erzeugt, die während der erweiterten Implementierung abweichen können.

Tessl

tessl.io | Spec-Registrierung | Dokumente

Tessl ist eine sprachunabhängige Plattform zur Agentenaktivierung, die auf zwei unterschiedlichen Produkten basiert. Das Tessl Framework wird als „Kacheln“ in einem Projekt installiert .tessl/ Verzeichnis und bringt jedem MCP-kompatiblen Agenten – einschließlich Claude Code, Cursor und anderen – bei, unabhängig vom Stack einem spezifikationsgesteuerten Workflow zu folgen: Agenten stellen zuerst klärende Fragen, schreiben strukturierte Spezifikationsdokumente, warten auf die Genehmigung des Entwicklers und implementieren dann. Die Spezifikationen sind als Langzeitgedächtnis in der Codebasis gespeichert, geben Entscheidungen einen Prüfpfad und ermöglichen es dem Agenten, die App im Laufe der Zeit kohärent weiterzuentwickeln.

Das Tessl Spec Registry ist das deutlichste Unterscheidungsmerkmal der Plattform: ein offenes Register mit über 10.000 Spezifikationen, die beschreiben, wie externe Open-Supply-Bibliotheken korrekt verwendet werden, und gezielt auf die API-Halluzinationen und Versionsverwechslungen abzielen, die Agenten häufig in Produktionscodebasen erzeugen. Betrachten Sie es als npm für Spezifikationen – Groups installieren sowohl eine Methodenkachel (wie man arbeitet) als auch Bibliothekskacheln (welche Instruments man richtig verwendet), um sowohl Prozesschaos als auch Dokumentationshalluzinationen zu verhindern. Die zweischichtige Architektur – Prozesskontext plus Bibliothekskontext – ist die Kernerkenntnis von Tessl: Ein strukturierter Workflow allein reicht nicht aus, wenn der Agent immer noch die APIs, mit denen er erstellt, halluziniert.

Folgen Sie uns gerne weiter Twitter und vergessen Sie nicht, bei uns mitzumachen 150.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Möchten Sie mit uns zusammenarbeiten, um Ihr GitHub-Repo ODER Ihre Hugging Face Web page ODER Produktveröffentlichung ODER Ihr Webinar usw. zu bewerben? Vernetzen Sie sich mit uns

Mit dem Aufkommen von UDFs sollten wir die Verwendung von Berechnungsgruppen überdenken.

Beides sind wesentliche Merkmale bei der Vereinfachung eines semantischen Modells durch Modularisierung der Logik und Reduzierung der Duplizierung der Geschäftslogik.

Während UDFs sehr nützlich sind, um die Geschäftslogik zu standardisieren und sie nur einmal professional Datenmodell zu haben, sind Berechnungsgruppen für Berichtsdesigner nützlich, um Geschäftslogik auf Kennzahlen anzuwenden.

Berechnungsgruppen sind für Berichtsdesigner sichtbar, UDFs können jedoch nur innerhalb von DAX-Ausdrücken und nicht im Entrance-Finish verwendet werden.

Ressourcen zum Kombinieren von UDFs und Berechnungsgruppen finden Sie im Abschnitt „Referenzen“ weiter unten.

Die Frage ist, ob wir explizite Maßnahmen hinzufügen oder den Benutzern nur Berechnungsgruppen anbieten sollten.

Hier ist ein Beispiel:

Ich muss die Möglichkeit bieten, den Vorjahreswert zu berechnen.

• Ich kann ein Berechnungselement anbieten, mit dem der Benutzer das gewünschte Ergebnis erzielen kann.
• Ich kann ein explizites Maß für das PY-Ergebnis hinzufügen.

Die Frage ist: Welches bietet mehr Flexibilität und ist einfacher zu verwenden?

Das ist die Frage, die ich hier zu beantworten versuche.

Die Ansicht des Benutzers

Erstens: Wer ist der Benutzer?

Es gibt zwei Benutzergruppen:

• Berichtsdesigner, die unsere semantischen Modelle verwenden und das semantische Modell leicht verstehen müssen
• Berichtskonsumenten müssen verstehen, was wir in den Visualisierungen zeigen, ohne viel Interpretationsspielraum.

Letztendlich müssen wir beide Benutzergruppen unterstützen, wenn wir ein semantisches Modell erstellen.

Im abschließenden Abschnitt unten finden Sie meine wichtigste Richtlinie beim Entwerfen eines semantischen Modells.

Aber sehen wir uns zunächst die Auswirkungen der beiden Ansätze für unsere Benutzer an.

Verwendung von Matrixvisualisierungen

Zuerst habe ich eine Matrix erstellt.

Die Matrix sollte die Kalenderhierarchie als Zeilen und die Kennzahlen für On-line-Verkäufe, PY und PM in den Spalten enthalten.

Außerdem möchte ich die Ergebnisse nach Marke aufschlüsseln.

Zuerst habe ich es mit Berechnungselementen gemacht:

Das Ergebnis entspricht den Anforderungen.

Beachten Sie, dass ich die Berechnungselemente filtern muss, um das PY-Ingredient (Woche) auszuschließen, da es bei Verwendung mit Quartalen und Monaten zu einem Fehler führen würde.

Als nächstes habe ich es mit expliziten Maßnahmen gemacht:

Wie Sie sehen, sind die Ergebnisse identisch.

Beachten Sie jedoch, dass in der ersten Spalte der Identify der Kennzahl anstelle des Namens des Berechnungselements angezeigt wird, wie Sie im ersten Screenshot sehen können.

Mit Express Measures kann ich den im Bild angezeigten Namen ändern. Beispielsweise haben die Kennzahlen für PY und PM einen unterschiedlichen Namen:

Dies ist bei Verwendung von Berechnungselementen nicht möglich. Die Visuals zeigen immer die Namen der Berechnungselemente an und ich kann sie nicht umbenennen.

Ich sehe nicht einmal den Namen der ursprünglichen Maßnahme.

Daher muss ich dem Visible einen aussagekräftigen Titel hinzufügen. Ich empfehle aber trotzdem, dies zu tun.

Verwendung anderer Visualisierungstypen (Spalten oder Balken)

Als nächstes habe ich es mit Spaltenvisualisierungen gemacht:

Das obere Visible verwendet die Berechnungselemente und das untere Visible enthält die expliziten Kennzahlen.

Hier haben wir die gleiche State of affairs wie zuvor:

• Ich muss einen Filter für die Berechnungselemente für das obere Bild hinzufügen.
• Ich kann die Kennzahlen im unteren Bild umbenennen.

Aber die Ergebnisse sind immer noch die gleichen.

Ich habe die Standardposition für Titel und Legende beibehalten. Sie sehen, dass sie geändert werden müssen, da sie doppelte Informationen enthalten. Darüber hinaus sieht man in der oberen Variante im Untertitel den Begriff „Zeitfunktion“, der für jeden Berichtskonsumenten bedeutungslos ist.

Abgesehen von den Titeln und Untertiteln sind die Unterschiede im Vergleich zum Matrixvisual sogar noch geringer.

Pivot-Tabellen in Excel

Schauen wir uns nun an, wie es in Excel-Pivot-Tabellen funktioniert:

Aber hier haben wir ein Drawback mit dem PY-Berechnungselement:

Was sich nicht ändert, ist die Notwendigkeit, die Berechnungselemente zu filtern, um nur die benötigten Elemente zu behalten:

Wie Sie sehen, ist die Spalte „PY“ leer, obwohl Daten für das Jahr 2022 vorliegen.

Als ich dies mit expliziten Maßnahmen versuchte, erhielt ich dieses Ergebnis:

Selbst bei expliziten Maßnahmen bleibt das PJ-Drawback bestehen.

Ich habe dann mithilfe der klassischen Zeitintelligenz eine PY-Kennzahl hinzugefügt, und es hat funktioniert, wie oben mit den grün hervorgehobenen Werten gezeigt.

Dies weist auf ein Drawback mit Excel und kalenderbasierter Zeitintelligenz hin.

Aber ich kann die Kennzahlnamen immer noch umbenennen, wie in Energy BI.

Daher gibt es keinen Unterschied zwischen den beiden Varianten.

Die Sicht des Benutzers – noch einmal

Wenn wir uns den Berichtskonsumenten ansehen, können wir dieselben Berichte erstellen, ohne einen Unterschied zu erkennen.

Zumindest für die einfachen Beispiele, die ich oben gezeigt habe.

Für den Berichtsdesigner ist das eine andere Geschichte.

Dieser Benutzertyp muss wissen, wie das Datenmodell und die Berechnungsgruppen verwendet werden.

Dies ist ein Hindernis für Self-Service-BI, bei dem Entwickler das Datenmodell zur Verfügung stellen und andere Benutzer ihre eigenen Berichte erstellen.

Eine gute Dokumentation zur Verwendung des Datenmodells sowie Schulungen und Schulungen sind unerlässlich, wenn nur Berechnungsgruppen verwendet werden, anstatt explizite Messungen anzubieten.

Aber wir stoßen beispielsweise an Grenzen, wenn wir versuchen, Daten nach einer nicht vorhandenen Kennzahl zu filtern, weil diese nur mit einem Berechnungselement verfügbar ist.

Gleiches gilt für Excel-Nutzer, die Excel-Berichte mit PivotTables auf Foundation des Semantic-Modells erstellen möchten.

Auch hier müssen wir ihnen beibringen, wie sie das Datenmodell richtig verwenden.

Dies ist viel einfacher, wenn wir alle notwendigen Maßnahmen konkretisieren und in intestine strukturierten Anzeigeordnern ablegen.

Die Benutzer können die benötigten Maßnahmen auswählen und mit ihnen arbeiten.

Abschluss

Wie Sie gesehen haben, kann die Erstellung expliziter Kennzahlen für den Berichtsdesigner, der mit unseren semantischen Modellen arbeitet, von Vorteil sein.

Meine Richtlinie bei der Erstellung semantischer Modelle ist folgende:

Die Bedürfnisse des Benutzers stehen an erster Stelle.
Technische Gründe stehen immer an zweiter Stelle.
Kein technischer Gewinn überwiegt die Benutzerfreundlichkeit und Verständlichkeit der Ausgabe.

Jetzt sind Sie an der Reihe.

Was sind Ihre Richtlinien bei der Erstellung eines semantischen Modells?

Was ist Ihre wichtigste Überlegung während der Entwurfsphase?

Referenzen

Der SQLBI-Artikeldas UDF- und Berechnungsgruppen vergleicht und zeigt, wie sie kombiniert werden.

Und hier ist das Video zu diesem Artikel:

Hier das Video von Guys in a Dice zum gleichen Thema mit einer etwas anderen Sichtweise:

Wie in meinen vorherigen Artikeln verwende ich den Contoso-Beispieldatensatz. Sie können den ContosoRetailDW-Datensatz kostenlos von Microsoft herunterladen Hier.

Die Contoso-Daten können wie beschrieben unter der MIT-Lizenz frei verwendet werden in diesem Dokument. Ich habe den Datensatz aktualisiert, um die Daten auf aktuelle Daten zu übertragen, und alle für dieses Beispiel nicht benötigten Tabellen entfernt.

Bild vom Autor

# Einführung

Wenn Sie mit Daten in Python gearbeitet haben, haben Sie es mit ziemlicher Sicherheit verwendet Pandas. Seit über einem Jahrzehnt ist sie die Anlaufstelle für Datenmanipulation. Aber vor kurzem, Polaren hat ernsthaft an Bedeutung gewonnen. Polars verspricht schneller, speichereffizienter und intuitiver zu sein als Pandas. Aber lohnt es sich, es zu lernen? Und wie unterschiedlich ist es wirklich?

In diesem Artikel vergleichen wir Pandas und Eisbären nebeneinander. Sie sehen Leistungsbenchmarks und lernen die Syntaxunterschiede kennen. Am Ende können Sie eine fundierte Entscheidung für Ihr nächstes Datenprojekt treffen.

Den Code finden Sie auf GitHub.

# Erste Schritte

Lassen Sie uns zuerst beide Bibliotheken installieren:

pip set up pandas polars

Notiz: Dieser Artikel verwendet Pandas 2.2.2 und Polars 1.31.0.

Für diesen Vergleich verwenden wir auch einen Datensatz, der groß genug ist, um echte Leistungsunterschiede zu erkennen. Wir werden verwenden Schwindler So generieren Sie Testdaten:

Jetzt können wir mit dem Codieren beginnen.

# Messen der Geschwindigkeit durch Lesen großer CSV-Dateien

Beginnen wir mit einem der häufigsten Vorgänge: dem Lesen einer CSV-Datei. Wir erstellen einen Datensatz mit 1 Million Zeilen, um echte Leistungsunterschiede zu sehen.

Lassen Sie uns zunächst unsere Beispieldaten generieren:

import pandas as pd
from faker import Faker
import random

# Generate a big CSV file for testing
pretend = Faker()
Faker.seed(42)
random.seed(42)

information = {
    'user_id': vary(1000000),
    'title': (pretend.title() for _ in vary(1000000)),
    'electronic mail': (pretend.electronic mail() for _ in vary(1000000)),
    'age': (random.randint(18, 80) for _ in vary(1000000)),
    'wage': (random.randint(30000, 150000) for _ in vary(1000000)),
    'division': (random.selection(('Engineering', 'Gross sales', 'Advertising and marketing', 'HR', 'Finance'))
                   for _ in vary(1000000))
}

df_temp = pd.DataFrame(information)
df_temp.to_csv('large_dataset.csv', index=False)
print("✓ Generated large_dataset.csv with 1M rows")

Dieser Code erstellt eine CSV-Datei mit realistischen Daten. Vergleichen wir nun die Lesegeschwindigkeiten:

import pandas as pd
import polars as pl
import time

# pandas: Learn CSV
begin = time.time()
df_pandas = pd.read_csv('large_dataset.csv')
pandas_time = time.time() - begin

# Polars: Learn CSV
begin = time.time()
df_polars = pl.read_csv('large_dataset.csv')
polars_time = time.time() - begin

print(f"Pandas learn time: {pandas_time:.2f} seconds")
print(f"Polars learn time: {polars_time:.2f} seconds")
print(f"Polars is {pandas_time/polars_time:.1f}x sooner")

Ausgabe beim Lesen der Beispiel-CSV:

Pandas learn time: 1.92 seconds
Polars learn time: 0.23 seconds
Polars is 8.2x sooner

Folgendes passiert: Wir messen, wie lange es dauert, bis jede Bibliothek dieselbe CSV-Datei liest. Während Pandas seinen traditionellen Single-Threaded-CSV-Reader verwendet, parallelisiert Polars das Lesen automatisch über mehrere CPU-Kerne hinweg. Wir berechnen den Beschleunigungsfaktor.

Auf den meisten Geräten werden Sie feststellen, dass Polars CSVs zwei- bis fünfmal schneller liest. Dieser Unterschied wird bei größeren Dateien noch deutlicher.

# Messen der Speichernutzung während des Betriebs

Geschwindigkeit ist nicht die einzige Überlegung. Sehen wir uns an, wie viel Speicher jede Bibliothek verbraucht. Wir führen eine Reihe von Vorgängen durch und messen den Speicherverbrauch. Bitte pip set up psutil falls Sie es noch nicht in Ihrer Arbeitsumgebung haben:

import pandas as pd
import polars as pl
import psutil
import os
import gc # Import rubbish collector for higher reminiscence launch makes an attempt

def get_memory_usage():
    """Get present course of reminiscence utilization in MB"""
    course of = psutil.Course of(os.getpid())
    return course of.memory_info().rss / 1024 / 1024

# — - Check with Pandas — -
gc.gather()
initial_memory_pandas = get_memory_usage()

df_pandas = pd.read_csv('large_dataset.csv')
filtered_pandas = df_pandas(df_pandas('age') > 30)
grouped_pandas = filtered_pandas.groupby('division')('wage').imply()

pandas_memory = get_memory_usage() - initial_memory_pandas
print(f"Pandas reminiscence delta: {pandas_memory:.1f} MB")

del df_pandas, filtered_pandas, grouped_pandas
gc.gather()

# — - Check with Polars (keen mode) — -
gc.gather()
initial_memory_polars = get_memory_usage()

df_polars = pl.read_csv('large_dataset.csv')
filtered_polars = df_polars.filter(pl.col('age') > 30)
grouped_polars = filtered_polars.group_by('division').agg(pl.col('wage').imply())

polars_memory = get_memory_usage() - initial_memory_polars
print(f"Polars reminiscence delta: {polars_memory:.1f} MB")

del df_polars, filtered_polars, grouped_polars
gc.gather()

# — - Abstract — -
if pandas_memory > 0 and polars_memory > 0:
  print(f"Reminiscence financial savings (Polars vs Pandas): {(1 - polars_memory/pandas_memory) * 100:.1f}%")
elif pandas_memory == 0 and polars_memory > 0:
  print(f"Polars used {polars_memory:.1f} MB whereas Pandas used 0 MB.")
elif polars_memory == 0 and pandas_memory > 0:
  print(f"Polars used 0 MB whereas Pandas used {pandas_memory:.1f} MB.")
else:
  print("Can not compute reminiscence financial savings as a consequence of zero or unfavorable reminiscence utilization delta in each frameworks.")

Dieser Code misst den Speicherbedarf:

1. Wir nutzen die psutil-Bibliothek um die Speichernutzung vor und nach Vorgängen zu verfolgen
2. Beide Bibliotheken lesen dieselbe Datei und führen Filterung und Gruppierung durch
3. Wir berechnen den Unterschied im Speicherverbrauch

Beispielausgabe:

Pandas reminiscence delta: 44.4 MB
Polars reminiscence delta: 1.3 MB
Reminiscence financial savings (Polars vs Pandas): 97.1%

Die obigen Ergebnisse zeigen das Speichernutzungsdelta für Pandas und Polars, wenn Filter- und Aggregationsvorgänge für durchgeführt werden large_dataset.csv.

• Pandas Speicherdelta: Gibt den von Pandas für die Vorgänge verbrauchten Speicher an.
• Polarspeicher-Delta: Gibt den von Polars für dieselben Vorgänge verbrauchten Speicher an.
• Speichereinsparungen (Polaren vs. Pandas): Diese Metrik gibt einen Prozentsatz an, wie viel weniger Speicher Polars im Vergleich zu Pandas verbrauchten.

Aufgrund der spaltenorientierten Datenspeicherung und der optimierten Ausführungs-Engine weist Polars häufig Speichereffizienz auf. Normalerweise werden Sie durch die Verwendung von Polars eine Verbesserung von 30 bis 70 % feststellen.

Notiz: Allerdings werden sequentielle Speichermessungen innerhalb desselben Python-Prozesses verwendet psutil.Course of(...).memory_info().rss kann manchmal irreführend sein. Der Speicherzuweiser von Python gibt Speicher nicht immer sofort an das Betriebssystem zurück, sodass eine „bereinigte“ Basislinie für einen nachfolgenden Check möglicherweise immer noch von früheren Vorgängen beeinflusst wird. Für möglichst genaue Vergleiche sollten Assessments idealerweise in separaten, isolierten Python-Prozessen ausgeführt werden.

# Vergleich der Syntax für grundlegende Operationen

Schauen wir uns nun an, wie sich die Syntax zwischen den beiden Bibliotheken unterscheidet. Wir behandeln die häufigsten Vorgänge, die Sie verwenden werden.

// Spalten auswählen

Wählen wir eine Teilmenge von Spalten aus. Wir erstellen hierfür (und für die folgenden Beispiele) einen viel kleineren DataFrame.

import pandas as pd
import polars as pl

# Create pattern information
information = {
    'title': ('Anna', 'Betty', 'Cathy'),
    'age': (25, 30, 35),
    'wage': (50000, 60000, 70000)
}

# Pandas strategy
df_pandas = pd.DataFrame(information)
result_pandas = df_pandas(('title', 'wage'))

# Polars strategy
df_polars = pl.DataFrame(information)
result_polars = df_polars.choose(('title', 'wage'))
# Different: Extra expressive
result_polars_alt = df_polars.choose((pl.col('title'), pl.col('wage')))

print("Pandas consequence:")
print(result_pandas)
print("nPolars consequence:")
print(result_polars)

Die wichtigsten Unterschiede hier:

• Pandas verwendet die Klammernotation: df(('col1', 'col2'))
• Polars verwendet die .choose() Verfahren
• Polars unterstützt auch das Ausdrucksstärkere pl.col() Syntax, die für komplexe Operationen leistungsstark ist

Ausgabe:

Pandas consequence:
    title  wage
0   Anna   50000
1  Betty   60000
2  Cathy   70000

Polars consequence:
form: (3, 2)
┌───────┬────────┐
│ title  ┆ wage │
│ — -   ┆ — -    │
│ str   ┆ i64    │
╞═══════╪════════╡
│ Anna  ┆ 50000  │
│ Betty ┆ 60000  │
│ Cathy ┆ 70000  │
└───────┴────────┘

Beide erzeugen die gleiche Ausgabe, aber die Syntax von Polars beschreibt deutlicher, was Sie tun.

// Zeilen filtern

Jetzt filtern wir die Zeilen:

# pandas: Filter rows the place age > 28
filtered_pandas = df_pandas(df_pandas('age') > 28)

# Different Pandas syntax with question
filtered_pandas_alt = df_pandas.question('age > 28')

# Polars: Filter rows the place age > 28
filtered_polars = df_polars.filter(pl.col('age') > 28)

print("Pandas filtered:")
print(filtered_pandas)
print("nPolars filtered:")
print(filtered_polars)

Beachten Sie die Unterschiede:

• In Pandas verwenden wir die boolesche Indizierung mit Klammernotation. Sie können auch die verwenden .question() Verfahren.
• Polars verwendet die .filter() Methode mit pl.col() Ausdrücke.
• Die Syntax von Polars liest sich eher wie SQL: „Filtern, wenn das Spaltenalter größer als 28 ist“.

Ausgabe:

Pandas filtered:
    title  age  wage
1  Betty   30   60000
2  Cathy   35   70000

Polars filtered:
form: (2, 3)
┌───────┬─────┬────────┐
│ title  ┆ age ┆ wage │
│ — -   ┆ — - ┆ — -    │
│ str   ┆ i64 ┆ i64    │
╞═══════╪═════╪════════╡
│ Betty ┆ 30  ┆ 60000  │
│ Cathy ┆ 35  ┆ 70000  │
└───────┴─────┴────────┘

// Neue Spalten hinzufügen

Jetzt fügen wir dem DataFrame neue Spalten hinzu:

# pandas: Add a brand new column
df_pandas('bonus') = df_pandas('wage') * 0.1
df_pandas('total_comp') = df_pandas('wage') + df_pandas('bonus')

# Polars: Add new columns
df_polars = df_polars.with_columns((
    (pl.col('wage') * 0.1).alias('bonus'),
    (pl.col('wage') * 1.1).alias('total_comp')
))

print("Pandas with new columns:")
print(df_pandas)
print("nPolars with new columns:")
print(df_polars)

Ausgabe:

Pandas with new columns:
    title  age  wage   bonus  total_comp
0   Anna   25   50000  5000.0     55000.0
1  Betty   30   60000  6000.0     66000.0
2  Cathy   35   70000  7000.0     77000.0

Polars with new columns:
form: (3, 5)
┌───────┬─────┬────────┬────────┬────────────┐
│ title  ┆ age ┆ wage ┆ bonus  ┆ total_comp │
│ — -   ┆ — - ┆ — -    ┆ — -    ┆ — -        │
│ str   ┆ i64 ┆ i64    ┆ f64    ┆ f64        │
╞═══════╪═════╪════════╪════════╪════════════╡
│ Anna  ┆ 25  ┆ 50000  ┆ 5000.0 ┆ 55000.0    │
│ Betty ┆ 30  ┆ 60000  ┆ 6000.0 ┆ 66000.0    │
│ Cathy ┆ 35  ┆ 70000  ┆ 7000.0 ┆ 77000.0    │
└───────┴─────┴────────┴────────┴────────────┘

Folgendes passiert:

• Pandas verwendet die direkte Spaltenzuweisung, die den vorhandenen DataFrame ändert
• Polars verwendet .with_columns() und gibt einen neuen DataFrame zurück (standardmäßig unveränderlich)
• In Polars verwenden Sie .alias() um die neue Spalte zu benennen

Der Polars-Ansatz fördert die Unveränderlichkeit und macht Datentransformationen lesbarer.

# Messen der Leistung beim Gruppieren und Aggregieren

Schauen wir uns ein nützlicheres Beispiel an: das Gruppieren von Daten und das Berechnen mehrerer Aggregationen. Dieser Code zeigt, wie wir Daten nach Abteilung gruppieren, mehrere Statistiken für verschiedene Spalten berechnen und beide Vorgänge zeitlich festlegen, um den Leistungsunterschied zu erkennen:

# Load our giant dataset
df_pandas = pd.read_csv('large_dataset.csv')
df_polars = pl.read_csv('large_dataset.csv')

# pandas: Group by division and calculate stats
import time

begin = time.time()
result_pandas = df_pandas.groupby('division').agg({
    'wage': ('imply', 'median', 'std'),
    'age': 'imply'
}).reset_index()
result_pandas.columns = ('division', 'avg_salary', 'median_salary', 'std_salary', 'avg_age')
pandas_time = time.time() - begin

# Polars: Identical operation
begin = time.time()
result_polars = df_polars.group_by('division').agg((
    pl.col('wage').imply().alias('avg_salary'),
    pl.col('wage').median().alias('median_salary'),
    pl.col('wage').std().alias('std_salary'),
    pl.col('age').imply().alias('avg_age')
))
polars_time = time.time() - begin

print(f"Pandas time: {pandas_time:.3f}s")
print(f"Polars time: {polars_time:.3f}s")
print(f"Speedup: {pandas_time/polars_time:.1f}x")
print("nPandas consequence:")
print(result_pandas)
print("nPolars consequence:")
print(result_polars)

Ausgabe:

Pandas time: 0.126s
Polars time: 0.077s
Speedup: 1.6x

Pandas consequence:
    division    avg_salary  median_salary    std_salary    avg_age
0  Engineering  89954.929266        89919.0  34595.585863  48.953405
1      Finance  89898.829762        89817.0  34648.373383  49.006690
2           HR  90080.629637        90177.0  34692.117761  48.979005
3    Advertising and marketing  90071.721095        90154.0  34625.095386  49.085454
4        Gross sales  89980.433386        90065.5  34634.974505  49.003168

Polars consequence:
form: (5, 5)
┌─────────────┬──────────────┬───────────────┬──────────────┬───────────┐
│ division  ┆ avg_salary   ┆ median_salary ┆ std_salary   ┆ avg_age   │
│ — -         ┆ — -          ┆ — -           ┆ — -          ┆ — -       │
│ str         ┆ f64          ┆ f64           ┆ f64          ┆ f64       │
╞═════════════╪══════════════╪═══════════════╪══════════════╪═══════════╡
│ HR          ┆ 90080.629637 ┆ 90177.0       ┆ 34692.117761 ┆ 48.979005 │
│ Gross sales       ┆ 89980.433386 ┆ 90065.5       ┆ 34634.974505 ┆ 49.003168 │
│ Engineering ┆ 89954.929266 ┆ 89919.0       ┆ 34595.585863 ┆ 48.953405 │
│ Advertising and marketing   ┆ 90071.721095 ┆ 90154.0       ┆ 34625.095386 ┆ 49.085454 │
│ Finance     ┆ 89898.829762 ┆ 89817.0       ┆ 34648.373383 ┆ 49.00669  │
└─────────────┴──────────────┴───────────────┴──────────────┴───────────┘

Aufschlüsselung der Syntax:

• Pandas verwendet ein Wörterbuch, um Aggregationen anzugeben, was bei komplexen Vorgängen verwirrend sein kann
• Polars verwendet Methodenverkettung: Jede Operation ist klar und benannt

Die Polars-Syntax ist ausführlicher, aber auch besser lesbar. Sie können sofort sehen, welche Statistiken berechnet werden.

# Verstehen der verzögerten Auswertung bei Polaren

Die verzögerte Auswertung ist eine der hilfreichsten Funktionen von Polars. Das heisst Ihre Abfrage wird nicht sofort ausgeführt. Stattdessen wird der gesamte Vorgang geplant und vor der Ausführung optimiert.

Sehen wir uns das in Aktion an:

import polars as pl

# Learn in lazy mode
df_lazy = pl.scan_csv('large_dataset.csv')

# Construct a posh question
consequence = (
    df_lazy
    .filter(pl.col('age') > 30)
    .filter(pl.col('wage') > 50000)
    .group_by('division')
    .agg((
        pl.col('wage').imply().alias('avg_salary'),
        pl.len().alias('employee_count')
    ))
    .filter(pl.col('employee_count') > 1000)
    .kind('avg_salary', descending=True)
)

# Nothing has been executed but!
print("Question plan created, however not executed")

# Now execute the optimized question
import time
begin = time.time()
result_df = consequence.gather()  # This runs the question
execution_time = time.time() - begin

print(f"nExecution time: {execution_time:.3f}s")
print(result_df)

Ausgabe:

Question plan created, however not executed

Execution time: 0.177s
form: (5, 3)
┌─────────────┬───────────────┬────────────────┐
│ division  ┆ avg_salary    ┆ employee_count │
│ — -         ┆ — -           ┆ — -            │
│ str         ┆ f64           ┆ u32            │
╞═════════════╪═══════════════╪════════════════╡
│ HR          ┆ 100101.595816 ┆ 132212         │
│ Advertising and marketing   ┆ 100054.012365 ┆ 132470         │
│ Gross sales       ┆ 100041.01049  ┆ 132035         │
│ Finance     ┆ 99956.527217  ┆ 132143         │
│ Engineering ┆ 99946.725458  ┆ 132384         │
└─────────────┴───────────────┴────────────────┘

Hier, scan_csv() lädt die Datei nicht sofort; es ist nur geplant, es zu lesen. Wir verketten mehrere Filter, Gruppierungen und Sortierungen. Polars analysiert die gesamte Abfrage und optimiert sie. Es könnte beispielsweise vor dem Lesen aller Daten gefiltert werden.

Nur wenn wir anrufen .gather() findet die eigentliche Berechnung statt? Die optimierte Abfrage wird viel schneller ausgeführt, als wenn jeder Schritt einzeln ausgeführt würde.

# Zusammenfassung

Wie man sieht, ist Polars für die Datenverarbeitung mit Python äußerst nützlich. Es ist schneller, speichereffizienter und verfügt über eine sauberere API als Pandas. Das heißt, Pandas gehen nirgendwo hin. Es hat über ein Jahrzehnt Entwicklungszeit, ein riesiges Ökosystem und Millionen von Benutzern. Für viele Projekte ist Pandas immer noch die richtige Wahl.

Lernen Sie Polars, wenn Sie groß angelegte Analysen für Knowledge-Engineering-Projekte und dergleichen in Betracht ziehen. Die Syntaxunterschiede sind nicht groß und die Leistungssteigerungen sind actual. Behalten Sie jedoch Pandas in Ihrem Toolkit, um Kompatibilität und schnelle Erkundungsarbeiten zu gewährleisten.

Probieren Sie Polars zunächst in einem Nebenprojekt oder einer Datenpipeline aus, die langsam läuft. Sie werden schnell ein Gefühl dafür bekommen, ob es für Ihren Anwendungsfall das Richtige ist. Viel Spaß beim Daten-Wrangeln!

Bala Priya C ist ein Entwickler und technischer Redakteur aus Indien. Sie arbeitet gerne an der Schnittstelle von Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Zu ihren Interessen- und Fachgebieten gehören DevOps, Datenwissenschaft und Verarbeitung natürlicher Sprache. Sie liebt es zu lesen, zu schreiben, zu programmieren und Kaffee zu trinken! Derzeit arbeitet sie daran, zu lernen und ihr Wissen mit der Entwickler-Neighborhood zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt außerdem ansprechende Ressourcenübersichten und Programmier-Tutorials.

In den heutigen hybriden und verteilten Arbeitsumgebungen suchen viele Unternehmen nach erschwinglichen verwalteten IT-Diensten für Distant-Groups in Denver, die verteilte Mitarbeiter zuverlässig unterstützen können, ohne das Finances zu sprengen. Unabhängig davon, ob Sie ein Startup mit Distant-Mitarbeitern oder ein mittelständisches Unternehmen leiten, das hybrides Arbeiten unterstützt, ist die Wahl des richtigen Managed Service Suppliers (MSP) von entscheidender Bedeutung für die Netzwerkstabilität, Sicherheit und Produktivität.

Hier ist eine Liste einiger der relevantesten und kosteneffizientesten Managed-IT-Service-Anbieter in Denver, die Sie in Betracht ziehen sollten, wenn Sie erschwingliche Managed-IT-Companies für Distant-Groups in Denver suchen, die hochwertigen Assist mit skalierbaren Preisen kombinieren.

1. Datenprise

Datenprise bietet umfassende, KI-gestützte verwaltete IT-Lösungen, die darauf ausgelegt sind, Distant-Groups produktiv, sicher und belastbar zu halten. Mit vollständig verwalteten und gemeinsam verwalteten Optionen stellt das Unternehmen sicher, dass Unternehmen jeder Größe das richtige Maß an IT-Unterstützung erhalten, um ihren Anforderungen gerecht zu werden, sei es eine All-in-One-Lösung für kleinere Groups oder skalierbares Fachwissen für größere Umgebungen. Die KI-Integration ist für den Betrieb von zentraler Bedeutung, da sie Routineaufgaben automatisiert, potenzielle Probleme proaktiv erkennt und Ausfallzeiten minimiert, um eine nahtlose Geschäftskontinuität aufrechtzuerhalten.

Der Ansatz des Unternehmens legt Wert auf personalisierten, proaktiven Assist, der die Technologie mit den Unternehmenszielen in Einklang bringt. Verwaltete Cybersicherheit, Cloud-Administration, Notfallwiederherstellung und Mobilgerätemanagement sind alle in das IT-Portfolio des Unternehmens integriert und bieten Unternehmen mit Sitz in Denver robusten Schutz und betriebliche Effizienz. Dedizierte Account-Groups arbeiten mit Kunden zusammen, um maßgeschneiderte Lösungen zu entwickeln, die die internen IT-Fähigkeiten stärken und das Wachstum unterstützen, ohne zusätzliche Komplexität oder Mehraufwand.

Dataprise wurde 1995 gegründet und verbindet nationale Anerkennung mit lokaler Experience und betreut Tausende von Kunden durch ein Staff zertifizierter Ingenieure und IT-Spezialisten. Seine Angebote ermöglichen Distant- und Hybrid-Arbeitskräften ein reibungsloses Funktionieren, reduzieren IT-bedingte Störungen und optimieren Technologieinvestitionen. Für Unternehmen in Denver, die erschwingliche verwaltete IT-Dienste für Distant-Groups suchen, bietet Dataprise strategische, vollständig integrierte IT-Lösungen, die Kosten, Leistung und Sicherheit in Einklang bringen.

2. Aufstiegstechnologie

Aufstiegstechnologie bietet verwaltete IT-Dienste für kleine und mittlere Unternehmen in Denver und unterstützt sowohl Vor-Ort- als auch Distant-Mitarbeiter. Das 2002 gegründete Unternehmen konzentriert sich auf praktische, kostengünstige Lösungen zur Steigerung der Unternehmensleistung. Zu den Dienstleistungen gehören Notfallsupport, {Hardware}- und Software program-Setup, Netzwerk- und Bürokonfiguration, Cloud- und Cybersicherheit, Backup und Catastrophe Restoration sowie Fernzugriff, bereitgestellt durch eine Mischung aus internen Experten und angeschlossenen Spezialisten.

Der Ansatz des Unternehmens legt Wert auf Reaktionsfähigkeit und Integration in die Abläufe der Kunden. Das Staff geht umgehend auf IT-Herausforderungen ein und sorgt dafür, dass Unternehmen ohne Unterbrechung weiterarbeiten können. Über die Problemlösung hinaus bietet Ascension Expertise strategische Beratung zu Technologieinvestitionen und -optimierung und hilft Groups dabei, fundierte Entscheidungen zu treffen und gleichzeitig die Budgetkontrolle zu behalten. Mit Kenntnissen über Home windows-, Apple-, Linux-, Citrix-, Unix- und Netzwerksicherheitsplattformen versetzt es Unternehmen in die Lage, sowohl routinemäßige Wartungsarbeiten als auch komplexe technische Projekte in Angriff zu nehmen.

Ascension Expertise priorisiert auch die Bedürfnisse einer dezentralen und verteilten Belegschaft und ermöglicht eine nahtlose Zusammenarbeit und Konnektivität über mehrere Standorte hinweg. Regelmäßige Überwachung und proaktive Verwaltung von Netzwerken und Endpunkten tragen dazu bei, Ausfallzeiten zu reduzieren, die Sicherheit zu stärken und die Produktivität zu steigern. Durch die Kombination von technischem Fachwissen, praktischem Assist und kundenorientiertem Service ermöglicht Ascension Expertise Unternehmen in Denver, Abläufe zu rationalisieren, IT-Investitionen zu optimieren und eine zukunftsfähige Technologieumgebung aufrechtzuerhalten.

3. Anspruchsvolle Technologien

Anspruchsvolle Technologien bietet Unternehmen in Denver praktische, maßgeschneiderte IT-Lösungen, die Distant- und Hybridteams produktiv und sicher halten. Mit flexiblen Angeboten, die vollständig verwaltete und gemeinsam verwaltete IT-Dienste umfassen, konzentriert sich Exigent auf die Rationalisierung von Technologieabläufen bei gleichzeitiger Reduzierung von Unterbrechungen. Sein proaktiver Ansatz kombiniert kontinuierliche Überwachung, Netzwerkunterstützung und Cybersicherheit, um sicherzustellen, dass die Systeme stabil und reaktionsfähig bleiben und internen Groups die Möglichkeit geben, sich auf strategische Prioritäten zu konzentrieren, anstatt sich mit der Bekämpfung von IT-Problemen zu befassen.

Seit seiner Gründung im Jahr 1997 hat sich Exigent zu einem vertrauenswürdigen nationalen MSP mit einer starken Präsenz in Colorado entwickelt und unterstützt Unternehmen mit lokalen Vor-Ort-Leistungen in ganz Denver und den umliegenden Landkreisen. Die Dienstleistungen des Unternehmens umfassen Cloud Computing, Catastrophe Restoration, Enterprise Continuity, Microsoft 365- und Azure-Integration sowie spezielle Cybersicherheitsmaßnahmen. Durch die Integration der Technologieplanung mit den Geschäftszielen erstellt Exigent IT-Roadmaps, die sowohl unmittelbare betriebliche Anforderungen als auch langfristiges Wachstum berücksichtigen und Unternehmen dabei helfen, effizient und ohne übermäßigen Overhead zu skalieren.

Zusammenarbeit ist ein zentraler Bestandteil des Servicemodells von Exigent. Jeder Kunde erhält einen engagierten technischen Berater und ein kleines, vertrautes Staff, das sein Umfeld, seine Ziele und branchenspezifischen Anforderungen versteht. Diese personalisierte Partnerschaft gewährleistet reaktionsschnellen Assist, effektive Problemlösung und maßgeschneiderte Beratung. Für Organisationen in Denver, die nach erschwinglichen verwalteten IT-Diensten für Distant-Groups suchen, bietet Exigent Applied sciences zuverlässige, strategische und skalierbare IT-Managementlösungen, die auf betriebliche Kontinuität und nachhaltiges Wachstum ausgelegt sind.

4. Roter Fluss

Roter Fluss bietet maßgeschneiderte IT-Managementlösungen für Unternehmen in Denver und hilft Distant- und Hybridteams dabei, sicher und effizient zu arbeiten. Mit umfassenden Companies, die Cloud-Migration, verwaltete Cybersicherheit, Netzwerkinfrastruktur und 24/7-Helpdesk-Assist umfassen, konzentriert sich Purple River darauf, den reibungslosen Betrieb der Technologie zu gewährleisten und gleichzeitig Unternehmen in die Lage zu versetzen, strategische Initiativen zu priorisieren. Durch die Kombination von proaktiver Überwachung, routinemäßiger Wartung und fortschrittlichen Berichtstools stellt Purple River sicher, dass potenzielle IT-Störungen behoben werden, bevor sie sich auf den Betrieb auswirken, und optimiert so die Leistung und Produktivität verteilter Groups.

Purple River wurde 1995 gegründet und integriert Fachwissen aus mehreren Branchen, um skalierbare IT-Lösungen bereitzustellen, die auf die Ziele jedes Unternehmens abgestimmt sind. Zu den Dienstleistungen gehören Microsoft 365- und Azure-Assist, Cloud- und Infrastrukturmanagement, Datensicherung und -wiederherstellung sowie vollständige Abdeckung der Cybersicherheit. Durch die Verknüpfung von Technologiestrategie und Geschäftsplanung hilft Purple River Unternehmen in Denver, ihr Wachstum zu steuern, Kosten zu senken und die Einhaltung gesetzlicher Vorschriften aufrechtzuerhalten. Der versatile Ansatz ermöglicht es Unternehmen, IT-Ressourcen effizient zu skalieren, interne Groups durch zertifizierte Experten zu ergänzen und durch Echtzeitdaten und -analysen umsetzbare Erkenntnisse zu gewinnen.

Zusammenarbeit und Zugänglichkeit sind für das Modell von Purple River von zentraler Bedeutung. Jeder Kunde arbeitet mit einem engagierten technischen Staff zusammen, das seine individuelle Umgebung und seine betrieblichen Anforderungen versteht und personalisierten Assist bietet, der über die reaktive Fehlerbehebung hinausgeht. Die Marke kombiniert strategische Planung, reaktionsschnellen Assist und modernste Technologie, um Stabilität, Sicherheit und langfristigen operativen Erfolg zu gewährleisten.

5. Techmate

Techmate bietet bedarfsgerechten IT-Assist für die Distant- und verteilten Mitarbeiter von Denver und kombiniert Vor-Ort-Companies mit intelligentem digitalem Administration. Zertifizierte Techniker kümmern sich um alles, von der routinemäßigen Wartung und Neuimaging des Desktops bis hin zur Netzwerk- und A/V-Einrichtung. Dank seiner Plattform können IT-Supervisor mehrere Büros überwachen, Anfragen verfolgen und Budgets effizient verwalten, während sie jede Aufgabe dem richtigen Experten zuordnen. Dieser Ansatz sorgt für schnellere Lösungszeiten und konsistenten Assist an allen Standorten.

Techmate unterstützt Unternehmen in ganz Denver und über 350 Städten im ganzen Land und legt Wert auf kostengünstige Lösungen, die die Abhängigkeit von traditionellen Auftragnehmern verringern. Mitgliedschaftsbasierte Preise und ein flexibles On-Demand-Servicemodell helfen Unternehmen dabei, ihre IT-Funktionen zu erweitern und gleichzeitig die Kontrolle über Ressourcen und Ausgaben zu behalten. Der strenge Überprüfungsprozess des Groups stellt sicher, dass nur die besten 5 % der Techniker dem Netzwerk beitreten, wodurch konsistenter, qualitativ hochwertiger Assist geboten wird und eine Problemlösungsrate von 97 % bei gleichzeitig hohen Kundenzufriedenheitswerten aufrechterhalten wird.

Techmate verbessert außerdem die strategische IT-Planung und Projektdurchführung, einschließlich Infrastrukturaktualisierungen und Cloud-Übergängen sowie Onboarding-/Offboarding-Unterstützung. Regelmäßige Besuche vor Ort fördern die Beziehungen zwischen IT-Groups und Mitarbeitern und identifizieren Möglichkeiten für proaktive Optimierung. Durch die Integration von technischem Fachwissen, betrieblicher Flexibilität und einem landesweiten Assist-Netzwerk ermöglicht Techmate Unternehmen in Denver, Ausfallzeiten zu reduzieren und die Cybersicherheit zu stärken.

Vergleich verwalteter IT-Companies

Auswahl des richtigen MSP für die Distant-Mitarbeiter in Denver

Produktions-LLM-Bereitstellung ist jetzt ein Systemproblem, kein Downside mehr generate() Schleife. Bei realen Workloads ist die Wahl des Inferenzstapels entscheidend Token professional Sekunde, Schwanzlatenzund letztendlich Kosten professional Million Token auf einer bestimmten GPU-Flotte.

Dieser Vergleich konzentriert sich auf 4 weit verbreitete Stacks:

• vLLM
• NVIDIA TensorRT-LLM
• Inferenz zur Generierung von Umarmungsgesichtstexten (TGI v3)
• LMDeploy

1. vLLM, PagedAttention als offene Baseline

Kernidee

vLLM ist darauf aufgebaut PagedAchtungeine Aufmerksamkeitsimplementierung, die den KV-Cache wie ausgelagerten virtuellen Speicher und nicht wie einen einzelnen zusammenhängenden Puffer professional Sequenz behandelt.

Anstatt professional Anfrage eine große KV-Area zuzuweisen, vLLM:

• Unterteilt den KV-Cache in Blöcke fester Größe
• Verwaltet eine Blocktabelle, die logische Token physischen Blöcken zuordnet
• Teilt Blöcke zwischen Sequenzen, wo immer sich Präfixe überschneiden

Dadurch wird die externe Fragmentierung reduziert und der Scheduler kann viel mehr gleichzeitige Sequenzen in denselben VRAM packen.

Durchsatz und Latenz

vLLM verbessert den Durchsatz um 2–4× gegenüber Systemen wie FasterTransformer und Orca bei ähnlicher Latenz, mit größeren Gewinnen für längere Sequenzen.

Wichtige Eigenschaften für Betreiber:

• Kontinuierliche Dosierung (auch Inflight-Batching genannt) führt eingehende Anfragen in bestehende GPU-Batches zusammen, anstatt auf feste Batch-Fenster zu warten.
• Bei typischen Chat-Workloads skaliert der Durchsatz nahezu linear mit der Parallelität, bis der KV-Speicher oder die Rechenleistung ausgelastet ist.
• Die P50-Latenz bleibt bei mäßiger Parallelität niedrig, aber P99 kann sich verschlechtern, wenn die Warteschlangen lang sind oder der KV-Speicher knapp ist, insbesondere bei Abfragen mit hohem Prefill-Gehalt.

vLLM macht eine verfügbar OpenAI-kompatible HTTP-API und lässt sich intestine mit Ray Serve und anderen Orchestratoren integrieren, weshalb es häufig als offene Basislinie verwendet wird.

KV und Multi-Tenant

• PagedAttention gibt Nahezu null KV-Abfall und versatile Präfixfreigabe innerhalb und zwischen Anfragen.
• Jeder vLLM-Prozess dient ein ModellMulti-Tenant- und Multi-Modell-Setups werden normalerweise mit einem externen Router oder API-Gateway erstellt, der auf mehrere vLLM-Instanzen verteilt.

2. TensorRT-LLM, {Hardware}-Most auf NVIDIA-GPUs

Kernidee

TensorRT-LLM ist NVIDIAs optimierte Inferenzbibliothek für ihre GPUs. Die Bibliothek bietet benutzerdefinierte Aufmerksamkeitskerne, Inflight-Batching, ausgelagertes KV-Caching, Quantisierung bis hinunter zu FP4 und INT4 sowie spekulative Dekodierung.

Es ist eng mit NVIDIA-{Hardware} gekoppelt, einschließlich FP8-Tensorkernen auf Hopper und Blackwell.

Gemessene Leistung

Die H100 vs. A100-Bewertung von NVIDIA ist die konkretste öffentliche Referenz:

• Auf H100 mit FP8 erreicht TensorRT-LLM über 10.000 ausgegebene Token/s bei Spitzendurchsatz für 64 gleichzeitige Anfragenmit ~100 ms Zeit bis zum ersten Token.
• H100 FP8 erreicht bis zu 4,6-fach höherer maximaler Durchsatz Und 4,4-mal schnellere Latenz des ersten Tokens als A100 bei den gleichen Modellen.

Für latenzempfindliche Modi:

• TensorRT-LLM auf H100 kann TTFT steuern unter 10 ms in Batch-1-Konfigurationen, auf Kosten eines geringeren Gesamtdurchsatzes.

Diese Zahlen sind modell- und formspezifisch, geben aber einen realistischen Maßstab wieder.

Vorfüllen vs. Dekodieren

TensorRT-LLM optimiert beide Phasen:

• Prefill profitiert von FP8-Aufmerksamkeitskernen mit hohem Durchsatz und Tensorparallelität
• Dekodieren profitiert von CUDA-Graphen, spekulativer Dekodierung, quantisierten Gewichten und KV sowie der Kernel-Fusion

Das Ergebnis sind sehr hohe Tokens/s über einen weiten Bereich von Eingabe- und Ausgabelängen, insbesondere wenn die Engine auf dieses Modell und Batch-Profil abgestimmt ist.

KV und Multi-Tenant

TensorRT-LLM bietet:

• Ausgelagerter KV-Cache mit konfigurierbarem Structure
• Unterstützung für lange Sequenzen, KV-Wiederverwendung und Offloading
• Batch- und prioritätsbewusste Planungsprimitive während des Flugs

NVIDIA kombiniert dies mit Ray-basierten oder Triton-basierten Orchestrierungsmustern für Multi-Tenant-Cluster. Die Unterstützung mehrerer Modelle erfolgt auf Orchestratorebene und nicht innerhalb einer einzelnen TensorRT-LLM-Engine-Instanz.

3. Hugging Face TGI v3, Lengthy-Immediate-Spezialist und Multi-Backend-Gateway

Kernidee

Textgenerierungsinferenz (TGI) ist ein auf Rust und Python basierender Serving-Stack, der Folgendes hinzufügt:

• HTTP- und gRPC-APIs
• Kontinuierlicher Batch-Planer
• Observability- und Autoscaling-Hooks
• Plug-in-Backends, einschließlich Engines im vLLM-Stil, TensorRT-LLM und anderen Laufzeiten

Model 3 konzentriert sich auf die lange Verarbeitung von Eingabeaufforderungen Chunking und Präfix-Caching.

Langer Immediate-Benchmark vs. vLLM

Der TGI v3-Dokumente Geben Sie einen klaren Maßstab:

• Bei langen Eingabeaufforderungen mit mehr als 200.000 Tokeneine Konversationsantwort, die dauert 27,5 s im vLLM kann in ca. serviert werden 2 s in TGI v3.
• Dies wird als a gemeldet 13-fache Beschleunigung auf diese Arbeitsbelastung.
• TGI v3 kann ca. verarbeiten 3× mehr Token im gleichen GPU-Speicher durch Reduzierung des Speicherbedarfs und Nutzung von Chunking und Caching.

Der Mechanismus ist:

• TGI behält den ursprünglichen Konversationskontext bei Präfix-Cachesodass nachfolgende Runden nur für zusätzliche Spielsteine ​​auszahlen
• Der Aufwand für die Cache-Suche liegt in der Größenordnung von Mikrosekundenvernachlässigbar im Vergleich zur Vorfüllberechnung

Hierbei handelt es sich um eine gezielte Optimierung für Workloads, bei denen Eingabeaufforderungen extrem lang sind und über mehrere Runden hinweg wiederverwendet werden, beispielsweise RAG-Pipelines und analytische Zusammenfassungen.

Architektur und Latenzverhalten

Schlüsselkomponenten:

• ChunkingSehr lange Eingabeaufforderungen werden für KV und Planung in überschaubare Segmente aufgeteilt
• Präfix-CachingDatenstruktur, um langen Kontext über Runden hinweg zu teilen
• Kontinuierliche Dosierungeingehende Anfragen verbinden Stapel bereits laufender Sequenzen
• PagedAttention und verschmolzene Kernel in den GPU-Backends

Bei kurzen Workloads im Chat-Stil liegen Durchsatz und Latenz auf dem gleichen Niveau wie bei vLLM. Bei langen, zwischenspeicherbaren Kontexten verbessert sich sowohl die P50- als auch die P99-Latenz um eine Größenordnung, da die Engine wiederholtes Vorfüllen vermeidet.

Multi-Backend und Multi-Modell

TGI ist als konzipiert Router plus Modellserver Architektur. Es kann:

• Leiten Sie Anfragen über viele Modelle und Replikate hinweg weiter
• Zielen Sie auf verschiedene Backends ab, zum Beispiel TensorRT-LLM auf H100 plus CPU oder kleinere GPUs für Datenverkehr mit niedriger Priorität

Dadurch eignet es sich als zentrale Bereitstellungsschicht in Umgebungen mit mehreren Mandanten.

4. LMDeploy, TurboMind mit blockiertem KV und aggressiver Quantisierung

Kernidee

LMDeploy aus dem InternLM-Ökosystem ist ein Toolkit zum Komprimieren und Bereitstellen von LLMs, das sich auf das konzentriert TurboMind Motor. Es konzentriert sich auf:

• Anforderungsbereitstellung mit hohem Durchsatz
• Blockierter KV-Cache
• Persistentes Batching (kontinuierliches Batching)
• Quantisierung von Gewichten und KV-Cache

Relativer Durchsatz im Vergleich zu vLLM

Im Projekt heißt es:

• „LMDeploy bietet einen bis zu 1,8-mal höheren Anforderungsdurchsatz als vLLM.“‚, mit der Unterstützung von persistentem Batch, blockiertem KV, dynamischer Aufteilung und Sicherung, Tensorparallelität und optimierten CUDA-Kerneln.

KV, Quantisierung und Latenz

LMDeploy umfasst:

• Blockierter KV-Cacheähnlich wie bei ausgelagertem KV, das dabei hilft, viele Sequenzen in VRAM zu packen
• Unterstützung für KV-Cache-Quantisierungnormalerweise int8 oder int4, um KV-Speicher und Bandbreite zu reduzieren
• Gewichtet nur Quantisierungspfade wie 4-Bit-AWQ
• Ein Benchmarking-System, das Token-Durchsatz, Anforderungsdurchsatz und erste Token-Latenz meldet

Dies macht LMDeploy attraktiv, wenn Sie größere offene Modelle wie InternLM oder Qwen auf Mittelklasse-GPUs mit aggressiver Komprimierung ausführen und gleichzeitig gute Token/s beibehalten möchten.

Bereitstellung mehrerer Modelle

LMDeploy bietet eine Proxyserver kann damit umgehen:

• Bereitstellung mehrerer Modelle
• Multi-Maschinen- und Multi-GPU-Setups
• Routing-Logik zur Auswahl von Modellen basierend auf Anforderungsmetadaten

Architektonisch ähnelt es additionally eher dem TGI als einem Einzelmotor.

Was wann verwenden??

• Wenn Sie maximalen Durchsatz und sehr niedrige TTFT auf NVIDIA-GPUs wünschen
  • TensorRT-LLM ist die erste Wahl
  • Es verwendet FP8 und niedrigere Präzision, benutzerdefinierte Kernel und spekulative Dekodierung, um Token/s zu pushen und die TTFT bei hoher Parallelität unter 100 ms und bei niedriger Parallelität unter 10 ms zu halten
• Wenn Sie von langen Eingabeaufforderungen mit Wiederverwendung dominiert werden, z. B. RAG über große Kontexte
  • TGI v3 ist ein starker Normal
  • Sein Präfix-Cache und Chunking geben nach 3× Token-Kapazität Und 13-fach geringere Latenz als vLLM in veröffentlichten Lengthy-Immediate-Benchmarks, ohne zusätzliche Konfiguration
• Wenn Sie eine offene, einfache Engine mit starker Grundleistung und einer API im OpenAI-Stil wünschen
  • vLLM bleibt die Standardbasislinie
  • PagedAttention und kontinuierliches Batching machen es möglich 2–4× schneller als ältere Stacks mit ähnlicher Latenz und lässt sich problemlos in Ray und K8s integrieren
• Wenn Sie auf offene Modelle wie InternLM oder Qwen abzielen und Wert auf aggressive Quantisierung mit Multi-Modell-Bereitstellung legen
  • LMDeploy passt intestine
  • Blockierter KV-Cache, persistentes Batching und int8- oder int4-KV-Quantisierung geben bis zu 1,8-mal höherer Anforderungsdurchsatz als vLLM bei unterstützten Modellen, inklusive Router-Schicht

In der Praxis mischen viele Entwicklerteams diese Systeme und verwenden beispielsweise TensorRT-LLM für proprietäre Chats mit hohem Volumen, TGI v3 für Analysen mit langen Kontexten, vLLM oder LMDeploy für experimentelle und offene Modell-Workloads. Der Schlüssel besteht darin, den Durchsatz, die Latenzausfälle und das KV-Verhalten an die tatsächlichen Token-Verteilungen in Ihrem Datenverkehr anzupassen und dann die Kosten professional Million Token aus den gemessenen Token/s auf Ihrer eigenen {Hardware} zu berechnen.

Referenzen

1. vLLM / PagedAttention
2. TensorRT-LLM-Leistung und Übersicht
3. HF Textual content Era Inference (TGI v3) Verhalten bei langer Eingabeaufforderung
4. LMDeploy / TurboMind

Michal Sutter ist ein Knowledge-Science-Experte mit einem Grasp of Science in Knowledge Science von der Universität Padua. Mit einer soliden Grundlage in statistischer Analyse, maschinellem Lernen und Datentechnik ist Michal hervorragend darin, komplexe Datensätze in umsetzbare Erkenntnisse umzuwandeln.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.

Die optische Zeichenerkennung hat sich von der reinen Textextraktion zur Dokumentenintelligenz entwickelt. Moderne Systeme müssen gescannte und digitale PDFs in einem Durchgang lesen, das Format beibehalten, Tabellen erkennen, Schlüssel-Wert-Paare extrahieren und mit mehr als einer Sprache arbeiten. Viele Groups wünschen sich mittlerweile auch OCR, das RAG- und Agent-Pipelines direkt versorgen kann. Im Jahr 2025 decken 6 Systeme die meisten realen Arbeitslasten ab:

1. Google Cloud Doc AI, Enterprise Doc OCR
2. Amazon Textract
3. Microsoft Azure AI Doc Intelligence
4. ABBYY FineReader Engine und FlexiCapture
5. PaddleOCR 3.0
6. DeepSeek OCR, optische Kontextkomprimierung

Das Ziel dieses Vergleichs besteht nicht darin, sie anhand einer einzigen Metrik einzustufen, da sie auf unterschiedliche Einschränkungen abzielen. Das Ziel besteht darin, zu zeigen, welches System für ein bestimmtes Dokumentenvolumen, Bereitstellungsmodell, Sprachsatz und nachgelagerten KI-Stack verwendet werden soll.

Bewertungsdimensionen

Wir vergleichen 6 stabile Dimensionen:

1. Kern-OCR-Qualität auf gescannten, fotografierten und digitalen PDFs.
2. Format und Struktur Tabellen, Schlüssel-Wert-Paare, Auswahlmarkierungen, Lesereihenfolge.
3. Abdeckung von Sprache und Handschrift.
4. Bereitstellungsmodell vollständig verwaltet, Container, vor Ort, selbst gehostet.
5. Integration mit LLM-, RAG- und IDP-Instruments.
6. Kosten im Maßstab.

1. Google Cloud Doc AI, Enterprise Doc OCR

Googles Enterprise Doc OCR erfasst PDFs und Bilder, ob gescannt oder digital, und gibt Textual content mit Format, Tabellen, Schlüssel-Wert-Paaren und Auswahlmarkierungen zurück. Es ermöglicht außerdem die Handschrifterkennung in 50 Sprachen und kann Mathematik und Schriftarten erkennen. Dies ist wichtig für Finanzberichte, Bildungsformulare und Archive. Die Ausgabe erfolgt in strukturiertem JSON, das an Vertex AI oder ein beliebiges RAG-System gesendet werden kann.

Stärken

• Hochwertige OCR für Geschäftsdokumente.
• Starke Format-Grafik- und Tabellenerkennung.
• Eine Pipeline für digitale und gescannte PDFs, die die Aufnahme vereinfacht.
• Enterprise-Qualität mit IAM und Datenresidenz.

Grenzen

• Es handelt sich um einen kostenpflichtigen Google Cloud-Dienst.
• Benutzerdefinierte Dokumenttypen müssen weiterhin konfiguriert werden.

Verwenden Sie wann Ihre Daten befinden sich bereits in Google Cloud oder Sie müssen das Format für eine spätere LLM-Part beibehalten.

Textract bietet zwei API-Lanes, synchron für kleine Dokumente und asynchron für große mehrseitige PDFs. Es extrahiert Texte, Tabellen, Formulare und Signaturen und gibt sie als Blöcke mit Beziehungen zurück. AnalyzeDocument im Jahr 2025 kann auch Fragen über die Seite beantworten, was die Extraktion von Rechnungen oder Forderungen vereinfacht. Durch die Integration mit S3, Lambda und Step Features lässt sich Textract ganz einfach in eine Ingestion-Pipeline umwandeln.

Stärken

• Zuverlässige Tabellen- und Schlüsselwertextraktion für Quittungen, Rechnungen und Versicherungsformulare.
• Klares Synchronisierungs- und Stapelverarbeitungsmodell.
• Enge AWS-Integration, intestine für Serverless und IDP auf S3.

Grenzen

• Die Bildqualität wirkt sich sichtbar aus, daher müssen Kamera-Uploads möglicherweise vorverarbeitet werden.
• Die Anpassung ist eingeschränkter als bei benutzerdefinierten Azure-Modellen.
• An AWS gebunden.

Verwenden Sie wann Die Arbeitslast befindet sich bereits in AWS und Sie benötigen sofort einsatzbereites strukturiertes JSON.

3. Microsoft Azure AI Doc Intelligence

Der von Kind Recognizer umbenannte Dienst von Azure kombiniert OCR, generisches Format, vorgefertigte Modelle und benutzerdefinierte neuronale oder Vorlagenmodelle. Mit der Model 2025 wurden Format- und Lesecontainer hinzugefügt, sodass Unternehmen dasselbe Modell vor Ort ausführen können. Das Layoutmodell extrahiert Textual content, Tabellen, Auswahlmarkierungen und Dokumentstruktur und ist für die Weiterverarbeitung durch LLMs konzipiert.

Stärken

• Erstklassige benutzerdefinierte Dokumentmodelle für Branchenformulare.
• Container für Hybrid- und Air-Hole-Einsätze.
• Vorgefertigte Modelle für Rechnungen, Quittungen und Ausweisdokumente.
• Bereinigen Sie die JSON-Ausgabe.

Grenzen

• Die Genauigkeit einiger nicht-englischer Dokumente kann immer noch etwas hinter der von ABBYY zurückbleiben.
• Preise und Durchsatz müssen geplant werden, da es sich immer noch um ein Cloud-First-Produkt handelt.

Verwenden Sie wann Sie müssen dem System Ihre eigenen Vorlagen beibringen oder wenn Sie ein Microsoft-Store sind, der das gleiche Modell in Azure und vor Ort wünscht.

4. ABBYY FineReader Engine und FlexiCapture

ABBYY bleibt auch im Jahr 2025 aus drei Gründen related: Genauigkeit bei gedruckten Dokumenten, sehr breite Sprachabdeckung und umfassende Kontrolle über Vorverarbeitung und Zoneneinteilung. Die aktuellen Engine- und FlexiCapture-Produkte unterstützen 190 und mehr Sprachen, exportieren strukturierte Daten und können in Home windows-, Linux- und VM-Workloads eingebettet werden. ABBYY ist auch in regulierten Sektoren stark, in denen Daten das Betriebsgelände nicht verlassen dürfen.

Stärken

• Sehr hohe Erkennungsqualität bei gescannten Verträgen, Pässen, alten Dokumenten.
• Größter Sprachsatz in diesem Vergleich.
• FlexiCapture kann auf unordentliche, wiederkehrende Dokumente abgestimmt werden.
• Ausgereifte SDKs.

Grenzen

• Die Lizenzkosten sind höher als bei Open Supply.
• Auf Deep Studying basierender Szenentext steht nicht im Mittelpunkt.
• Die Skalierung auf Hunderte von Knoten erfordert Engineering.

Verwenden Sie wann Sie müssen lokal ausgeführt werden, viele Sprachen verarbeiten oder Compliance-Audits bestehen.

5. PaddleOCR 3.0

PaddleOCR 3.0 ist ein von Apache lizenziertes Open-Supply-Toolkit, das darauf abzielt, Bilder und PDFs mit LLM-fähigen strukturierten Daten zu verbinden. Im Lieferumfang sind PP OCRv5 für mehrsprachige Erkennung, PP StructureV3 für die Dokumentenanalyse und Tabellenrekonstruktion sowie PP ChatOCRv4 für die Extraktion wichtiger Informationen enthalten. Es unterstützt mehr als 100 Sprachen, läuft auf CPU und GPU und verfügt über Mobil- und Edge-Varianten.

Stärken

• Kostenlos und offen, keine Kosten professional Seite.
• Schnell auf der GPU, im Edge-Betrieb nutzbar.
• Deckt Erkennung, Erkennung und Struktur in einem Projekt ab.
• Aktive Gemeinschaft.

Grenzen

• Sie müssen es bereitstellen, überwachen und aktualisieren.
• Für europäische oder finanzielle Layouts ist häufig eine Nachbearbeitung oder Feinabstimmung erforderlich.
• Sicherheit und Langlebigkeit liegen in Ihrer Verantwortung.

Verwenden Sie wann Sie möchten die volle Kontrolle oder möchten einen selbst gehosteten Dokumenten-Intelligence-Dienst für LLM RAG aufbauen.

6. DeepSeek OCR, optische Kontextkomprimierung

DeepSeek OCR wurde im Oktober 2025 veröffentlicht. Es handelt sich nicht um eine klassische OCR. Es handelt sich um ein LLM-zentriertes Imaginative and prescient-Sprachmodell, das lange Texte und Dokumente in hochauflösende Bilder komprimiert und diese dann dekodiert. Die öffentliche Modellkarte und der Weblog berichten von einer Dekodierungsgenauigkeit von etwa 97 Prozent bei 10-facher Komprimierung und etwa 60 Prozent bei 20-facher Komprimierung. Es ist MIT-lizenziert, basiert auf einem 3B-Decoder und wird bereits in vLLM und Hugging Face unterstützt. Dies macht es für Groups interessant, die die Token-Kosten reduzieren möchten, bevor sie ein LLM aufrufen.

Stärken

• Selbstgehostet, GPU-fähig.
• Hervorragend geeignet für langen Kontext und gemischten Textual content sowie Tabellen, da die Komprimierung vor der Dekodierung erfolgt.
• Offene Lizenz.
• Passend für moderne Agentenstacks.

Grenzen

• Es gibt noch keinen öffentlichen Commonplace-Benchmark, der es mit Google oder AWS vergleicht, daher müssen Unternehmen ihre eigenen Exams durchführen.
• Erfordert eine GPU mit ausreichend VRAM.
• Die Genauigkeit hängt vom gewählten Kompressionsverhältnis ab.

Verwenden Sie wann Sie möchten eine OCR, die für LLM-Pipelines und nicht für die Archivdigitalisierung optimiert ist.

Direkter Vergleich

Was wann verwenden?

• Cloud IDP auf Rechnungen, Quittungen, medizinischen Formularen: Amazon Textract oder Azure Doc Intelligence.
• Gemischte gescannte und digitale PDFs für Banken und Telekommunikationsunternehmen in Google Cloud: Google Doc AI Enterprise Doc OCR.
• Regierungsarchiv oder Verlag mit über 150 Sprachen und ohne Cloud: ABBYY FineReader Engine und FlexiCapture.
• Startup oder Medienunternehmen, das sein eigenes RAG über PDFs erstellt: PaddleOCR 3.0.
• LLM-Plattform, die den Kontext vor der Inferenz verkleinern möchte: DeepSeek OCR.

Google Doc AI, Amazon Textract und Azure AI Doc Intelligence liefern allesamt Format-basierte OCR mit Tabellen, Schlüssel-Wert-Paaren und Auswahlmarkierungen als strukturierte JSON-Ausgaben, während ABBYY FineReader Engine 12 R7 und FlexiCapture strukturierte Daten in XML und das neue JSON-Format exportieren und 190 bis 201 Sprachen für die Verarbeitung vor Ort unterstützen. PaddleOCR 3.0 bietet Apache-lizenziertes PP OCRv5, PP StructureV3 und PP ChatOCRv4 für die Analyse selbst gehosteter Dokumente. DeepSeek OCR meldet eine Dekodierungsgenauigkeit von 97 % unter 10-facher Komprimierung und etwa 60 % bei 20-facher Komprimierung, sodass Unternehmen vor der Einführung in Produktions-Workloads lokale Benchmarks durchführen müssen. Insgesamt steht bei OCR im Jahr 2025 die Dokumentenintelligenz an erster Stelle und die Erkennung an zweiter Stelle.

Referenzen:

Michal Sutter ist ein Knowledge-Science-Experte mit einem Grasp of Science in Knowledge Science von der Universität Padua. Mit einer soliden Grundlage in statistischer Analyse, maschinellem Lernen und Datentechnik ist Michal hervorragend darin, komplexe Datensätze in umsetzbare Erkenntnisse umzuwandeln.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.