In diesem Tutorial erstellen wir einen Finish-to-Finish-Workflow zur kognitiven Komplexitätsanalyse mit Komplexität. Wir beginnen mit der Messung der Komplexität direkt anhand der Rohcodezeichenfolgen und skalieren dann dieselbe Analyse auf einzelne Dateien und ein gesamtes Projektverzeichnis. Unterwegs generieren wir maschinenlesbare Berichte, normalisieren sie in strukturierte DataFrames und visualisieren Komplexitätsverteilungen, um zu verstehen, wie sich die Entscheidungstiefe über Funktionen hinweg ansammelt. Indem wir kognitive Komplexität als messbares technisches Sign behandeln, zeigen wir, wie sie auf natürliche Weise in die alltägliche Python-Entwicklung und Qualitätsprüfungen integriert werden kann. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

!pip -q set up complexipy pandas matplotlib


import os
import json
import textwrap
import subprocess
from pathlib import Path


import pandas as pd
import matplotlib.pyplot as plt


from complexipy import code_complexity, file_complexity


print(" Put in complexipy and dependencies")

Wir richten die Umgebung ein, indem wir die erforderlichen Bibliotheken installieren und alle für die Analyse und Visualisierung erforderlichen Abhängigkeiten importieren. Wir stellen sicher, dass das Pocket book vollständig eigenständig ist und ohne externe Einrichtung in Google Colab ausgeführt werden kann. Es bildet das Rückgrat der Ausführung für alles, was folgt.

snippet = """
def score_orders(orders):
   complete = 0
   for o in orders:
       if o.get("legitimate"):
           if o.get("precedence"):
               if o.get("quantity", 0) > 100:
                   complete += 3
               else:
                   complete += 2
           else:
               if o.get("quantity", 0) > 100:
                   complete += 2
               else:
                   complete += 1
       else:
           complete -= 1
   return complete
"""


res = code_complexity(snippet)
print("=== Code string complexity ===")
print("Total complexity:", res.complexity)
print("Features:")
for f in res.capabilities:
   print(f" - {f.title}: {f.complexity} (strains {f.line_start}-{f.line_end})")

Wir beginnen mit der Analyse einer rohen Python-Codezeichenfolge, um die kognitive Komplexität auf Funktionsebene zu verstehen. Wir untersuchen direkt, wie verschachtelte Bedingungen und Kontrollflüsse zur Komplexität beitragen. Es hilft uns, das Kernverhalten von complexipy zu validieren, bevor wir es auf echte Dateien skalieren.

root = Path("toy_project")
src = root / "src"
exams = root / "exams"
src.mkdir(dad and mom=True, exist_ok=True)
exams.mkdir(dad and mom=True, exist_ok=True)


(src / "__init__.py").write_text("")
(exams / "__init__.py").write_text("")


(src / "easy.py").write_text(textwrap.dedent("""
def add(a, b):
   return a + b


def safe_div(a, b):
   if b == 0:
       return None
   return a / b
""").strip() + "n")


(src / "legacy_adapter.py").write_text(textwrap.dedent("""
def legacy_adapter(x, y):
   if x and y:
       if x > 0:
           if y > 0:
               return x + y
           else:
               return x - y
       else:
           if y > 0:
               return y - x
           else:
               return -(x + y)
   return 0
""").strip() + "n")


(src / "engine.py").write_text(textwrap.dedent("""
def route_event(occasion):
   variety = occasion.get("variety")
   payload = occasion.get("payload", {})
   if variety == "A":
       if payload.get("x") and payload.get("y"):
           return _handle_a(payload)
       return None
   elif variety == "B":
       if payload.get("flags"):
           return _handle_b(payload)
       else:
           return None
   elif variety == "C":
       for merchandise in payload.get("gadgets", ()):
           if merchandise.get("enabled"):
               if merchandise.get("mode") == "quick":
                   _do_fast(merchandise)
               else:
                   _do_safe(merchandise)
       return True
   else:
       return None


def _handle_a(p):
   complete = 0
   for v in p.get("vals", ()):
       if v > 10:
           complete += 2
       else:
           complete += 1
   return complete


def _handle_b(p):
   rating = 0
   for f in p.get("flags", ()):
       if f == "x":
           rating += 1
       elif f == "y":
           rating += 2
       else:
           rating -= 1
   return rating


def _do_fast(merchandise):
   return merchandise.get("id")


def _do_safe(merchandise):
   if merchandise.get("id") is None:
       return None
   return merchandise.get("id")
""").strip() + "n")


(exams / "test_engine.py").write_text(textwrap.dedent("""
from src.engine import route_event


def test_route_event_smoke():
   assert route_event({"variety": "A", "payload": {"x": 1, "y": 2, "vals": (1, 20)}}) == 3
""").strip() + "n")


print(f" Created venture at: {root.resolve()}")

Wir erstellen programmgesteuert ein kleines, aber realistisches Python-Projekt mit mehreren Modulen und Testdateien. Wir integrieren bewusst unterschiedliche Kontrollflussmuster, um sinnvolle Unterschiede in der Komplexität zu schaffen. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

engine_path = src / "engine.py"
file_res = file_complexity(str(engine_path))


print("n=== File complexity (Python API) ===")
print("Path:", file_res.path)
print("File complexity:", file_res.complexity)
for f in file_res.capabilities:
   print(f" - {f.title}: {f.complexity} (strains {f.line_start}-{f.line_end})")


MAX_ALLOWED = 8


def run_complexipy_cli(project_dir: Path, max_allowed: int = 8):
   cmd = (
       "complexipy",
       ".",
       "--max-complexity-allowed", str(max_allowed),
       "--output-json",
       "--output-csv",
   )
   proc = subprocess.run(cmd, cwd=str(project_dir), capture_output=True, textual content=True)


   preferred_csv = project_dir / "complexipy.csv"
   preferred_json = project_dir / "complexipy.json"


   csv_candidates = ()
   json_candidates = ()


   if preferred_csv.exists():
       csv_candidates.append(preferred_csv)
   if preferred_json.exists():
       json_candidates.append(preferred_json)


   csv_candidates += listing(project_dir.glob("*.csv")) + listing(project_dir.glob("**/*.csv"))
   json_candidates += listing(project_dir.glob("*.json")) + listing(project_dir.glob("**/*.json"))


   def uniq(paths):
       seen = set()
       out = ()
       for p in paths:
           p = p.resolve()
           if p not in seen and p.is_file():
               seen.add(p)
               out.append(p)
       return out


   csv_candidates = uniq(csv_candidates)
   json_candidates = uniq(json_candidates)


   def pick_best(paths):
       if not paths:
           return None
       paths = sorted(paths, key=lambda p: p.stat().st_mtime, reverse=True)
       return paths(0)


   return proc.returncode, pick_best(csv_candidates), pick_best(json_candidates)


rc, csv_report, json_report = run_complexipy_cli(root, MAX_ALLOWED)

Wir analysieren eine echte Quelldatei mithilfe der Python-API und führen dann die komplexe CLI für das gesamte Projekt aus. Wir führen die CLI aus dem richtigen Arbeitsverzeichnis aus, um zuverlässig Berichte zu erstellen. Dieser Schritt verbindet die lokale API-Nutzung mit statischen Analyse-Workflows im Produktionsstil.

df = None


if csv_report and csv_report.exists():
   df = pd.read_csv(csv_report)
elif json_report and json_report.exists():
   knowledge = json.masses(json_report.read_text())
   if isinstance(knowledge, listing):
       df = pd.DataFrame(knowledge)
   elif isinstance(knowledge, dict):
       if "information" in knowledge and isinstance(knowledge("information"), listing):
           df = pd.DataFrame(knowledge("information"))
       elif "outcomes" in knowledge and isinstance(knowledge("outcomes"), listing):
           df = pd.DataFrame(knowledge("outcomes"))
       else:
           df = pd.json_normalize(knowledge)


if df is None:
   elevate RuntimeError("No report produced")


def explode_functions_table(df_in):
   if "capabilities" in df_in.columns:
       tmp = df_in.explode("capabilities", ignore_index=True)
       if tmp("capabilities").notna().any() and isinstance(tmp("capabilities").dropna().iloc(0), dict):
           fn = pd.json_normalize(tmp("capabilities"))
           base = tmp.drop(columns=("capabilities"))
           return pd.concat((base.reset_index(drop=True), fn.reset_index(drop=True)), axis=1)
       return tmp
   return df_in


fn_df = explode_functions_table(df)


col_map = {}
for c in fn_df.columns:
   lc = c.decrease()
   if lc in ("path", "file", "filename", "module"):
       col_map(c) = "path"
   if ("perform" in lc and "title" in lc) or lc in ("perform", "func", "function_name"):
       col_map(c) = "perform"
   if lc == "title" and "perform" not in fn_df.columns:
       col_map(c) = "perform"
   if "complexity" in lc and "allowed" not in lc and "max" not in lc:
       col_map(c) = "complexity"
   if lc in ("line_start", "linestart", "start_line", "startline"):
       col_map(c) = "line_start"
   if lc in ("line_end", "lineend", "end_line", "endline"):
       col_map(c) = "line_end"


fn_df = fn_df.rename(columns=col_map)

Wir laden die generierten Komplexitätsberichte in Pandas und normalisieren sie in eine Tabelle auf Funktionsebene. Wir verarbeiten mehrere mögliche Berichtsschemata, um den Workflow stabil zu halten. Diese strukturierte Darstellung ermöglicht es uns, mit Commonplace-Datenanalysetools über die Komplexität nachzudenken.

if "complexity" in fn_df.columns:
   fn_df("complexity") = pd.to_numeric(fn_df("complexity"), errors="coerce")
   plt.determine()
   fn_df("complexity").dropna().plot(variety="hist", bins=20)
   plt.title("Cognitive Complexity Distribution (capabilities)")
   plt.xlabel("complexity")
   plt.ylabel("depend")
   plt.present()


def refactor_hints(complexity):
   if complexity >= 20:
       return (
           "Break up into smaller pure capabilities",
           "Exchange deep nesting with guard clauses",
           "Extract complicated boolean predicates"
       )
   if complexity >= 12:
       return (
           "Extract inside logic into helpers",
           "Flatten conditionals",
           "Use dispatch tables"
       )
   if complexity >= 8:
       return (
           "Cut back nesting",
           "Early returns"
       )
   return ("Acceptable complexity")


if "complexity" in fn_df.columns and "perform" in fn_df.columns:
   for _, r in fn_df.sort_values("complexity", ascending=False).head(8).iterrows():
       cx = float(r("complexity")) if pd.notna(r("complexity")) else None
       if cx is None:
           proceed
       print(r("perform"), cx, refactor_hints(cx))


print(" Tutorial full.")

Wir visualisieren die Verteilung der kognitiven Komplexität und leiten Refactoring-Anleitungen aus numerischen Schwellenwerten ab. Wir übersetzen abstrakte Komplexitätswerte in konkrete technische Maßnahmen. Es schließt den Kreis, indem es die Messung direkt mit Entscheidungen zur Wartbarkeit verknüpft.

Abschließend stellten wir eine praktische, reproduzierbare Pipeline zur Prüfung der kognitiven Komplexität in Python-Projekten mithilfe von complexipy vor. Wir haben gezeigt, wie wir von der Advert-hoc-Inspektion zu datengesteuerten Überlegungen zur Codestruktur übergehen, risikoreiche Funktionen identifizieren und umsetzbare Refactoring-Anleitungen auf der Grundlage quantifizierter Schwellenwerte bereitstellen können. Der Workflow ermöglicht es uns, frühzeitig über die Wartbarkeit nachzudenken, Komplexitätsbudgets konsequent durchzusetzen und Codebasen mit Klarheit und Zuversicht zu entwickeln, anstatt uns ausschließlich auf die Instinct zu verlassen.

Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Nach einem Jahrzehnt Erfahrung in der Analytik bin ich fest davon überzeugt, dass Beobachtbarkeit und Auswertung für jede LLM-Anwendung, die in der Produktion läuft, von wesentlicher Bedeutung sind. Überwachung und Metriken sind nicht nur nette Dinge. Sie stellen sicher, dass Ihr Produkt wie erwartet funktioniert und dass jedes neue Replace Sie tatsächlich in die richtige Richtung bringt.

In diesem Artikel möchte ich meine Erfahrungen mit den Beobachtbarkeits- und Auswertungsfunktionen des NeMo Agent Toolkit (NAT) teilen. Falls Sie es nicht gelesen haben mein vorheriger Artikel Zum Thema NAT hier eine kurze Auffrischung: NAT ist Nvidias Framework zum Erstellen produktionsbereiter LLM-Anwendungen. Betrachten Sie es als den Klebstoff, der LLMs, Instruments und Arbeitsabläufe verbindet und gleichzeitig Bereitstellungs- und Observability-Optionen bietet.

Mithilfe von NAT haben wir einen Happiness Agent entwickelt, der in der Lage ist, differenzierte Fragen zu beantworten die Daten des World Happiness-Berichts und Durchführung von Berechnungen basierend auf realen Metriken. Unser Schwerpunkt lag auf dem Aufbau von Agentenflüssen, der Integration von Agenten aus anderen Frameworks als Instruments (in unserem Beispiel ein LangGraph-basierter Rechneragent) und der Bereitstellung der Anwendung sowohl als REST-API als auch als benutzerfreundliche Schnittstelle.

In diesem Artikel gehe ich auf meine Lieblingsthemen ein: Beobachtbarkeit und Bewertungen. Denn wie heißt es so schön: Was man nicht misst, kann man nicht verbessern. Additionally, ohne weitere Umschweife, lasst uns einsteigen.

Beobachtbarkeit

Beginnen wir mit der Beobachtbarkeit – der Fähigkeit, zu verfolgen, was in Ihrer Anwendung passiert, einschließlich aller Zwischenschritte, verwendeten Instruments, Zeitabläufe und Token-Nutzung. Das NeMo Agent Toolkit lässt sich in eine Vielzahl von Observability-Instruments wie Phoenix, W&B Weave und Catalyst integrieren. Sie können jederzeit die neueste Liste der unterstützten Frameworks einsehen die Dokumentation.

Für diesen Artikel probieren wir Phoenix aus. Phönix ist eine Open-Supply-Plattform zur Verfolgung und Bewertung von LLMs. Bevor wir es verwenden können, müssen wir zunächst das Plugin installieren.

uv pip set up arize-phoenix
uv pip set up "nvidia-nat(phoenix)"

Als nächstes können wir den Phoenix-Server starten.

phoenix server

Sobald es läuft, ist der Suchdienst unter verfügbar http://localhost:6006/v1/traces. An dieser Stelle sehen Sie ein Standardprojekt, da wir noch keine Daten gesendet haben.

Da der Phoenix-Server nun läuft, wollen wir sehen, wie wir ihn verwenden können. Da NAT auf der YAML-Konfiguration basiert, müssen wir unserer Konfiguration lediglich einen Telemetrieabschnitt hinzufügen. Die Konfiguration und die vollständige Agentenimplementierung finden Sie unter GitHub. Wenn Sie mehr über das NAT-Framework erfahren möchten, schauen Sie hier mein vorheriger Artikel.

basic:                                             
  telemetry:                                          
    tracing:                                          
      phoenix:                                        
        _type: phoenix                               
        endpoint: http://localhost:6006/v1/traces 
        undertaking: happiness_report

Wenn dies erledigt ist, können wir unseren Agenten betreiben.

export ANTHROPIC_API_KEY=<your_key>
supply .venv_nat_uv/bin/activate
cd happiness_v3 
uv pip set up -e . 
cd .. 
nat run 
  --config_file happiness_v3/src/happiness_v3/configs/config.yml 
  --input "How a lot happier in percentages are individuals in Finland in comparison with the UK?"

Lassen Sie uns noch ein paar Abfragen durchführen, um zu sehen, welche Artwork von Daten Phoenix verfolgen kann.

nat run 
  --config_file happiness_v3/src/happiness_v3/configs/config.yml 
  --input "Are individuals general getting happier over time?"

nat run 
  --config_file happiness_v3/src/happiness_v3/configs/config.yml 
  --input "Is Switzerland on the primary place?"

nat run 
  --config_file happiness_v3/src/happiness_v3/configs/config.yml 
  --input "What's the important contibutor to the happiness in the UK?"

nat run 
  --config_file happiness_v3/src/happiness_v3/configs/config.yml 
  --input "Are individuals in France happier than in Germany?"

Nachdem Sie diese Abfragen ausgeführt haben, werden Sie ein neues Projekt in Phoenix bemerken (happiness_reportwie wir in der Konfiguration definiert haben) zusammen mit allen LLM-Aufrufen, die wir gerade durchgeführt haben. Dadurch haben Sie einen klaren Überblick darüber, was unter der Haube passiert.

Wir können eine der Abfragen vergrößern, z „Werden die Menschen mit der Zeit insgesamt glücklicher?“

Diese Abfrage dauert ziemlich lange (ca. 25 Sekunden), da sie fünf Software-Aufrufe professional Jahr erfordert. Wenn wir viele ähnliche Fragen zu allgemeinen Traits erwarten, kann es sinnvoll sein, unserem Agenten ein neues Software zur Verfügung zu stellen, mit dem er zusammenfassende Statistiken auf einmal berechnen kann.

Genau hier kommt die Beobachtbarkeit zum Tragen: Indem sie Engpässe und Ineffizienzen aufdeckt, hilft sie Ihnen, Kosten zu senken und den Benutzern ein reibungsloseres Erlebnis zu bieten.

Bewertungen

Bei der Beobachtbarkeit geht es darum, zu verfolgen, wie Ihre Anwendung in der Produktion funktioniert. Diese Informationen sind hilfreich, reichen jedoch nicht aus, um zu sagen, ob die Qualität der Antworten intestine genug ist oder ob eine neue Model eine bessere Leistung erbringt. Um solche Fragen zu beantworten, brauchen wir Auswertungen. Glücklicherweise ist das mit dem NeMo Agent Toolkit möglich helfen uns auch mit Evals.

Lassen Sie uns zunächst einen kleinen Satz an Auswertungen zusammenstellen. Wir müssen nur drei Felder angeben: ID, Frage und Antwort.

(
  {
    "id": "1",
    "query": "In what nation was the happiness rating highest in 2021?",
    "reply": "Finland"
  }, 
  {
    "id": "2",
    "query": "What contributed most to the happiness rating in 2024?",
    "reply": "Social Help"
  }, 
  {
    "id": "3",
    "query": "How UK's rank modified from 2019 to 2024?",
    "reply": "The UK's rank dropped from thirteenth in 2019 to twenty third in 2024."
  },
  {
    "id": "4",
    "query": "Are individuals in France happier than in Germany primarily based on the most recent report?",
    "reply": "No, Germany is at twenty second place in 2024 whereas France is at thirty third place."
  },
  {
    "id": "5",
    "query": "How a lot in percents are individuals in Poland happier in 2024 in comparison with 2019?",
    "reply": "Happiness in Poland elevated by 7.9% from 2019 to 2024. It was 6.1863 in 2019 and 6.6730 in 2024."
  }
)

Als Nächstes müssen wir unsere YAML-Konfiguration aktualisieren, um zu definieren, wo die Bewertungsergebnisse gespeichert werden und wo der Bewertungsdatensatz zu finden ist. Ich habe eine eigene eingerichtet eval_llm zu Evaluierungszwecken, um die Lösung modular zu halten, und ich verwende Sonnet 4.5 dafür.

# Analysis configuration
eval:
  basic:
    output:
      dir: ./tmp/nat/happiness_v3/eval/evals/
      cleanup: false  
    dataset:
      _type: json
      file_path: src/happiness_v3/information/evals.json

  evaluators:
    answer_accuracy:
      _type: ragas
      metric: AnswerAccuracy
      llm_name: eval_llm
    groundedness:
      _type: ragas
      metric: ResponseGroundedness
      llm_name: eval_llm
    trajectory_accuracy:
      _type: trajectory
      llm_name: eval_llm

Ich habe hier mehrere Bewerter definiert. Wir werden uns auf Antwortgenauigkeit und Antworterdetheit konzentrieren Ragas (ein Open-Supply-Framework zur Finish-to-Finish-Bewertung von LLM-Workflows) sowie zur Trajektorienbewertung. Lassen Sie uns sie aufschlüsseln.

Antwortgenauigkeit misst, wie intestine die Reaktion eines Modells mit einer Referenzgrundwahrheit übereinstimmt. Es verwendet zwei „LLM-as-a-Choose“-Eingabeaufforderungen, die jeweils eine Bewertung von 0, 2 oder 4 zurückgeben. Diese Bewertungen werden dann in eine (0,1)-Skala umgewandelt und gemittelt. Höhere Werte weisen darauf hin, dass die Antwort des Modells weitgehend mit der Referenz übereinstimmt.

• 0 → Die Antwort ist ungenau oder nicht zum Thema gehörend.
• 2 → Antwort stimmt teilweise überein,
• 4 → Antwort stimmt genau überein.

Reaktionsgeerdetheit wertet aus, ob eine Antwort von den abgerufenen Kontexten unterstützt wird. Das heißt, ob jeder Anspruch (vollständig oder teilweise) in den bereitgestellten Daten zu finden ist. Dies funktioniert ähnlich wie die Antwortgenauigkeit, wobei zwei unterschiedliche „LLM-as-a-Choose“-Eingabeaufforderungen mit Bewertungen von 0, 1 oder 2 verwendet werden, die dann auf eine Skala (0,1) normiert werden.

• 0 → Überhaupt nicht geerdet,
• 1 → Teilweise geerdet,
• 2 → Vollständig geerdet.

Flugbahnbewertung Verfolgt die vom LLM ausgeführten Zwischenschritte und Toolaufrufe und hilft so, den Argumentationsprozess zu überwachen. Ein LLM-Richter bewertet die durch den Arbeitsablauf erzeugte Flugbahn unter Berücksichtigung der bei der Ausführung verwendeten Werkzeuge. Es wird ein Gleitkommawert zwischen 0 und 1 zurückgegeben, wobei 1 eine perfekte Flugbahn darstellt.

Lassen Sie uns Auswertungen durchführen, um zu sehen, wie es in der Praxis funktioniert.

nat eval --config_file src/happiness_v3/configs/config.yml

Als Ergebnis der Ausführung der Auswertungen erhalten wir mehrere Dateien in dem zuvor angegebenen Ausgabeverzeichnis. Eines der nützlichsten ist workflow_output.json. Diese Datei enthält Ausführungsergebnisse für jedes Beispiel in unserem Bewertungssatz, einschließlich der ursprünglichen Frage, der vom LLM generierten Antwort, der erwarteten Antwort und einer detaillierten Aufschlüsselung aller Zwischenschritte. Mithilfe dieser Datei können Sie nachvollziehen, wie das System jeweils funktionierte.

Hier ist ein gekürztes Beispiel für das erste Beispiel.

{
  "id": 1,
  "query": "In what nation was the happiness rating highest in 2021?",
  "reply": "Finland",
  "generated_answer": "Finland had the very best happiness rating in 2021 with a rating of seven.821.",
  "intermediate_steps": (...),
  "expected_intermediate_steps": ()
}

Für Antwortgenauigkeit und Antworterdung haben wir die höchstmögliche Punktzahl erreicht (durchschnittlich 1,0 von 1,0), was immer wieder schön zu sehen ist. Hier ist die zurückgegebene Datei.

{
  "average_score": 1.0,
  "eval_output_items": (
    {
      "id": 1,
      "rating": 1.0,
      "reasoning": {
        "user_input": "In what nation was the happiness rating highest in 2021?",
        "reference": "Finland",
        "response": "Finland had the very best happiness rating in 2021 with a rating of seven.821.",
        "retrieved_contexts": (...)
      }
    },
    {
      "id": 2,
      "rating": 1.0,
      "reasoning": {
        "user_input": "What contributed most to the happiness rating in 2024?",
        "reference": "Social Help",
        "response": "In 2024, **Social Help** contributed most to the happiness rating, with a median affect of 1.333 factors. This was adopted very intently by **GDP per capita** with an affect of 1.319 factors. These two components have been considerably extra influential than different contributors like life expectancy (0.551), freedom (0.749), generosity (0.113), and perceptions of corruption (0.147). This means that having robust social connections and relationships, together with financial prosperity, have been the first drivers of happiness throughout international locations in 2024.",
        "retrieved_contexts": (...)
      }
    },
    {
      "id": 3,
      "rating": 1.0,
      "reasoning": {
        "user_input": "How UK's rank modified from 2019 to 2024?",
        "reference": "The UK's rank dropped from thirteenth in 2019 to twenty third in 2024.",
        "response": "The UK's rank within the World Happiness Report modified from thirteenth place in 2019 to twenty third place in 2024, representing a decline of 10 positions. The happiness rating additionally decreased from 7.1645 in 2019 to six.7280 in 2024.",
        "retrieved_contexts": (...)
      }
    },
    {
      "id": 4,
      "rating": 1.0,
      "reasoning": {
        "user_input": "Are individuals in France happier than in Germany primarily based on the most recent report?",
        "reference": "No, Germany is at twenty second place in 2024 whereas France is at thirty third place.",
        "response": "Based mostly on the most recent 2024 World Happiness Report, individuals in Germany are happier than individuals in France. Germany has a happiness rating of 6.753 (ranked twenty second globally), whereas France has a happiness rating of 6.593 (ranked thirty third globally). The distinction is 0.16 factors in Germany's favor.",
        "retrieved_contexts": (...)
      }
    },
    {
      "id": 5,
      "rating": 1.0,
      "reasoning": {
        "user_input": "How a lot in percents are individuals in Poland happier in 2024 in comparison with 2019?",
        "reference": "Happiness in Poland elevated by 7.9% from 2019 to 2024. It was 6.1863 in 2019 and 6.6730 in 2024.",
        "response": "Folks in Poland are roughly 7.87% happier in 2024 in comparison with 2019. The happiness rating elevated from 6.1863 in 2019 to six.6730 in 2024, representing a rise of 0.4867 factors or about 7.87%.",
        "retrieved_contexts": (...)
      }
    }
  )
}

Bei der Flugbahnbewertung erreichten wir einen Durchschnittswert von 0,95. Um zu verstehen, wo das Modell zu kurz kam, schauen wir uns ein nicht ideales Beispiel an. Bei der fünften Frage stellte der Richter richtig fest, dass der Agent einen suboptimalen Weg eingeschlagen hatte: Es waren 8 Schritte erforderlich, um zur endgültigen Antwort zu gelangen, obwohl das gleiche Ergebnis in 4–5 Schritten hätte erreicht werden können. Als Ergebnis erhielt diese Flugbahn eine Bewertung von 0,75 von 1,0.

Let me consider this AI language mannequin's efficiency step-by-step:

## Analysis Standards:
**i. Is the ultimate reply useful?**
Sure, the ultimate reply is evident, correct, and straight addresses the query. 
It gives each the proportion enhance (7.87%) and explains the underlying 
information (happiness scores from 6.1863 to six.6730). The reply is well-formatted 
and simple to know.

**ii. Does the AI language use a logical sequence of instruments to reply the query?**
Sure, the sequence is logical:
1. Question nation statistics for Poland
2. Retrieve the information exhibiting happiness scores for a number of years together with 
2019 and 2024
3. Use a calculator to compute the proportion enhance
4. Formulate the ultimate reply
This can be a wise strategy to the issue.

**iii. Does the AI language mannequin use the instruments in a useful means?**
Sure, the instruments are used appropriately:
- The `country_stats` software efficiently retrieved the related happiness information
- The `calculator_agent` appropriately computed the proportion enhance utilizing 
the correct components
- The Python analysis software carried out the precise calculation precisely

**iv. Does the AI language mannequin use too many steps to reply the query?**
That is the place there's some inefficiency. The mannequin makes use of 8 steps whole, which 
contains some redundancy:
- Steps 4-7 seem to contain a number of calls to calculate the identical share 
(the calculator_agent is invoked, which then calls Claude Opus, which calls 
evaluate_python, and returns via the chain)
- Step 7 appears to repeat what was already performed in steps 4-6
Whereas the reply is right, there's pointless duplication. The calculation 
may have been performed extra effectively in 4-5 steps as a substitute of 8.

**v. Are the suitable instruments used to reply the query?**
Sure, the instruments chosen are acceptable:
- `country_stats` was the correct software to get happiness information for Poland
- `calculator_agent` was acceptable for computing the proportion change
- The underlying `evaluate_python` software appropriately carried out the mathematical 
calculation

## Abstract:
The mannequin efficiently answered the query with correct information and proper 
calculations. The logical move was sound, and acceptable instruments have been chosen. 
Nonetheless, there was some inefficiency within the execution with redundant steps 
within the calculation section.

Betrachtet man die Begründung, so stellt sich heraus, dass es sich um eine überraschend umfassende Bewertung des gesamten LLM-Workflows handelt. Besonders wertvoll ist, dass es sofort einsatzbereit ist und keine Floor-Reality-Daten erfordert. Ich würde Ihnen auf jeden Fall empfehlen, diese Auswertung für Ihre Bewerbungen zu verwenden.

Vergleich verschiedener Versionen

Besonders aussagekräftig sind Auswertungen, wenn Sie verschiedene Versionen Ihrer Anwendung vergleichen müssen. Stellen Sie sich ein Group vor, das sich auf die Kostenoptimierung konzentriert und einen Wechsel vom teureren System in Betracht zieht sonnet Modell zu haiku. Mit NAT dauert die Änderung des Modells weniger als eine Minute, aber ohne Qualitätsvalidierung wäre es riskant. Genau hier glänzen Bewertungen.

Für diesen Vergleich stellen wir auch ein weiteres Observability-Software vor: W&B Weave. Es bietet besonders praktische Visualisierungen und direkte Vergleiche zwischen verschiedenen Versionen Ihres Workflows.

Um zu beginnen, müssen Sie sich anmelden der W&B-Web site und erhalten Sie einen API-Schlüssel. W&B ist frei für persönliche Projekte zu verwenden.

export WANDB_API_KEY=<your key>

Als nächstes installieren Sie die erforderlichen Pakete und Plugins.

uv pip set up wandb weave
uv pip set up "nvidia-nat(weave)"

Wir müssen auch unsere YAML-Konfiguration aktualisieren. Dazu gehört das Hinzufügen von Weave zum Telemetrieabschnitt und die Einführung eines Workflow-Alias, damit wir klar zwischen verschiedenen Versionen der Anwendung unterscheiden können.

basic:                                             
  telemetry:                                          
    tracing:                                          
      phoenix:                                        
        _type: phoenix                               
        endpoint: http://localhost:6006/v1/traces 
        undertaking: happiness_report
      weave: # specified Weave
        _type: weave
        undertaking: "nat-simple"

eval:
  basic:
    workflow_alias: "nat-simple-sonnet-4-5" # added alias
    output:
      dir: ./.tmp/nat/happiness_v3/eval/evals/
      cleanup: false  
    dataset:
      _type: json
      file_path: src/happiness_v3/information/evals.json

  evaluators:
    answer_accuracy:
      _type: ragas
      metric: AnswerAccuracy
      llm_name: chat_llm
    groundedness:
      _type: ragas
      metric: ResponseGroundedness
      llm_name: chat_llm
    trajectory_accuracy:
      _type: trajectory
      llm_name: chat_llm

Für die haiku Model, die ich erstellt habe eine separate Konfiguration wo beides chat_llm Und calculator_llm verwenden haiku anstatt sonnet.

Jetzt können wir Auswertungen für beide Versionen durchführen.

nat eval --config_file src/happiness_v3/configs/config.yml
nat eval --config_file src/happiness_v3/configs/config_simple.yml

Sobald die Bewertungen abgeschlossen sind, können wir zur W&B-Oberfläche gehen und einen umfassenden Vergleichsbericht einsehen. Die Visualisierung des Radardiagramms gefällt mir sehr intestine, da sie Kompromisse sofort deutlich macht.

Mit sonnetbeobachten wir eine höhere Token-Nutzung (und höhere Kosten professional Token) sowie langsamere Antwortzeiten (24,8 Sekunden im Vergleich zu 16,9 Sekunden für haiku). Trotz der deutlichen Geschwindigkeits- und Kostenvorteile würde ich jedoch keinen Modellwechsel empfehlen. Der Qualitätsabfall ist zu groß: Die Flugbahngenauigkeit sinkt von 0,85 auf 0,55 und die Antwortgenauigkeit sinkt von 0,95 auf 0,45. In diesem Fall haben uns die Bewertungen dabei geholfen, eine Beeinträchtigung der Benutzererfahrung im Streben nach Kostenoptimierung zu vermeiden.

Die vollständige Implementierung finden Sie auf GitHub.

Zusammenfassung

In diesem Artikel haben wir die Beobachtbarkeits- und Auswertungsmöglichkeiten des NeMo Agent Toolkits untersucht.

• Wir haben mit zwei Observability-Instruments (Phoenix und W&B Weave) gearbeitet, die sich beide nahtlos in NAT integrieren und es uns ermöglichen, zu protokollieren, was in unserem System in der Produktion passiert, sowie Auswertungsergebnisse zu erfassen.
• Außerdem haben wir erklärt, wie man Auswertungen in NAT konfiguriert, und mit W&B Weave die Leistung zweier verschiedener Versionen derselben Anwendung verglichen. Dies machte es einfach, über Kompromisse zwischen Kosten, Latenz und Antwortqualität nachzudenken.

Das NeMo Agent Toolkit liefert solide, produktionsreife Lösungen für Beobachtbarkeit und Auswertungen – grundlegende Bestandteile jeder ernsthaften LLM-Anwendung. Das Herausragende für mich warfare jedoch W&B Weave, dessen Bewertungsvisualisierungen den Vergleich von Modellen und Kompromisse bemerkenswert einfach machen.

Vielen Dank fürs Lesen. Ich hoffe, dieser Artikel warfare aufschlussreich. Erinnern Sie sich an Einsteins Rat: „Wichtig ist, nicht mit dem Hinterfragen aufzuhören. Neugier hat ihre eigene Daseinsberechtigung.“ Möge Ihre Neugier Sie zu Ihrer nächsten großen Erkenntnis führen.

Referenz

Dieser Artikel ist inspiriert von „Nvidias NeMo Agent Toolkit: Agenten zuverlässig machen“ Kurzkurs von DeepLearning.AI.

Ich habe neulich an einem Drehbuch gearbeitet und es hat mich wahnsinnig gemacht. Es hat zwar funktioniert, aber es conflict nur … langsam. Wirklich langsam. Ich hatte das Gefühl, dass es viel schneller gehen könnte, wenn ich es herausfinden könnte Wo die Verzögerung conflict.

Mein erster Gedanke conflict, mit den Optimierungen zu beginnen. Ich konnte das Laden der Daten optimieren. Oder die for-Schleife umschreiben? Aber ich habe mich zurückgehalten. Ich bin schon einmal in diese Falle getappt und habe Stunden damit verbracht, einen Codeabschnitt zu „optimieren“, nur um dann festzustellen, dass er kaum einen Unterschied zur Gesamtlaufzeit macht. Donald Knuth hatte Recht, als er sagte: „Vorzeitige Optimierung ist die Wurzel allen Übels.“

Ich habe mich für einen methodischeren Ansatz entschieden. Anstatt zu raten, wollte ich es sicher herausfinden. Ich musste ein Profil des Codes erstellen, um konkrete Daten darüber zu erhalten, welche Funktionen genau die meisten Taktzyklen verbrauchten.

In diesem Artikel werde ich Sie durch den genauen Prozess führen, den ich verwendet habe. Wir nehmen ein bewusst langsames Python-Skript und verwenden zwei fantastische Instruments, um seine Engpässe mit chirurgischer Präzision zu lokalisieren.

Das erste dieser Instruments heißt cProfileein leistungsstarker, in Python integrierter Profiler. Der andere heißt Schlangenvisz, A geniales Werkzeug Das wandelt die Ausgabe des Profilers in eine interaktive visuelle Karte um.

Einrichten einer Entwicklungsumgebung

Bevor wir mit dem Codieren beginnen, richten wir unsere Entwicklungsumgebung ein. Die beste Vorgehensweise besteht darin, eine separate Python-Umgebung zu erstellen, in der Sie die erforderliche Software program installieren und experimentieren können, in dem Wissen, dass alles, was Sie tun, keine Auswirkungen auf den Relaxation Ihres Techniques hat. Ich werde dafür Conda verwenden, aber Sie können jede Methode verwenden, mit der Sie vertraut sind.

#create our check setting
conda create -n profiling_lab python=3.11 -y

# Now activate it
conda activate profiling_lab

Nachdem wir nun unsere Umgebung eingerichtet haben, müssen wir Snakeviz für unsere Visualisierungen und Numpy für das Beispielskript installieren. cProfile ist bereits in Python enthalten, daher gibt es dort nichts weiter zu tun. Da wir unsere Skripte mit einem Jupyter-Pocket book ausführen, werden wir dieses auch installieren.

# Set up our visualization instrument and numpy
pip set up snakeviz numpy jupyter

Geben Sie nun ein jupyter pocket book in Ihre Eingabeaufforderung ein. In Ihrem Browser sollte ein Jupiter-Notizbuch geöffnet sein. Wenn dies nicht automatisch geschieht, wird Ihnen danach wahrscheinlich ein Bildschirm voller Informationen angezeigt jupyter pocket book Befehl. Ganz unten finden Sie eine URL, die Sie kopieren und in Ihren Browser einfügen sollten, um das Jupyter Pocket book zu starten.

Ihre URL wird sich von meiner unterscheiden, aber sie sollte in etwa so aussehen:-

http://127.0.0.1:8888/tree?token=3b9f7bd07b6966b41b68e2350721b2d0b6f388d248cc69da

Nachdem unsere Instruments bereit sind, ist es an der Zeit, einen Blick auf den Code zu werfen, den wir reparieren werden.

Unser „Drawback“-Skript

Um unsere Profiling-Instruments ordnungsgemäß zu testen, benötigen wir ein Skript, das eindeutige Leistungsprobleme aufweist. Ich habe ein einfaches Programm geschrieben, das Verarbeitungsprobleme mit Speicher, Iteration und CPU-Zyklen simuliert, was es zu einem perfekten Kandidaten für unsere Untersuchung macht.

# run_all_systems.py
import time
import math

# ===================================================================
CPU_ITERATIONS = 34552942
STRING_ITERATIONS = 46658100
LOOP_ITERATIONS = 171796964
# ===================================================================

# --- Activity 1: A Calibrated CPU-Certain Bottleneck ---
def cpu_heavy_task(iterations):
    print("  -> Operating CPU-bound job...")
    end result = 0
    for i in vary(iterations):
        end result += math.sin(i) * math.cos(i) + math.sqrt(i)
    return end result

# --- Activity 2: A Calibrated Reminiscence/String Bottleneck ---
def memory_heavy_string_task(iterations):
    print("  -> Operating Reminiscence/String-bound job...")
    report = ""
    chunk = "report_item_abcdefg_123456789_"
    for i in vary(iterations):
        report += f"|{chunk}{i}"
    return report

# --- Activity 3: A Calibrated "Thousand Cuts" Iteration Bottleneck ---
def simulate_tiny_op(n):
    move

def iteration_heavy_task(iterations):
    print("  -> Operating Iteration-bound job...")
    for i in vary(iterations):
        simulate_tiny_op(i)
    return "OK"

# --- Fundamental Orchestrator ---
def run_all_systems():
    print("--- Beginning FINAL SLOW Balanced Showcase ---")
    
    cpu_result = cpu_heavy_task(iterations=CPU_ITERATIONS)
    string_result = memory_heavy_string_task(iterations=STRING_ITERATIONS)
    iteration_result = iteration_heavy_task(iterations=LOOP_ITERATIONS)

    print("--- FINAL SLOW Balanced Showcase Completed ---")

Schritt 1: Sammeln der Daten mit cProfile

Unser erstes Software, cProfile, ist ein in Python integrierter deterministischer Profiler. Wir können es über den Code ausführen, um unser Skript auszuführen und detaillierte Statistiken zu jedem Funktionsaufruf aufzuzeichnen.

import cProfile, pstats, io

pr = cProfile.Profile()
pr.allow()

# Run the perform you wish to profile
run_all_systems()

pr.disable()

# Dump stats to a string and print the highest 10 by cumulative time
s = io.StringIO()
ps = pstats.Stats(pr, stream=s).sort_stats("cumtime")
ps.print_stats(10)
print(s.getvalue())

Hier ist die Ausgabe.

--- Beginning FINAL SLOW Balanced Showcase ---
  -> Operating CPU-bound job...
  -> Operating Reminiscence/String-bound job...
  -> Operating Iteration-bound job...
--- FINAL SLOW Balanced Showcase Completed ---
         275455984 perform calls in 30.497 seconds

   Ordered by: cumulative time
   Listing diminished from 47 to 10 resulting from restriction <10>

   ncalls  tottime  percall  cumtime  percall filename:lineno(perform)
        2    0.000    0.000   30.520   15.260 /house/tom/.native/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3541(run_code)
        2    0.000    0.000   30.520   15.260 {built-in technique builtins.exec}
        1    0.000    0.000   30.497   30.497 /tmp/ipykernel_173802/1743829582.py:41(run_all_systems)
        1    9.652    9.652   14.394   14.394 /tmp/ipykernel_173802/1743829582.py:34(iteration_heavy_task)
        1    7.232    7.232   12.211   12.211 /tmp/ipykernel_173802/1743829582.py:14(cpu_heavy_task)
171796964    4.742    0.000    4.742    0.000 /tmp/ipykernel_173802/1743829582.py:31(simulate_tiny_op)
        1    3.891    3.891    3.892    3.892 /tmp/ipykernel_173802/1743829582.py:22(memory_heavy_string_task)
 34552942    1.888    0.000    1.888    0.000 {built-in technique math.sin}
 34552942    1.820    0.000    1.820    0.000 {built-in technique math.cos}
 34552942    1.271    0.000    1.271    0.000 {built-in technique math.sqrt}

Wir haben eine Reihe von Zahlen, die schwer zu interpretieren sein können. Hier kommt Snakeviz ins Spiel.

Schritt 2: Visualisierung des Engpasses mit Snakeviz

Hier geschieht die Magie. Snakeviz nimmt die Ausgabe unserer Profilierungsdatei und wandelt sie in ein interaktives, browserbasiertes Diagramm um, um das Auffinden von Engpässen zu erleichtern.

Nutzen wir additionally dieses Software, um zu visualisieren, was wir haben. Da ich ein Jupyter-Pocket book verwende, müssen wir es zuerst laden.

%load_ext snakeviz

Und wir führen es so aus.

%%snakeviz
predominant()

Die Ausgabe besteht aus zwei Teilen. Zuerst ist eine Visualisierung wie diese.

Was Sie sehen, ist ein „Eiszapfen“-Diagramm von oben nach unten. Von oben nach unten stellt es die Anrufhierarchie dar.

Ganz oben: Python führt unser Skript aus ().

Als nächstes: die __main__-Ausführung des Skripts (:1()). Dann die Funktion run_all_systems. Darin werden zwei Schlüsselfunktionen aufgerufen: iteration_heavy_task und cpu_heavy_task.

Der speicherintensive Verarbeitungsteil ist im Diagramm nicht gekennzeichnet. Das liegt daran, dass der Zeitanteil, der mit dieser Aufgabe verbunden ist, viel kleiner ist als der Zeitanteil, der auf die anderen beiden intensiven Funktionen entfällt. Als Ergebnis sehen wir rechts vom cpu_heavy_task-Block einen viel kleineren, unbeschrifteten Block.

Beachten Sie, dass es für die Analyse auch einen Snakeviz-Diagrammstil namens a gibt Sunburst-Diagramm. Es ähnelt ein wenig einem Kreisdiagramm, enthält jedoch eine Reihe immer größerer konzentrischer Kreise und Bögen. Die Idee dahinter ist, dass die Zeit, die Funktionen zum Ausführen benötigen, durch die Winkelausdehnung der Bogengröße des Kreises dargestellt wird. Die Wurzelfunktion ist ein Kreis in der Mitte von nämlich. Die Root-Funktion wird ausgeführt, indem sie die darunter liegenden Unterfunktionen usw. aufruft. Wir werden uns in diesem Artikel nicht mit diesem Anzeigetyp befassen.

Eine solche visuelle Bestätigung kann so viel wirkungsvoller sein, als auf eine Zahlentabelle zu starren. Ich musste nicht mehr raten, wo ich suchen sollte; Die Daten starrten mich direkt ins Gesicht.

Auf die Visualisierung folgt schnell ein Textblock, der die Zeitabläufe für verschiedene Teile Ihres Codes detailliert beschreibt, ähnlich wie die Ausgabe des cprofile-Instruments. Ich zeige hier nur die ersten etwa ein Dutzend Zeilen, da es insgesamt über 30 waren.

ncalls tottime percall cumtime percall filename:lineno(perform)
----------------------------------------------------------------
1 9.581 9.581 14.3 14.3 1062495604.py:34(iteration_heavy_task)
1 7.868 7.868 12.92 12.92 1062495604.py:14(cpu_heavy_task)
171796964 4.717 2.745e-08 4.717 2.745e-08 1062495604.py:31(simulate_tiny_op)
1 3.848 3.848 3.848 3.848 1062495604.py:22(memory_heavy_string_task)
34552942 1.91 5.527e-08 1.91 5.527e-08 ~:0(<built-in technique math.sin>)
34552942 1.836 5.313e-08 1.836 5.313e-08 ~:0(<built-in technique math.cos>)
34552942 1.305 3.778e-08 1.305 3.778e-08 ~:0(<built-in technique math.sqrt>)
1 0.02127 0.02127 31.09 31.09 <string>:1(<module>)
4 0.0001764 4.409e-05 0.0001764 4.409e-05 socket.py:626(ship)
10 0.000123 1.23e-05 0.0004568 4.568e-05 iostream.py:655(write)
4 4.594e-05 1.148e-05 0.0002735 6.838e-05 iostream.py:259(schedule)
...
...
...

Schritt 3: Die Lösung

Instruments wie Cprofiler und Snakeviz verraten es Ihnen natürlich nicht Wie um Ihre Leistungsprobleme zu beheben, aber da ich nun genau wusste, wo die Probleme lagen, konnte ich gezielte Korrekturen vornehmen.

# final_showcase_fixed_v2.py
import time
import math
import numpy as np

# ===================================================================
CPU_ITERATIONS = 34552942
STRING_ITERATIONS = 46658100
LOOP_ITERATIONS = 171796964
# ===================================================================

# --- Repair 1: Vectorization for the CPU-Certain Activity ---
def cpu_heavy_task_fixed(iterations):
    """
    Fastened by utilizing NumPy to carry out the advanced math on a whole array
    without delay, in extremely optimized C code as an alternative of a Python loop.
    """
    print("  -> Operating CPU-bound job...")
    # Create an array of numbers from 0 to iterations-1
    i = np.arange(iterations, dtype=np.float64)
    # The identical calculation, however vectorized, is orders of magnitude quicker
    result_array = np.sin(i) * np.cos(i) + np.sqrt(i)
    return np.sum(result_array)

# --- Repair 2: Environment friendly String Becoming a member of ---
def memory_heavy_string_task_fixed(iterations):
    """
    Fastened by utilizing an inventory comprehension and a single, environment friendly ''.be a part of() name.
    This avoids creating hundreds of thousands of intermediate string objects.
    """
    print("  -> Operating Reminiscence/String-bound job...")
    chunk = "report_item_abcdefg_123456789_"
    # A listing comprehension is quick and memory-efficient
    elements = (f"|{chunk}{i}" for i in vary(iterations))
    return "".be a part of(elements)

# --- Repair 3: Eliminating the "Thousand Cuts" Loop ---
def iteration_heavy_task_fixed(iterations):
    """
    Fastened by recognizing the duty is usually a no-op or a bulk operation.
    In a real-world state of affairs, you'd discover a strategy to keep away from the loop solely.
    Right here, we show the repair by merely eradicating the pointless loop.
    The aim is to indicate the price of the loop itself was the issue.
    """
    print("  -> Operating Iteration-bound job...")
    # The repair is to discover a bulk operation or eradicate the necessity for the loop.
    # Because the unique perform did nothing, the repair is to do nothing, however quicker.
    return "OK"

# --- Fundamental Orchestrator ---
def run_all_systems():
    """
    The primary orchestrator now calls the FAST variations of the duties.
    """
    print("--- Beginning FINAL FAST Balanced Showcase ---")
    
    cpu_result = cpu_heavy_task_fixed(iterations=CPU_ITERATIONS)
    string_result = memory_heavy_string_task_fixed(iterations=STRING_ITERATIONS)
    iteration_result = iteration_heavy_task_fixed(iterations=LOOP_ITERATIONS)

    print("--- FINAL FAST Balanced Showcase Completed ---")

Jetzt können wir den cprofiler für unseren aktualisierten Code erneut ausführen.

import cProfile, pstats, io

pr = cProfile.Profile()
pr.allow()

# Run the perform you wish to profile
run_all_systems()

pr.disable()

# Dump stats to a string and print the highest 10 by cumulative time
s = io.StringIO()
ps = pstats.Stats(pr, stream=s).sort_stats("cumtime")
ps.print_stats(10)
print(s.getvalue())

#
# begin of output
#

--- Beginning FINAL FAST Balanced Showcase ---
  -> Operating CPU-bound job...
  -> Operating Reminiscence/String-bound job...
  -> Operating Iteration-bound job...
--- FINAL FAST Balanced Showcase Completed ---
         197 perform calls in 6.063 seconds

   Ordered by: cumulative time
   Listing diminished from 52 to 10 resulting from restriction <10>

   ncalls  tottime  percall  cumtime  percall filename:lineno(perform)
        2    0.000    0.000    6.063    3.031 /house/tom/.native/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3541(run_code)
        2    0.000    0.000    6.063    3.031 {built-in technique builtins.exec}
        1    0.002    0.002    6.063    6.063 /tmp/ipykernel_173802/1803406806.py:1(<module>)
        1    0.402    0.402    6.061    6.061 /tmp/ipykernel_173802/3782967348.py:52(run_all_systems)
        1    0.000    0.000    5.152    5.152 /tmp/ipykernel_173802/3782967348.py:27(memory_heavy_string_task_fixed)
        1    4.135    4.135    4.135    4.135 /tmp/ipykernel_173802/3782967348.py:35(<listcomp>)
        1    1.017    1.017    1.017    1.017 {technique 'be a part of' of 'str' objects}
        1    0.446    0.446    0.505    0.505 /tmp/ipykernel_173802/3782967348.py:14(cpu_heavy_task_fixed)
        1    0.045    0.045    0.045    0.045 {built-in technique numpy.arange}
        1    0.000    0.000    0.014    0.014 <__array_function__ internals>:177(sum)

Das ist ein fantastisches Ergebnis, das die Leistungsfähigkeit der Profilerstellung demonstriert. Wir haben unsere Mühe auf die Teile des Codes gelenkt, die wichtig waren. Der Gründlichkeit halber habe ich auch Snakeviz für das korrigierte Skript ausgeführt.

%%snakeviz
run_all_systems()

Die bemerkenswerteste Änderung ist die Reduzierung der Gesamtlaufzeit von etwa 30 Sekunden auf etwa 6 Sekunden. Dies ist eine 5-fache Beschleunigung, die durch die Beseitigung der drei Hauptengpässe erreicht wird, die im „Vorher“-Profil sichtbar waren.

Schauen wir uns jedes einzeln an.

1. Die iteration_heavy_task

Vorher (Das Drawback)
Im ersten Bild ist der große Balken auf der linken Seite, iteration_heavy_task, der größte Engpass, der verbraucht 14,3 Sekunden.

• Warum conflict es langsam? Diese Aufgabe conflict ein klassischer „Tod durch tausend Schnitte“. Die Funktion simulieren_tiny_op hat quick nichts bewirkt, wurde aber millionenfach innerhalb einer reinen Python-for-Schleife aufgerufen. Der immense Aufwand, den der Python-Interpreter mit dem wiederholten Starten und Stoppen eines Funktionsaufrufs verursacht, conflict die alleinige Ursache für die Langsamkeit.

Die Lösung
Die feste Model iteration_heavy_task_fixed erkannte, dass das Ziel ohne die Schleife erreicht werden konnte. In unserem Fall bedeutete dies, die sinnlose Schleife vollständig zu entfernen. In einer realen Anwendung müsste dazu eine einzige „Massen“-Operation gefunden werden, um die iterative Operation zu ersetzen.

Nachher (Das Ergebnis)
Im zweiten Bild ist die iteration_heavy_task-Leiste zu sehen völlig verschwunden. Es ist jetzt so schnell, dass seine Laufzeit nur einen winzigen Bruchteil einer Sekunde beträgt und auf dem Diagramm unsichtbar ist. Wir haben ein 14,3-Sekunden-Drawback erfolgreich behoben.

2. Die cpu_heavy_task

Vorher (Das Drawback)
Der zweite große Engpass, deutlich sichtbar als großer orangefarbener Balken rechts, ist cpu_heavy_task, der in Anspruch genommen wurde 12,9 Sekunden.

• Warum conflict es langsam? Wie die Iterationsaufgabe conflict auch diese Funktion durch die Geschwindigkeit der Python-for-Schleife begrenzt. Während die darin enthaltenen mathematischen Operationen schnell waren, musste der Interpreter jede der Millionen Berechnungen einzeln verarbeiten, was für numerische Aufgaben äußerst ineffizient ist.

Die Lösung
Die Lösung conflict Vektorisierung Verwendung der NumPy-Bibliothek. Anstatt eine Python-Schleife zu verwenden, hat cpu_heavy_task_fixed ein NumPy-Array erstellt und alle mathematischen Operationen (np.sqrt, np.sin usw.) gleichzeitig für das gesamte Array ausgeführt. Diese Operationen werden in hochoptimiertem, vorkompiliertem C-Code ausgeführt, wobei die langsame Python-Interpreterschleife vollständig umgangen wird.

Nachher (Das Ergebnis).
Genau wie der erste Engpass ist auch die cpu_heavy_task-Leiste aus dem „Nachher“-Diagramm verschwunden. Seine Laufzeit wurde von 12,9 Sekunden auf wenige Millisekunden reduziert.

3. Die „memory_heavy_string_task“.

Vorher (Das Drawback):
Im ersten Diagramm lief die speicherintensive_string_task, aber ihre Laufzeit conflict im Vergleich zu den beiden anderen größeren Problemen gering, sodass sie in den kleinen, unbeschrifteten Bereich ganz rechts verbannt wurde. Es conflict ein relativ kleines Drawback.

Die Lösung
Die Lösung für diese Aufgabe bestand darin, das Ineffiziente zu ersetzen melden += „…” String-Verkettung mit einer viel effizienteren Methode: Erstellen einer Liste aller String-Teile und anschließender Aufruf „“.verbinden() ein einziges Mal am Ende.

Nachher (Das Ergebnis)
Im zweiten Diagramm sehen wir das Ergebnis unseres Erfolgs. Nachdem die beiden Engpässe von mehr als 10 Sekunden beseitigt wurden, ist nun die speicherintensive Zeichenfolgenaufgabe behoben neuer dominanter EngpassBuchhaltung 4,34 Sekunden der gesamten 5,22 Sekunden Laufzeit.

Snakeviz lässt uns sogar einen Blick in diese feste Funktion werfen. Der neue wichtigste Beitragszahler ist der orangefarbene Balken mit der Bezeichnung (Listenverständnis), was dauert 3,52 Sekunden. Dies deutet darauf hin, dass auch in der behoben Der zeitaufwändigste Teil des Codes besteht nun darin, die umfangreiche Liste der Zeichenfolgen im Speicher zu erstellen, bevor sie verknüpft werden können.

Zusammenfassung

Dieser Artikel bietet eine praktische Anleitung zum Identifizieren und Beheben von Leistungsproblemen in Python-Code und argumentiert, dass Entwickler dazu Profilierungstools verwenden sollten messen Leistung zu verbessern, anstatt sich auf Instinct oder Vermutungen zu verlassen, um die Ursache von Verlangsamungen zu ermitteln.

Ich habe einen methodischen Arbeitsablauf mit zwei Schlüsselwerkzeugen demonstriert:-

• cProfile: Pythons integrierter Profiler, der zum Sammeln detaillierter Daten zu Funktionsaufrufen und Ausführungszeiten verwendet wird.
• Schlangenviz: Ein Visualisierungstool, das die Daten von cProfile in ein interaktives „Eiszapfen“-Diagramm umwandelt und es so einfach macht, visuell zu erkennen, welche Teile des Codes die meiste Zeit verbrauchen.

Der Artikel verwendet eine Fallstudie eines absichtlich langsamen Skripts, das mit drei deutlichen und erheblichen Engpässen entwickelt wurde:

1. Eine iterationsgebundene Aufgabe: Eine Funktion, die millionenfach in einer Schleife aufgerufen wird und die Leistungseinbußen des Funktionsaufruf-Overheads von Python („Tod durch tausend Schnitte“) zeigt.
2. Eine CPU-gebundene Aufgabe: Eine for-Schleife, die Millionen mathematischer Berechnungen durchführt und die Ineffizienz von reinem Python für schwere numerische Arbeiten verdeutlicht.
3. Eine speichergebundene Aufgabe: Eine große Zeichenfolge, die durch wiederholte +=-Verkettung ineffizient erstellt wurde.

Durch die Analyse der Snakeviz-Ausgabe habe ich diese drei Probleme lokalisiert und gezielte Korrekturen vorgenommen.

• Der Iterationsengpass wurde behoben durch Eliminierung der unnötigen Schleife.
• Der CPU-Engpass wurde durch Vektorisierung mit NumPy behoben, das mathematische Operationen in schnellem, kompiliertem C-Code ausführt.
• Der Speicherengpass wurde durch das Anhängen von Zeichenfolgenteilen an eine Liste und die Verwendung eines einzigen, effizienten „“ behoben..verbinden() Anruf.

Diese Korrekturen führten zu einer erheblichen Beschleunigung und verkürzten die Laufzeit des Skripts erheblich 30 Sekunden bis knapp vorbei 6 Sekunden. Abschließend habe ich gezeigt, dass der Profiler auch nach der Lösung größerer Probleme erneut zur Identifizierung verwendet werden kann neukleinere Engpässe, was verdeutlicht, dass die Leistungsoptimierung ein iterativer Prozess ist, der durch Messungen gesteuert wird.

: Wenn die Fähigkeiten nicht genug sind

Sie beobachten, wie Ihr Crew den Besitz dominiert, die Anzahl der Aufnahmen doppelt so hoch wiet … und trotzdem verlieren. Ist es nur Pech?

Followers beschuldigen Schiedsrichter. Die Spieler beschuldigen „Off Days“. Coach erwähnen „Schwung“. Aber was wäre, wenn wir Ihnen diese Zufälligkeit sagen – nicht Expertise oder Taktik – eine wichtige versteckte Variable bei den Sportergebnissen sein würde?

Dieser Beitrag taucht tief in ein Wie Glück den Sport beeinflusstwie wir versuchen können, die Zufälligkeit mit Daten zu quantifizieren, und wie Information Science uns hilft, die Fähigkeiten von Zufall zu trennen.

Wie immer finden Sie hier eine kurze Zusammenfassung dessen, was wir heute durchmachen werden:

1. Glück im Sport definieren
2. Glück messen
3. Fallstudie
4. Berühmte Zufälligkeit Momente
5. Was wäre, wenn wir Glück entfernen könnten?
6. Letzte Gedanken

Glück im Sport definieren

Dies könnte umstritten sein, da verschiedene Menschen es anders definieren und alle Interpretationen gleichermaßen akzeptabel wären. Hier ist meins: Glück im Sport geht es um Varianz Und Unsicherheit.

Mit anderen Worten könnten wir sagen, dass Glück die Varianz der Ergebnisse ist, die nicht durch Fähigkeiten erklärt werden.

Für die anderen Datenwissenschaftler ist eine andere Artwork zu sagen: Glück ist das Restrauschen, das unsere Modelle nicht angemessen erklären oder angemessen vorhersagen können (das Modell könnte beispielsweise ein Fußballspiel sein). Hier sind einige Beispiele:

• Ein Schuss mit leerem Tor, der den Pfosten schlug, anstatt hineinzugehen.
• Ein Tennisnetzkabel, das die Ballrichtung ändert.
• Eine kontroverse VAR -Entscheidung.
• Ein Münze -Wurf -Sieg im Cricket oder amerikanischen Fußball.

Glück ist überall, ich entdecke hier nichts Neues. Aber können wir es messen?

Glück messen

Wir könnten das Glück in vielerlei Hinsicht messen, aber wir werden drei von Fundamental zu Fortgeschrittenen besuchen.

Regressionsreste

Wir konzentrieren uns in der Regel auf die Modellierung der erwarteten Ergebnisse eines Ereignisses: HWO werden viele Tore ein Crew erzielen, was der Punktunterschied zwischen zwei NBA -Groups sein wird…

Es gibt kein perfektes Modell und es ist unrealistisch, ein 100percentiger Genehmigungsmodell anzustreben. Das wissen wir alle. Aber genau dieser Unterschied, was unser Modell von einem perfekten unterscheidet, was wir definieren können Regressionsreste.

Lassen Sie uns ein sehr einfaches Beispiel sehen: Wir möchten das Endergebnis eines Fußballspiels (Fußball) vorhersagen. Wir verwenden Metriken wie XG, Besitz %, Heimvorteil, Spielermetriken… und unser Modell sagt voraus, dass das Heimteam 3,1 Tore erzielte und die Anzeigetafel des Besuchers eine 1,2 aufweisen wird (offensichtlich müssten wir sie umrunden, weil Tore in echten Spielen Ganzzahlen sind).

Das Endergebnis beträgt jedoch 1: 0 (anstelle von 3,1-1,2 oder der abgerundeten 3-1). Dieses Rauschen, der Unterschied zwischen dem Ergebnis und unserer Vorhersage, ist das Glückskomponente Wir reden darüber.

Das Ziel wird immer darin bestehen, dass unsere Modelle diese Glückskomponente (Fehler) reduzieren, aber wir könnten es auch verwenden, um Groups durch Übertrefferformance im Vergleich zu erwarteten zu rangieren und so zu sehen, welche Groups mehr von Glück betroffen sind (basierend auf unserem Modell).

Monte Carlo -Methode

Natürlich musste MC in diesem Beitrag erscheinen. Ich habe bereits einen Beitrag, der sich tiefer in ihn ausgräbt (na ja, genauer gesagt in Markov -Kette Monte Carlo) Aber ich werde es trotzdem vorstellen.

Der Monte Carlo Methode oder Simulationen bestehen darin, wiederholt Stichprobenzahlen zu verwenden, um numerische Ergebnisse in Kind der Wahrscheinlichkeit einer Reihe von Ergebnissen des Auftretens zu erhalten.

Grundsätzlich wird es verwendet, um die möglichen Ergebnisse oder die Verteilung eines unsicheren Ereignisses zu schätzen oder zu approximieren.

Mit unserem weitermachen Sport Beispiele: Nehmen wir an, ein Basketballspieler schießt genau 75% aus der Freiwurflinie. Mit diesem Prozentsatz könnten wir 10.000 Spielzeiten simulieren, vorausgesetzt, jeder Spieler hat das gleiche Fähigkeitsniveau und generiere stochastisch.

Mit den Ergebnissen konnten wir die mit der Fähigkeit basierenden vorhergesagten Ergebnisse mit den simulierten Verteilungen vergleichen. Wenn wir sehen, dass der tatsächliche Rekord des Groups außerhalb der 95% des Simulationsbereichs liegt, dann ist das wahrscheinlich Glück (Intestine oder schlecht, je nach Extrem, in dem sie liegen).

Bayes’sche Inferenz

Bei weitem meine bevorzugte Artwork, das Glück zu messen, weil die Fähigkeit der Bayes’schen Modelle, die zugrunde liegenden Fähigkeiten von lauter Leistung zu trennen, zu trennen.

Angenommen, Sie sind in einem Fußball -Scouting -Crew und überprüfen einen sehr jungen Stürmer des besten Groups der örtlichen norwegischen Liga. Sie interessieren sich besonders für seine Zielumwandlung, denn das braucht Ihr Crew und Sie sehen, dass er in den letzten 10 Spielen 9 Tore erzielt hat. Ist er Elite? Oder Glück?

Mit einem Bayesian Prior (z. B. durchschnittliche Konversionsrate = 15%) aktualisieren wir unseren Glauben nach jedem Spiel und haben am Ende eine hintere Verteilung, die zeigt, ob seine Leistung ist nachhaltig überdurchschnittlich oder ein Zufall.

Wenn Sie sich mit dem Thema Bayesianer Inferenz einlassen möchten, habe ich einen Beitrag geschrieben, der versucht habe, die Champions League der letzten Saison mit diesen Methoden vorherzusagen: https://towardsdatascience.com/using-bayesian-modeling-to-predict-the-champions-league-8ebb069006ba/

Fallstudie

Lass uns die Hände schmutzig machen.

Das Szenario ist das nächste: Wir haben eine Spherical-Robin-Saison zwischen 6 Groups, in denen jedes Crew zweimal (zu Hause und weg) gespielt hat. Jedes Spiel erzielte für beide Groups die erwarteten Tore (XG) und die tatsächlichen Ziele wurden aus einer Poisson-Verteilung um XG abgetastet:

Schätzen wir die, wo wir im vorherigen Abschnitt abgereist sind, die wahre Fähigkeit zur Torschreibung von jedem Crew und sehen, wie sehr ihre tatsächliche Leistung davon abweist – was wir interpretieren werden Glück oder Varianz.

Wir werden ein Bayes’sche Poisson -Modell verwenden:

• Sei λₜ die latente Torquote für jedes Crew.
• Dann ist unser Prior λₜ ∼ Gamma (α, β)
• Und wir nehmen die Ziele ∼ Poisson (λₜ) an, die Überzeugungen über λₜ unter Verwendung der tatsächlichen Ziele über Spiele aktualisieren.

λₜ | Daten ∼ Gamma (α+Gesamtziele, β+Gesamtübereinstimmungen)

Genau, jetzt müssen wir unsere Werte für α und β entscheiden:

• Mein erster Glaube (ohne Daten zu betrachten) ist, dass die meisten Groups rund 2 Tore professional Spiel erzielen. Ich weiß auch, dass der Mittelwert in einer Gamma -Verteilung mithilfe des Mittelwerts berechnet wird α/β.
• Aber ich bin nicht sehr zuversichtlich, additionally möchte ich, dass die Standardabweichung relativ hoch ist, sicherlich über einem Ziel. Wiederum wird in einer Gamma -Verteilung die Standardabweichung berechnet √α/β.

Wenn wir die einfachen Gleichungen lösen, die aus diesen Argumentation hervorgehen, finden wir das α = 2 Und β = 1 sind wahrscheinlich gute vorherige Annahmen.

Wenn wir unser Modell ausführen, erhalten wir die nächsten Ergebnisse:

Wie interpretieren wir sie?

• Alle Groups haben ihre posterioren Erwartungen leicht unterdurchschnittlich – in kurzen Saisons aufgrund von Abweichungen häufig.

• Crew b Und Crew c Hatte die größte adverse „Glück“ -Lücke: Ihr tatsächlicher Wert warfare 0,10 Tore professional Spiel niedriger als die Bayes’sche Schätzung.

• Crew a warfare seiner vorhergesagten Stärke am nächsten – das „neutralste Glück“ -Crew.

Dies warfare ein gefälschtes Beispiel mit gefälschten Daten, aber ich wette, Sie können bereits seine Kraft spüren.

Lassen Sie uns nun einige historische Zufälligkeitsmomente in der Welt des Sports activities überprüfen.

Berühmte Zufälligkeit Momente

Jeder NBA -Fan erinnert sich an die 2016 Finale. Es ist Spiel 7, Cleveland spielt bei Warriors ‚und sie sind mit 89 mit weniger als einer Minute übrig. Kyrie Irving sieht sich Stephen Curry gegenüber und trifft eine unvergessliche Kupplung. Dann gewinnen die Cavaliers das Finale.

Struggle diese Fähigkeit oder Glück? Kyrie ist ein High -Spieler und wahrscheinlich auch ein guter Schütze. Aber mit der Opposition, die er hatte, die Zeit und der Anzeigetafel Druck … wir können einfach nicht wissen, welches es warfare.

Wenn wir uns jetzt zum Fußball bewegen, konzentrieren wir uns jetzt auf die 2019 Champions League SemisLiverpool gegen Barcelona. Dieser ist persönlich verletzend. Barça gewann das erste Bein zu Hause mit 3: 0, verlor jedoch in Liverpool im Rückspiel mit 4: 0 und gab den Roten die Möglichkeit, bis zum Finale voranzukommen.

Liverpools Übererformance? Oder eine statistische Anomalie?

Ein letzter Beispiel: NFL -Münzwurf von OT gewinnt. Die gesamten Playoff -Ergebnisse werden durch ein 50/50 -einfacher Szenario entschieden, in dem die Münze (Glück) die gesamte Kraft zu entscheiden hat.

Was wäre, wenn wir Glück entfernen könnten?

Können wir Glück entfernen? Die Antwort ist ein klares Nein.

Doch warum versuchen so viele von uns? Für Fachleute ist klar: Diese Unsicherheit beeinflusst die Leistung. Je mehr Kontrolle wir über alles haben können, desto mehr können wir unsere Methoden und Strategien optimieren.

Mehr Gewissheit (weniger Glück) bedeutet mehr Geld.

Und wir tun dies zu Recht: Glück ist nicht abnehmbar, aber wir können es verringern. Deshalb erstellen wir komplexe XG -Modelle oder bauen Wettmodelle mit probabilistischer Begründung auf.

Aber Sport soll unvorhersehbar sein. Das macht sie für den Zuschauer aufregend. Die meisten würden sich kein Spiel ansehen, wenn wir das Ergebnis bereits wüssten.

Letzte Gedanken

Heute hatten wir die Gelegenheit, über die Rolle des Glücks im Sport zu sprechen, was massiv ist. Wenn man es versteht, kann es den Followers helfen, überreagiert zu werden. Es könnte aber auch helfen, Scouting und Teammanagement zu sammeln oder intelligentere Wetten- oder Fantasy -League -Entscheidungen zu informieren.

Alles in allem müssen wir wissen, dass das beste Crew nicht immer gewinnt, aber Daten können uns sagen, wie oft sie haben sollten.

Die Wahrheit ist niemals perfekt. Von wissenschaftlichen Messungen bis hin zu menschlichen Anmerkungen, die zum Ausbilden von tiefen Lernmodellen verwendet wurden, hat die Grundwahrheit immer ein gewisses Maß an Fehlern. ImageNet, wohl am besten kuratiertes Bilddatensatz hat 0,3% Fehler bei menschlichen Anmerkungen. Wie können wir dann Vorhersagemodelle anhand solcher fehlerhaften Beschriftungen bewerten?

In diesem Artikel untersuchen wir, wie Fehler in Testdatenbezeichnungen berücksichtigt werden, und schätzen die „wahre“ Genauigkeit eines Modells.

Beispiel: Bildklassifizierung

Nehmen wir an, es gibt 100 Bilder, die entweder eine Katze oder einen Hund enthalten. Die Bilder werden von menschlichen Annotatoren gekennzeichnet, von denen bekannt ist, dass sie eine Genauigkeit von 96% (Aᵍʳᵒᵘⁿᵈᵗʳᵘᵗʰ) haben. Wenn wir einen Picture-Klassifizierer für einige dieser Daten trainieren und feststellen, dass es eine Genauigkeit von 90% für einen Maintain-out-Set (Aᵐᵒᵈᵉˡ) hat, wie lautet die „wahre“ Genauigkeit des Modells (Aᵗʳᵘᵉ)? Zuerst ein paar Beobachtungen:

1. Innerhalb der 90% der Vorhersagen, dass das Modell „richtig“ wurde, wurden einige Beispiele möglicherweise falsch gekennzeichnet, was bedeutet, dass sowohl das Modell als auch die Grundwahrheit falsch sind. Dies verbessert künstlich die gemessene Genauigkeit.
2. Umgekehrt können einige innerhalb der 10% der „falschen“ Vorhersagen tatsächlich Fälle sein, in denen das Modell richtig ist und das Label der Bodenwahrheit falsch ist. Dies entfällt künstlich die gemessene Genauigkeit.

Wie sehr kann die wahre Genauigkeit angesichts dieser Komplikationen variieren?

Reichweite der wahren Genauigkeit

Die wahre Genauigkeit unseres Modells hängt davon ab, wie seine Fehler mit den Fehlern in den Bodenwahrheitsbezeichnungen korrelieren. Wenn sich die Fehler unseres Modells mit den Grundwahrheitsfehlern perfekt überschneiden (dh das Modell ist in genau genauso falsch wie menschliche Label), ist seine wahre Genauigkeit:

Aᵗʳᵘᵉ = 0,90 – (1–0,96) = 86%

Alternativ ist, wenn unser Modell als menschliche Label (perfekte destructive Korrelation) genau das Gegenteil falsch ist, seine wahre Genauigkeit lautet:

Aᵗʳᵘᵉ = 0,90 + (1–0,96) = 94%

Oder allgemeiner:

Aᵗʳᵘᵉ = aᵐᵒᵈᵉˡ ± (1 – aᵍʳᵒᵘⁿᵈᵗʳᵘᵗʰ)

Es ist wichtig zu beachten, dass die wahre Genauigkeit des Modells sowohl niedriger als auch höher sein kann als die gemeldete Genauigkeit, abhängig von der Korrelation zwischen Modellfehlern und Grundwahrheitsfehlern.

Probabilistische Schätzung der wahren Genauigkeit

In einigen Fällen werden die Ungenauigkeiten zwischen den Beschriftungen zwischen den Beispielen zufällig verteilt und nicht systematisch auf bestimmte Etiketten oder Regionen des Merkmalsraums voreingenommen. Wenn die Ungenauigkeiten des Modells unabhängig von den Ungenauigkeiten in den Etiketten sind, können wir eine genauere Schätzung seiner wahren Genauigkeit ableiten.

Wenn wir Aᵐᵒᵈᵉˡ (90%) messen, zählen wir Fälle, in denen die Vorhersage des Modells mit dem Bodentwahrheitsbezeichnung übereinstimmt. Dies kann in zwei Szenarien passieren:

1. Sowohl das Modell als auch die Bodenwahrheit sind korrekt. Dies geschieht mit der Wahrscheinlichkeit aᵗʳᵘᵉ × aᵍʳᵒᵘⁿᵈᵗʳᵘᵗʰ.
2. Sowohl das Modell als auch die Bodenwahrheit sind (auf die gleiche Weise) falsch. Dies geschieht mit Wahrscheinlichkeit (1 – aᵗʳᵘᵉ) × (1 – aᵍʳᵒᵘⁿᵈᵗʳᵘᵗʰ).

Unter der Unabhängigkeit können wir dies als:

Aᵐᵒᵈᵉˡ = aᵗʳᵘᵉ × aᵍʳᵒᵘⁿᵈᵗʳᵘᵗʰ + (1 – aᵗʳᵘᵉ) × (1 – aᵍʳᵒᵘⁿᵈᵗʳᵘᵗʰ)

Wenn wir die Begriffe neu anordnen, bekommen wir:

Aᵗʳᵘᵉ = (Aᵐᵒᵈᵉˡ + aᵍʳᵒᵘⁿᵈᵗʳᵘᵗʰ – 1) / (2 × aᵍʳᵒᵘⁿᵈᵗʳᵘᵗʰ – 1)

In unserem Beispiel entspricht dies (0,90 + 0,96–1) / (2 × 0,96–1) = 93,5%, was im Bereich von 86% bis 94% liegt, den wir oben abgeleitet haben.

Das Unabhängigkeitsparadox

Wenn wir Aᵍʳᵒᵘⁿᵈᵗʳᵘᵗʰ als 0,96 aus unserem Beispiel einstecken, bekommen wir

Aᵗʳᵘᵉ = (aᵐᵒᵈᵉˡ – 0,04) / (0,92). Lassen Sie uns dies unten zeichnen.

Seltsam, nicht wahr? Wenn wir davon ausgehen, dass die Fehler des Modells mit Grundwahrheitsfehlern nicht korreliert sind, ist die wahre Genauigkeit A ᵗʳᵘᵉ immer höher als die 1: 1 -Zeile, wenn die gemeldete Genauigkeit> 0,5 beträgt. Dies gilt auch dann, wenn wir unterscheiden aᵍʳᵒᵘⁿᵈᵗʳᵘᵗʰ:

Fehlerkorrelation: Warum Modelle oft dort kämpfen, wo Menschen tun

Die Unabhängigkeitsannahme ist entscheidend, aber in der Praxis oft nicht. Wenn einige Bilder von Katzen sehr verschwommen sind oder einige kleine Hunde wie Katzen aussehen, sind sowohl die Grundwahrheits- als auch die Modellfehler wahrscheinlich korreliert. Dies führt dazu, dass Aᵗʳᵘᵉ näher an der unteren Grenze (aᵐᵒᵈᵉˡ – (1 – aᵍʳᵒᵘⁿᵈᵗʳᵘᵗʰ)) als die Obergrenze liegt.

Im Allgemeinen sind Modellfehler in der Regel mit Grundwahrheitsfehlern korreliert, wenn:

1. Sowohl Menschen als auch Modelle haben mit den gleichen „schwierigen“ Beispielen zu kämpfen (z. B. mehrdeutige Bilder, Randfälle)
2. Das Modell hat die gleichen Verzerrungen gelernt, die im menschlichen Kennzeichnungsprozess vorhanden sind
3. Bestimmte Klassen oder Beispiele sind für jeden Klassifikator, Menschen oder Maschine von Natur aus mehrdeutig oder herausfordernd
4. Die Etiketten selbst werden aus einem anderen Modell generiert
5. Es gibt zu viele Klassen (und damit zu viele verschiedene Arten, falsch zu sein)

Greatest Practices

Die wahre Genauigkeit eines Modells kann sich erheblich von seiner gemessenen Genauigkeit unterscheiden. Das Verständnis dieses Unterschieds ist für die ordnungsgemäße Modellbewertung von entscheidender Bedeutung, insbesondere in Bereichen, in denen das Erhalten perfekter Grundwahrheit unmöglich oder unerschwinglich teuer ist.

Bei der Bewertung der Modellleistung mit unvollständiger Grundwahrheit:

1. Durchführen Sie gezielte Fehleranalyse: Untersuchen Sie Beispiele, in denen das Modell mit der Grundwahrheit nicht einverstanden ist, um mögliche Grundwahrheitsfehler zu identifizieren.
2. Betrachten Sie die Korrelation zwischen Fehlern: Wenn Sie die Korrelation zwischen Modell- und Grundwahrheitsfehlern vermuten, liegt die wahre Genauigkeit wahrscheinlich näher an der unteren Grenze (aᵐᵒᵈᵉˡ – (1 – aᵍʳᵒᵘⁿᵈᵗʳᵘᵗʰ)).
3. Erhalten Sie mehrere unabhängige Anmerkungen: Mehrere Annotatoren können dazu beitragen, die Genauigkeit der Grundwahrheit zuverlässig zu schätzen.

Abschluss

Zusammenfassend haben wir das gelernt:

1. Der Bereich möglicher wahrer Genauigkeit hängt von der Fehlerrate in der Grundwahrheit ab
2. Wenn Fehler unabhängig sind, ist die tatsächliche Genauigkeit häufig höher als für Modelle besser als zufällige Probability
3. In realen Szenarien sind Fehler selten unabhängig, und die wahre Genauigkeit liegt wahrscheinlich näher an der Untergrenze

Wichtige Kennzahlen und Techniken zur Steigerung der Leistung Ihrer abrufgestützten Generierung

AFortschritte bei Massive Language Fashions (LLMs) haben die Fantasie der Welt angeregt. Mit der Veröffentlichung von ChatGPT von OpenAIIm November 2022 gelangten bisher unbekannte Begriffe wie Generative AI in den öffentlichen Diskurs. In kurzer Zeit fanden LLMs eine breite Verbreitung Anwendbarkeit in modernen Sprachverarbeitungsaufgaben und sogar den Weg dafür geebnet autonome KI-Agenten. Manche nennen es einen Wendepunkt in der Technologie und ziehen hochtrabende Vergleiche mit dem Aufkommen des Internets oder sogar der Erfindung der Glühbirne. Folglich ist die überwiegende Mehrheit der Wirtschaftsführer, Softwareentwickler und Unternehmer bestrebt, LLMs zu ihrem Vorteil zu nutzen.

Retrieval Augmented Era (RAG) ist eine zentrale Technik, die die Landschaft der angewandten generativen KI prägt. Ein neuartiges Konzept, das Lewis et al. in ihrer wegweisenden Arbeit vorgestellt haben Retrieval-Augmented Era für wissensintensive NLP-AufgabenRAG hat sich schnell zu einem Eckpfeiler entwickelt, der die Zuverlässigkeit und Vertrauenswürdigkeit der Ergebnisse großer Sprachmodelle erhöht.

In diesem Blogbeitrag gehen wir auf die Particulars der Bewertung von RAG-Systemen ein. Aber lassen Sie uns vorher den Kontext schaffen, indem wir den Bedarf an RAG verstehen und uns einen Überblick über die Implementierung von RAG-Pipelines verschaffen.