tief – chatgpz.de – KI-Tools & Praxiswissen

Perplexity AI veröffentlicht WANDR: einen offenen Benchmark zur Bewertung von Forschungsagenten, die weit und tief suchen müssen

admin — Sun, 19 Jul 2026 21:02:24 +0000

[ad_1]

Rechercheagenten übernehmen bereits heute echte Wissensarbeit. Die Groups delegieren ihnen Wettbewerbskartierung, Due Diligence und Literaturrecherche. Allerdings testen die meisten Benchmarks eine einzelne Antwort und keine großen, evidenzgestützten Sammlungen. Perplexity schließt diese Lücke mit einem neuen offenen Benchmark.

Ratlosigkeit befreit WANDR (Breite und tiefe Forschung). Es handelt sich um ein offenes Benchmark- und Bewertungssystem. Es besteht aus rund 500 realistischen, herausfordernden Datenerfassungsaufgaben für die Wissensarbeit. WANDR ist der große Bruder von Perplexitys DRACO-Benchmark für tiefgreifende Forschung. DRACO fragt, ob ein Agent einen genauen, vollständigen und objektiven Langformbericht erstellt. WANDR fragt stattdessen, ob es eine große Beweissammlung aufbauen kann.

Was ist WANDR

Im Kern testet WANDR zwei Anforderungen gemeinsam. Breit bedeutet, eine große, oft offene Gruppe qualifizierter Einheiten zu entdecken. Tief bedeutet, jedes Unternehmen ausreichend zu untersuchen, um jede Behauptung mit Beweisen zu untermauern. Durch die Kombination beider Faktoren ändert sich das Drawback für die Agenten. Ein paar überzeugende Beispiele reichen hier nicht aus. Eine ausgefeilte Erzählung, die auf unvollständigen Recherchen aufbaut, greift ebenfalls zu kurz.

Um dies zu erfassen, verwendet WANDR ein Composable Qualifikationsschlüsselhierarchie. Eine Aufgabe könnte eine Anforderung sein firm(n) -> worker(m) -> url(okay). Das bedeutet n qualifizierte Unternehmen, jeweils m Mitarbeiter und jeweils okay unterstützende Seiten. Jeder vollständige Pfad durch den Baum wird unabhängig validiert. Dieselbe Struktur kann eine flache Liste, eine verschachtelte Suche oder eine Matrix darstellen.

Ein konkretes Aufgabenbeispiel

Um diese Hierarchie zu begründen, betrachten Sie die Veröffentlichung ceo_cfo_appointments Aufgabe. Gefragt sind mindestens 70 in den USA ansässige Unternehmen. Für jeden muss eine Ernennung zum CEO oder CFO erstmals zwischen dem 1. März und dem 30. April 2026 bekannt gegeben werden. Für jeden stellt der Agent eine maßgebliche Terminseite bereit. Eine Unteraufgabe fügt professional Unternehmen eine Itemizing-Authority-Seite hinzu. Insgesamt erfordert die Aufgabe 140 quellengestützte Datensätze.

Konkret sehen die beiden Hierarchien und ein übermittelter Datensatz so aus:

# Job hierarchies
firm(70) -> company_appointee(1) -> url(1)   # 70 appointment information
firm(70) -> url(1)                           # 70 itemizing information

# One file the grader re-fetches and re-checks (values are illustrative)
{
  "merchandise":     "Instance Corp - new CFO",
  "url":      "https://issuer.instance.com/press/cfo-appointment",
  "excerpts": ("Instance Corp as we speak named Jane Doe as Chief Monetary Officer, efficient April 2026."),
  "reply":   "Jane Doe appointed CFO; introduced April 2026"
}

Realistische Aufgaben, maßstabsgetreu generiert

Über einzelne Beispiele hinaus baut WANDR seine Aufgaben auf der realen Nutzung auf. Es geht von nicht identifizierten Mustern aus, die in der Produktion zu sehen sind, und nicht von synthetischen Eingabeaufforderungen. Eine halbautomatische Pipeline wandelt diese Muster dann in Aufgaben um. Die Pipeline durchläuft vier Phasen: Seeding, Authoring, Zulassung und Kuration. Es verwendet eine verschachtelte Autor-Kritiker-Schleife mit mechanischer Flusenbildung.

Daher erfordert die mittlere Aufgabe insgesamt 50 Mitglieder und 245 Datensätze. Für alle 500 Aufgaben fordert WANDR 170.495 quellengestützte Datensätze. Die Aufgaben sind in 167 Aufgaben mit niedrigerem, 166 mittlerem und 167 höherem Schwierigkeitsgrad unterteilt. Der Schwierigkeitsgrad hängt von der Arbeit professional Datensatz ab, nicht nur vom Maßstab.

Wie WANDR Agenten bewertet

Im Gegensatz zu festen Antwortschlüsseln bewertet WANDR jeden Anspruch anhand der zitierten Beweise. Jeder Datensatz enthält ein Component, eine URL, ausgewählte Auszüge und eine Antwort. Der Bewerter ruft die Seite während der Bewertung erneut ab. Es prüft, ob die Seite nutzbar und im Umfang ist. Anschließend wird überprüft, ob die Auszüge tatsächlich vorliegen und alle Anforderungen erfüllen.

Diese binären Datensatzurteile werden dann in der Hierarchie zusammengefasst. Präzision misst die Qualität dessen, was ein System übermittelt hat. Abrufen misst die qualitätsbereinigte Fertigstellung und füllt etwaige Lücken mit Nullen. Weich Bei Partituren werden unvollständige Mitglieder teilweise angerechnet. Hart Scores zählen nur Mitglieder, deren vollständiger Teilbaum korrekt ist.

Die Benchmark-Ergebnisse

Mit dieser Methode führte Perplexity sechs Produktionssysteme für alle 500 Aufgaben aus. Sein eigenes Search as Code (SaC)-System führt. Dennoch kommt kein System auch nur annähernd an die Lösung des Benchmarks heran.

System	Weiches F1	Harte F1	Notizen
Ratlosigkeit (Suche als Code)	0,363	0,133	5,20 $/Aufgabe, durchschnittlich 14,9 Minuten, 3,82 Mio. Token/Aufgabe
Anthropisch	0,249	0,072	Am nächsten an der Qualität, aber mehr Zeit, Geld, Token
Andere (am besten)	0,121	0,035	OpenAI, Exa schneller und günstiger, aber schlechtere Werte

Mit mehr Aufwand erreicht Perplexity einen Gentle-F1-Wert von 0,447 xhigh Einstellung. Die Kosten über alle Einstellungen hinweg erstrecken sich über mehr als vier Größenordnungen. Der Preis reicht von 0,03 $ professional Aufgabe bis zu 324,83 $ professional Aufgabe.

Über die Bestenliste hinaus stechen vier Erkenntnisse hervor. Erstens ist ein teilweiser Fortschritt üblich, eine vollständige Abdeckung jedoch nicht. Jedes System zeigt einen Gentle-Recall unterhalb der Gentle-Präzision. Zweitens verschärft die Größenordnung das Drawback erheblich. Tiefere Hierarchien schaden am meisten, da jede Verzweigung einen Fehlerpunkt hinzufügt. Drittens ist die Entdeckung der erste strukturelle Engpass. Der Erkennungsabschluss auf oberster Ebene liegt systemübergreifend zwischen 0,611 und 0,951. Der größte Teil des fehlenden Volumens ist auf eine Unterlieferung zurückzuführen, nicht auf die Zusammenführung von Duplikaten. Viertens ist es normalerweise einfach, eine brauchbare Seite zu finden. Es ist der schwierige Teil, daraus vollständige Beweise zu machen. Bei Perplexity fehlt auf 41,4 % der Seiten eine wesentliche Anforderung. Außerdem stützen 57,5 % der Auszüge nicht die vollständige Behauptung. Sein weicher F1 fällt von 0,531 bei einer reinen Abrufprüfung auf 0,363 bei der vollständigen Beurteilung.

Insbesondere passt Search as Code intestine zu dieser Aufgabenform. Ein Agent kann Abruf-, Filter-, Fanout-, Be a part of-, Deduplizierungs- und Stopplogik als Programm ausdrücken. Die deterministische Berechnung verarbeitet dann wiederholte Vorgänge außerhalb des Modellkontexts.

How WANDR Evaluates a Wide-and-Deep Research Agent

Watch an agent discover entities (wide), enrich each one (deep), then get graded against cited evidence. Scores roll up the hierarchy into Precision, Recall, and F1. Numbers here are illustrative of the method.

Effort:

Ready

Task: find companies → a CEO/CFO appointee → one evidence URL each. Press Discover to begin.

Precision0.00

Recall0.00

Soft F10.00

Hard F10.00

submitted evidence verified failed check missing (target)

Interactive explainer · method after Perplexity WANDR (Wide ANd Deep Research) Built by Marktechpost

[ad_2]

Tauchen Sie tief in Multithreading, Multiprocessing und Asyncio ein | von Clara Chong | Dez. 2024

admin — Sat, 28 Dec 2024 18:12:40 +0000

[ad_1]

Multithreading ermöglicht es einem Prozess, mehrere Threads gleichzeitig auszuführen, wobei Threads denselben Speicher und dieselben Ressourcen teilen (siehe Diagramme 2 und 4).

Allerdings schränkt Pythons International Interpreter Lock (GIL) die Effektivität von Multithreading für CPU-gebundene Aufgaben ein.

Pythons International Interpreter Lock (GIL)

Die GIL ist eine Sperre, die es jeweils nur einem Thread ermöglicht, die Kontrolle über den Python-Interpreter zu behalten, was bedeutet, dass nur ein Thread gleichzeitig Python-Bytecode ausführen kann.

Die GIL wurde eingeführt, um die Speicherverwaltung in Python zu vereinfachen, da viele interne Vorgänge, wie z. B. die Objekterstellung, standardmäßig nicht threadsicher sind. Ohne eine GIL erfordern mehrere Threads, die versuchen, auf die gemeinsam genutzten Ressourcen zuzugreifen, komplexe Sperren oder Synchronisierungsmechanismen, um Race Circumstances und Datenbeschädigungen zu verhindern.

Wann ist GIL ein Engpass?

Für Single-Threaded-Programme ist die GIL irrelevant, da der Thread exklusiven Zugriff auf den Python-Interpreter hat.
Für Multithread-E/A-gebundene Programme ist die GIL weniger problematisch, da Threads die GIL freigeben, wenn sie auf E/A-Vorgänge warten.
Bei Multithread-CPU-gebundenen Vorgängen wird die GIL zu einem erheblichen Engpass. Mehrere Threads, die um die GIL konkurrieren, müssen abwechselnd Python-Bytecode ausführen.

Ein interessanter erwähnenswerter Fall ist die Verwendung von time.sleepwas Python effektiv als E/A-Vorgang behandelt. Der time.sleep Die Funktion ist nicht an die CPU gebunden, da sie keine aktive Berechnung oder die Ausführung von Python-Bytecode während der Ruhephase erfordert. Stattdessen wird die Verantwortung für die Verfolgung der verstrichenen Zeit an das Betriebssystem delegiert. Während dieser Zeit gibt der Thread die GIL frei, sodass andere Threads ausgeführt und den Interpreter nutzen können.

Multiprocessing ermöglicht es einem System, mehrere Prozesse parallel auszuführen, jeder mit eigenem Speicher, eigener GIL und eigenen Ressourcen. Innerhalb jedes Prozesses kann es einen oder mehrere Threads geben (siehe Diagramme 3 und 4).

Multiprocessing umgeht die Einschränkungen der GIL. Dadurch eignet es sich für CPU-gebundene Aufgaben, die einen hohen Rechenaufwand erfordern.

Allerdings ist Multiprocessing aufgrund des separaten Speicher- und Prozess-Overheads ressourcenintensiver.

Im Gegensatz zu Threads oder Prozessen verwendet Asyncio einen einzelnen Thread, um mehrere Aufgaben abzuwickeln.

Beim Schreiben von asynchronem Code mit dem asyncio Bibliothek, Sie werden die verwenden async/await Schlüsselwörter zum Verwalten von Aufgaben.

Schlüsselkonzepte

Coroutinen: Dies sind Funktionen, die mit definiert sind async def . Sie sind der Kern von Asyncio und stellen Aufgaben dar, die angehalten und später wieder aufgenommen werden können.
Ereignisschleife: Es verwaltet die Ausführung von Aufgaben.
Aufgaben: Wrapper um Coroutinen. Wenn Sie möchten, dass eine Coroutine tatsächlich ausgeführt wird, verwandeln Sie sie in eine Aufgabe – z. verwenden asyncio.create_task()
await : Unterbricht die Ausführung einer Coroutine und gibt die Kontrolle wieder an die Ereignisschleife zurück.

Wie es funktioniert

Asyncio führt eine Ereignisschleife aus, die Aufgaben plant. Aufgaben „pausieren“ sich freiwillig, wenn sie auf etwas warten, beispielsweise auf eine Netzwerkantwort oder das Lesen einer Datei. Während die Aufgabe angehalten ist, wechselt die Ereignisschleife zu einer anderen Aufgabe, sodass keine Zeit mit Warten verschwendet wird.

Dies macht Asyncio best für Szenarien mit viele kleine Aufgaben, die viel Zeit mit Warten in Anspruch nehmenB. die Bearbeitung tausender Webanfragen oder die Verwaltung von Datenbankabfragen. Da alles in einem einzigen Thread läuft, vermeidet Asyncio den Overhead und die Komplexität des Thread-Wechsels.

Der Hauptunterschied zwischen Asyncio und Multithreading liegt in der Artwork und Weise, wie sie mit wartenden Aufgaben umgehen.

Multithreading ist darauf angewiesen, dass das Betriebssystem zwischen Threads wechselt, wenn ein Thread wartet (Präventiver Kontextwechsel).
Wenn ein Thread wartet, wechselt das Betriebssystem automatisch zu einem anderen Thread.
Asyncio verwendet einen einzelnen Thread und ist darauf angewiesen, dass Aufgaben „kooperieren“, indem sie pausieren, wenn sie warten müssen (kooperatives Multitasking).

2 Möglichkeiten, asynchronen Code zu schreiben:

methodology 1: await coroutine

Wenn Sie direkt await eine Coroutine, die Ausführung der Die aktuelle Coroutine pausiert am await Anweisung, bis die erwartete Coroutine beendet ist. Aufgaben werden ausgeführt Der Reihe nach innerhalb der aktuellen Coroutine.

Verwenden Sie diesen Ansatz, wenn Sie das Ergebnis der Coroutine benötigen sofort um mit den nächsten Schritten fortzufahren.

Auch wenn das wie synchroner Code klingt, ist es das nicht. Im synchronen Code würde das gesamte Programm während einer Pause blockieren.

Bei Asyncio pausiert nur die aktuelle Coroutine, während der Relaxation des Programms weiterlaufen kann. Dadurch ist Asyncio auf Programmebene nicht blockierend.

Beispiel:

Die Ereignisschleife hält die aktuelle Coroutine an, bis fetch_data ist abgeschlossen.

async def fetch_data():
print("Fetching knowledge...")
await asyncio.sleep(1)  # Simulate a community name
print("Information fetched")
return "knowledge"async def principal():
consequence = await fetch_data()  # Present coroutine pauses right here
print(f"Consequence: {consequence}")
asyncio.run(principal())

methodology 2: asyncio.create_task(coroutine)

Die Coroutine ist geplant laufen gleichzeitig im Hintergrund. Im Gegensatz zu awaitwird die aktuelle Coroutine sofort weiter ausgeführt, ohne auf den Abschluss der geplanten Aufgabe zu warten.

Die geplante Coroutine beginnt mit der Ausführung, sobald die Ereignisschleife eine Gelegenheit findetohne auf ein explizites warten zu müssen await.

Es werden keine neuen Threads erstellt. Stattdessen läuft die Coroutine im selben Thread wie die Ereignisschleife, die verwaltet, wann jede Aufgabe Ausführungszeit erhält.

Dieser Ansatz ermöglicht Parallelität innerhalb des Programms, sodass mehrere Aufgaben ihre Ausführung effizient überlappen können. Das werden Sie später noch tun müssen await die Aufgabe, das Ergebnis zu erhalten und sicherzustellen, dass es erledigt wird.

Verwenden Sie diesen Ansatz, wenn Sie Aufgaben gleichzeitig ausführen möchten und die Ergebnisse nicht sofort benötigen.

Beispiel:

Wenn die Linie asyncio.create_task() erreicht ist, die Coroutine fetch_data() Es ist geplant, mit der Ausführung zu beginnen sofort, wenn die Ereignisschleife verfügbar ist. Dies kann sogar passieren vor Sie ausdrücklich await die Aufgabe. Im Gegensatz dazu im ersten await Methode beginnt die Coroutine erst mit der Ausführung, wenn die await Aussage erreicht ist.

Insgesamt wird das Programm dadurch effizienter, da die Ausführung mehrerer Aufgaben überlappt.

async def fetch_data():
# Simulate a community name
await asyncio.sleep(1)
return "knowledge"async def principal():
# Schedule fetch_data
activity = asyncio.create_task(fetch_data())  
# Simulate doing different work
await asyncio.sleep(5)  
# Now, await activity to get the consequence
consequence = await activity  
print(consequence)
asyncio.run(principal())

Weitere wichtige Punkte

Sie können synchronen und asynchronen Code mischen.
Da synchroner Code blockiert, kann er mit in einen separaten Thread ausgelagert werden asyncio.to_thread(). Dadurch wird Ihr Programm effektiv multithreadfähig.
Im folgenden Beispiel wird die Asyncio-Ereignisschleife im Hauptthread ausgeführt, während ein separater Hintergrundthread zur Ausführung verwendet wird sync_task.

import asyncio
import timedef sync_task():
time.sleep(2)
return "Accomplished"
async def principal():
consequence = await asyncio.to_thread(sync_task)
print(consequence)
asyncio.run(principal())

Sie sollten CPU-gebundene Aufgaben, die rechenintensiv sind, auf einen separaten Prozess auslagern.

Dieser Ablauf ist eine gute Möglichkeit zu entscheiden, wann was verwendet werden soll.

Flussdiagramm (von mir gezeichnet), das sich darauf bezieht Stapelüberlauf Diskussion

Mehrfachverarbeitung
– Am besten für CPU-gebundene Aufgaben geeignet, die rechenintensiv sind.
– Wenn Sie die GIL umgehen müssen – Jeder Prozess verfügt über einen eigenen Python-Interpreter, der echte Parallelität ermöglicht.
Multithreading
– Am besten für schnelle I/O-gebundene Aufgaben geeignet, da die Häufigkeit des Kontextwechsels reduziert wird und der Python-Interpreter länger bei einem einzelnen Thread bleibt
– Aufgrund von GIL nicht best für CPU-gebundene Aufgaben.
Asyncio
– Supreme für langsame I/O-gebundene Aufgaben wie lange Netzwerkanfragen oder Datenbankabfragen, da es Wartezeiten effizient verarbeitet und dadurch skalierbar ist.
– Nicht für CPU-gebundene Aufgaben geeignet, ohne dass die Arbeit auf andere Prozesse verlagert wird.

Das ist es, Leute. Dieses Thema deckt noch viel mehr ab, aber ich hoffe, ich habe Ihnen die verschiedenen Konzepte und den Einsatz der einzelnen Methoden vorgestellt.

Danke fürs Lesen! Ich schreibe regelmäßig über Python, Softwareentwicklung und die Projekte, die ich erstelle, additionally folgen Sie mir, um nichts zu verpassen. Wir sehen uns im nächsten Artikel

[ad_2]