In diesem Tutorial erkunden wir das Lambda/hermes-agent-reasoning-traces-Datensatz um zu verstehen, wie agentenbasierte Modelle denken, Instruments verwenden und Antworten in Gesprächen mit mehreren Runden generieren. Wir beginnen mit dem Laden und Untersuchen des Datensatzes und untersuchen seine Struktur, Kategorien und Konversationsformat, um eine klare Vorstellung von den verfügbaren Informationen zu erhalten. Anschließend erstellen wir einfache Parser, um Schlüsselkomponenten wie Argumentationsspuren, Toolaufrufe und Toolantworten zu extrahieren und so internes Denken von externen Aktionen zu trennen. Außerdem analysieren wir Muster wie die Häufigkeit der Instrument-Nutzung, die Gesprächslänge und Fehlerraten, um das Agentenverhalten besser zu verstehen. Wir erstellen auch Visualisierungen, um diese Tendencies hervorzuheben und die Analyse intuitiver zu gestalten. Abschließend bereiten wir den Datensatz für das Coaching vor, indem wir ihn in ein modellfreundliches Format konvertieren, sodass er für Aufgaben wie überwachte Feinabstimmung geeignet ist.

!pip -q set up -U datasets pandas matplotlib seaborn transformers speed up trl


import json, re, random, textwrap
from collections import Counter, defaultdict
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datasets import load_dataset, concatenate_datasets


random.seed(0)


CONFIG = "kimi"
ds = load_dataset("lambda/hermes-agent-reasoning-traces", CONFIG, break up="prepare")
print(ds)
print("Config:", CONFIG, "| Fields:", ds.column_names)
print("Classes:", sorted(set(ds("class"))))


COMPARE_BOTH = False
if COMPARE_BOTH:
   ds_kimi = load_dataset("lambda/hermes-agent-reasoning-traces", "kimi", break up="prepare")
   ds_glm  = load_dataset("lambda/hermes-agent-reasoning-traces", "glm-5.1", break up="prepare")
   ds_kimi = ds_kimi.add_column("supply", ("kimi") * len(ds_kimi))
   ds_glm  = ds_glm.add_column("supply", ("glm-5.1") * len(ds_glm))
   ds = concatenate_datasets((ds_kimi, ds_glm)).shuffle(seed=0)
   print("Mixed:", ds, "→ counts:", Counter(ds("supply")))


pattern = ds(0)
print("n=== Pattern 0 ===")
print("id        :", pattern("id"))
print("class  :", pattern("class"), "/", pattern("subcategory"))
print("process      :", pattern("process"))
print("turns     :", len(pattern("conversations")))
print("system(0) :", pattern("conversations")(0)("worth")(:220), "...n")

Wir installieren alle erforderlichen Bibliotheken und importieren die notwendigen Module, um unsere Umgebung einzurichten. Anschließend laden wir den Datensatz „lambda/hermes-agent-reasoning-traces“ und überprüfen seine Struktur, Felder und Kategorien. Non-compulsory kombinieren wir auch mehrere Datensatzkonfigurationen und untersuchen eine Stichprobe, um das Konversationsformat zu verstehen.

THINK_RE     = re.compile(r"<assume>(.*?)</assume>", re.DOTALL)
TOOL_CALL_RE = re.compile(r"<tool_call>s*({.*?})s*</tool_call>", re.DOTALL)
TOOL_RESP_RE = re.compile(r"<tool_response>s*(.*?)s*</tool_response>", re.DOTALL)


def parse_assistant(worth: str) -> dict:
   ideas = (t.strip() for t in THINK_RE.findall(worth))
   calls = ()
   for uncooked in TOOL_CALL_RE.findall(worth):
       strive:
           calls.append(json.hundreds(uncooked))
       besides json.JSONDecodeError:
           calls.append({"identify": "<malformed>", "arguments": {}})
   last = TOOL_CALL_RE.sub("", THINK_RE.sub("", worth)).strip()
   return {"ideas": ideas, "tool_calls": calls, "last": last}


def parse_tool(worth: str):
   uncooked = TOOL_RESP_RE.search(worth)
   if not uncooked: return {"uncooked": worth}
   physique = uncooked.group(1)
   strive:    return json.hundreds(physique)
   besides: return {"uncooked": physique}


first_gpt = subsequent(t for t in pattern("conversations") if t("from") == "gpt")
p = parse_assistant(first_gpt("worth"))
print("Thought preview :", (p("ideas")(0)(:160) + "...") if p("ideas") else "(none)")
print("Instrument calls       :", ((c.get("identify"), record(c.get("arguments", {}).keys())) for c in p("tool_calls")))

Wir definieren Regex-basierte Parser, um Argumentationsspuren, Toolaufrufe und Toolantworten aus dem Datensatz zu extrahieren. Wir verarbeiten Hilfsmeldungen, um Gedanken, Handlungen und Endergebnisse auf strukturierte Weise zu trennen. Anschließend testen wir den Parser anhand einer Beispielkonversation, um sicherzustellen, dass die Extraktion ordnungsgemäß funktioniert.

N = 3000
sub = ds.choose(vary(min(N, len(ds))))


tool_calls         = Counter()
parallel_widths    = Counter()
thoughts_per_turn  = ()
calls_per_traj     = ()
errors_per_traj    = ()
turns_per_traj     = ()
cat_counts         = Counter()


for ex in sub:
   cat_counts(ex("class")) += 1
   n_calls = n_err = 0
   turns_per_traj.append(len(ex("conversations")))
   for t in ex("conversations"):
       if t("from") == "gpt":
           p = parse_assistant(t("worth"))
           thoughts_per_turn.append(len(p("ideas")))
           if p("tool_calls"):
               parallel_widths(len(p("tool_calls"))) += 1
               for c in p("tool_calls"):
                   tool_calls(c.get("identify", "<unknown>")) += 1
               n_calls += len(p("tool_calls"))
       elif t("from") == "software":
           r = parse_tool(t("worth"))
           blob = json.dumps(r).decrease()
           if "error" in blob or '"exit_code": 1' in blob or "traceback" in blob:
               n_err += 1
   calls_per_traj.append(n_calls)
   errors_per_traj.append(n_err)


print(f"nScanned {len(sub)} trajectories")
print(f"Avg turns/traj      : {np.imply(turns_per_traj):.1f}")
print(f"Avg software calls/traj : {np.imply(calls_per_traj):.1f}")
print(f"% with >=1 error    : {100*np.imply((e>0 for e in errors_per_traj)):.1f}%")
print(f"% parallel turns    : {100*sum(v for okay,v in parallel_widths.gadgets() if okay>1)/max(1,sum(parallel_widths.values())):.1f}%")
print("High 10 instruments        :", tool_calls.most_common(10))


fig, axes = plt.subplots(2, 2, figsize=(13, 9))


high = tool_calls.most_common(15)
axes(0,0).barh((t for t,_ in high)(::-1), (c for _,c in high)(::-1), colour="teal")
axes(0,0).set_title("High 15 instruments by name quantity")
axes(0,0).set_xlabel("calls")


ks = sorted(parallel_widths)
axes(0,1).bar((str(okay) for okay in ks), (parallel_widths(okay) for okay in ks), colour="coral")
axes(0,1).set_title("Instrument-calls per assistant flip (parallel width)")
axes(0,1).set_xlabel("# software calls in a single flip"); axes(0,1).set_ylabel("depend")
axes(0,1).set_yscale("log")


axes(1,0).hist(turns_per_traj, bins=40, colour="steelblue")
axes(1,0).set_title("Dialog size"); axes(1,0).set_xlabel("turns")


cats, vals = zip(*cat_counts.most_common())
axes(1,1).pie(vals, labels=cats, autopct="%1.0f%%", startangle=90)
axes(1,1).set_title("Class distribution")


plt.tight_layout(); plt.present()

Wir führen datensatzweite Analysen durch, um die Instrument-Nutzung, Gesprächslängen und Fehlermuster zu messen. Wir aggregieren Statistiken über mehrere Stichproben hinweg, um das allgemeine Agentenverhalten zu verstehen. Wir erstellen auch Visualisierungen, um Tendencies wie Werkzeughäufigkeit, Parallelanrufe und Kategorieverteilung hervorzuheben.

def render_trace(ex, max_chars=350):
   print(f"n{'='*72}nTASK ({ex('class')} / {ex('subcategory')}): {ex('process')}n{'='*72}")
   for t in ex("conversations"):
       position = t("from")
       if position == "system":
           proceed
       if position == "human":
           print(f"n(USER)n{textwrap.shorten(t('worth'), 600)}")
       elif position == "gpt":
           p = parse_assistant(t("worth"))
           for th in p("ideas"):
               print(f"n(THINK)n{textwrap.shorten(th, max_chars)}")
           for c in p("tool_calls"):
               args = json.dumps(c.get("arguments", {}))(:200)
               print(f"(CALL) {c.get('identify')}({args})")
           if p("last"):
               print(f"n(ANSWER)n{textwrap.shorten(p('last'), max_chars)}")
       elif position == "software":
           print(f"(TOOL_RESPONSE) {textwrap.shorten(t('worth'), 220)}")
   print("="*72)


idx = int(np.argmin(np.abs(np.array(turns_per_traj) - 10)))
render_trace(sub(idx))


def get_tool_schemas(ex):
   strive:    return json.hundreds(ex("instruments"))
   besides: return ()


schemas = get_tool_schemas(pattern)
print(f"nSample 0 has {len(schemas)} instruments obtainable")
for s in schemas(:3):
   fn = s.get("perform", {})
   print(" -", fn.get("identify"), "—", (fn.get("description") or "")(:80))


ROLE_MAP = {"system": "system", "human": "person", "gpt": "assistant", "software": "software"}


def to_openai_messages(conv):
   return ({"position": ROLE_MAP(t("from")), "content material": t("worth")} for t in conv)


example_msgs = to_openai_messages(pattern("conversations"))
print("nFirst 2 OpenAI messages:")
for m in example_msgs(:2):
   print(" ", m("position"), "→", m("content material")(:120).change("n", " "), "...")

Wir entwickeln Dienstprogramme, um vollständige Konversationsspuren in einem lesbaren Format für eine tiefergehende Untersuchung darzustellen. Wir extrahieren außerdem Toolschemata und konvertieren den Datensatz in ein Nachrichtenformat im OpenAI-Stil, um die Kompatibilität mit Trainingspipelines zu gewährleisten. Dies hilft uns, sowohl die Struktur der Instruments als auch die Artwork und Weise, wie Gespräche standardisiert werden können, besser zu verstehen.

from transformers import AutoTokenizer
TOK_ID = "Qwen/Qwen2.5-0.5B-Instruct"
tok = AutoTokenizer.from_pretrained(TOK_ID)


def build_masked(conv, tokenizer, max_len=2048):
   msgs = to_openai_messages(conv)
   for m in msgs:
       if m("position") == "software":
           m("position") = "person"
           m("content material") = "(TOOL OUTPUT)n" + m("content material")
   input_ids, labels = (), ()
   for m in msgs:
       textual content = tokenizer.apply_chat_template((m), tokenize=False, add_generation_prompt=False)
       ids = tokenizer.encode(textual content, add_special_tokens=False)
       input_ids.lengthen(ids)
       labels.lengthen(ids if m("position") == "assistant" else (-100) * len(ids))
   return input_ids(:max_len), labels(:max_len)


ids, lbls = build_masked(pattern("conversations"), tok)
trainable = sum(1 for x in lbls if x != -100)
print(f"nTokenized instance: {len(ids)} tokens, {trainable} trainable ({100*trainable/len(ids):.1f}%)")


think_lens, call_lens, ans_lens = (), (), ()
for ex in sub.choose(vary(min(500, len(sub)))):
   for t in ex("conversations"):
       if t("from") != "gpt": proceed
       p = parse_assistant(t("worth"))
       for th in p("ideas"): think_lens.append(len(th))
       for c in p("tool_calls"): call_lens.append(len(json.dumps(c)))
       if p("last"): ans_lens.append(len(p("last")))


plt.determine(figsize=(10,4))
plt.hist((think_lens, call_lens, ans_lens), bins=40, log=True,
        label=("<assume>", "<tool_call>", "last reply"), stacked=False)
plt.legend(); plt.xlabel("characters"); plt.title("Size distributions (log y)")
plt.tight_layout(); plt.present()


class TraceReplayer:
   def __init__(self, ex):
       self.ex = ex
       self.steps = ()
       pending = None
       for t in ex("conversations"):
           if t("from") == "gpt":
               if pending: self.steps.append(pending)
               pending = {"assume": parse_assistant(t("worth")), "responses": ()}
           elif t("from") == "software" and pending:
               pending("responses").append(parse_tool(t("worth")))
       if pending: self.steps.append(pending)
   def __len__(self): return len(self.steps)
   def play(self, i):
       s = self.steps(i)
       print(f"n── Step {i+1}/{len(self)} ──")
       for th in s("assume")("ideas"):
           print(f" {textwrap.shorten(th, 280)}")
       for c in s("assume")("tool_calls"):
           print(f"  {c.get('identify')}({json.dumps(c.get('arguments', {}))(:140)})")
       for r in s("responses"):
           print(f" {textwrap.shorten(json.dumps(r), 200)}")
       if s("assume")("last"):
           print(f" {textwrap.shorten(s('assume')('last'), 200)}")


rp = TraceReplayer(pattern)
for i in vary(min(3, len(rp))):
   rp.play(i)


TRAIN = False
if TRAIN:
   import torch
   from transformers import AutoModelForCausalLM
   from trl import SFTTrainer, SFTConfig


   train_subset = ds.choose(vary(200))


   def to_text(batch):
       msgs = to_openai_messages(batch("conversations"))
       for m in msgs:
           if m("position") == "software":
               m("position") = "person"; m("content material") = "(TOOL)n" + m("content material")
       batch("textual content") = tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=False)
       return batch


   train_subset = train_subset.map(to_text)


   mannequin = AutoModelForCausalLM.from_pretrained(
       TOK_ID,
       torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
       device_map="auto" if torch.cuda.is_available() else None,
   )


   cfg = SFTConfig(
       output_dir="hermes-sft-demo",
       per_device_train_batch_size=1,
       gradient_accumulation_steps=4,
       max_steps=20,
       learning_rate=2e-5,
       logging_steps=2,
       max_seq_length=1024,
       dataset_text_field="textual content",
       report_to="none",
       fp16=torch.cuda.is_available(),
   )
   SFTTrainer(mannequin=mannequin, args=cfg, train_dataset=train_subset, processing_class=tok).prepare()
   print("Wonderful-tune demo completed.")


print("n Tutorial full. You now have parsers, analytics, plots, a replayer, "
     "tokenized + label-masked SFT examples, and an optionally available coaching hook.")

Wir tokenisieren die Gespräche und wenden Etikettenmaskierung an, sodass nur die Antworten der Assistenten zum Coaching beitragen. Wir analysieren die Längenverteilungen von Begründungen, Werkzeugaufrufen und Antworten, um weitere Erkenntnisse zu gewinnen. Wir implementieren außerdem einen Hint-Replayer, um das Agentenverhalten schrittweise zu durchlaufen und optionally available eine kleine Feinabstimmungsschleife auszuführen.

Abschließend haben wir einen strukturierten Arbeitsablauf entwickelt, um die Argumentationsspuren von Agenten zu analysieren, zu analysieren und effektiv damit zu arbeiten. Wir konnten Gespräche in sinnvolle Komponenten zerlegen, Schritt für Schritt untersuchen, wie Agenten argumentieren, und messen, wie sie während der Problemlösung mit Instruments interagieren. Mithilfe der Visualisierungen und Analysen haben wir Einblicke in allgemeine Muster und Verhaltensweisen im gesamten Datensatz gewonnen. Darüber hinaus haben wir die Daten in ein Format konvertiert, das zum Trainieren von Sprachmodellen geeignet ist, einschließlich der Handhabung der Tokenisierung und Labelmaskierung für Assistentenantworten. Darüber hinaus bietet dieser Prozess eine solide Grundlage für die praktische und skalierbare Untersuchung, Bewertung und Verbesserung von KI-Systemen, die Werkzeuge verwenden.

Schauen Sie sich das an Vollständige Codes mit Pocket book. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 130.000+ ML SubReddit und Abonnieren Unser Publication. 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

haben wir AlpamayoR1 (AR1) besprochen, ein autonomes Fahrmodell, das einen VLM als logisches Rückgrat integriert. Es basiert auf einem sorgfältig gesammelten Datensatz zur Kausalkette. Das Coaching anhand dieses Datensatzes ermöglicht es AR1, in natürlicher Sprache zu „argumentieren“, um herausfordernde Fahrsituationen zu lösen.

Was aber, wenn natürliche Sprache nicht die beste Unterstützung für das Denken in Fahrszenarien ist? Denn wenn es um eine Fahrsituation geht, die eine sofortige Reaktion erfordert, handeln menschliche Fahrer in der Regel reflexartig und nicht „Schritt für Schritt in der Sprache argumentieren“. Was ist die Different für Fahrmodelle?

In diesem Artikel erläutern wir die LatentVLA-Architektur, eine überzeugende Sicht auf sprachbasierte Ansätze, die erforderlich sind kein Datensatz in natürlicher Sprache, führt Überlegungen im latenten Raum durch und Verwendungen Wissensdestillation um Echtzeitbeschränkungen zu erfüllen.

Latentes Aktionslernen

Ein großer Teil des Erfolgs von AR1 beruht auf dem Datensatz zur Kausalkette, dessen Erfassung einen industriellen Aufwand, eine sorgfältig ausgearbeitete Kennzeichnungspipeline und eine umfassende Validierung erforderte.

Im Gegensatz dazu schlägt LatentVLA eine völlig entgegengesetzte Richtung ein: Die Autoren argumentieren, dass rohe Fahrdaten bereits die Struktur enthalten, die zum Trainieren eines großen Modells erforderlich ist, und dass natürliche Sprache von Natur aus voreingenommen und schwer mit Aktionen abzugleichen ist. Darüber hinaus ist die Generierung von Argumentationsketten in natürlicher Sprache ineffizient, da einige Token keinen sinnvollen Beitrag zum Argumentationsprozess leisten (z. B. Stoppwörter).

Daher führen sie einen selbstüberwachten Rahmen ein, der zur Vorhersage eingesetzt wird egozentrische latente Handlungen in einem kleinen latenten Raum. Mit anderen Worten: Das Modell verwendet unbeschriftete Fahrdaten zur Vorhersage welche Maßnahmen der Fahrer ergriffen haben muss um diese Daten zu generieren. Diese latenten Handlungen werden als Bausteine ​​für das Denken im latenten Raum dienen.

Repräsentationslernen

Um latente Handlungen aus unbeschrifteten Daten vorherzusagen, verwenden die Autoren eine Methode, die an LAPO (Lernen, ohne Handlungen zu handeln) erinnert (2). Dieser Ansatz basiert auf einem Encoder-Decoder-Setup, bei dem der Encoder (auch als „Inverse-Dynamics-Modell“ (IDM) bezeichnet) zwei aufeinanderfolgende Frames verwendet, um einen kontinuierlichen Aktionsvektor vorherzusagen, und der Decoder (als „Ahead-Dynamics-Modell“ (FDM) bezeichnet) den aktuellen Body und den vorhergesagten Aktionsvektor verwendet, um den nächsten Body zu rekonstruieren.

Dieser clevere Aufbau zwingt die erlernte Aktionsdarstellung dazu, zu beschreiben, was Es müssen Maßnahmen ergriffen worden sein um die Zustandsübergänge in unserem Datensatz zu beobachten. Diese kontinuierliche Aktionsdarstellung ist jedoch immer noch nicht mit den VLMs kompatibel, die wir verwenden möchten. Um es zu diskretisieren, verwenden die Autoren einen VQ-VAE (Vector-Quantised Variational Auto-Encoder), der kontinuierliche Vektoren auf die nächstgelegenen diskreten Vektoren in einem erlernten System abbildet Codebuch (dh ein Wörterbuch diskreter Aktionen) auf differenzierbare Weise. Dies ist die Aktion, die vom FDM verwendet wird, um den nächsten Body zu dekodieren.

Durch die Optimierung des Rekonstruktionsfehlers des nächsten Frames haben wir IDM und FDM gemeinsam trainiert, um eine prädiktive Darstellung diskreter Aktionen zu codieren.

Unterscheidung von Ego-Aktionen und Umgebungslärm

Jetzt denken Sie vielleicht: „Die Aktionen des Fahrers sind nicht der einzige Faktor, der das nächste Bild während der Fahrt beeinflusst. Was wäre, wenn ein Vogel vor der Kamera fliegt? Verunreinigt das die Aktionsdarstellung?“ Darauf antworten die Autoren mit Ja Und Nein, es muss einen Mechanismus geben, der die Auswirkungen der Handlungen des Fahrers auf die Zukunft entwirrt Umweltdynamik.

Die elegante Lösung dieses Issues besteht in der Verwendung eines zweistufigen Encoder-Decoder-Aufbaus:

1. Abhängig von der Flugbahn der Grundwahrheit, dem Ego-Zustand und dem vorherigen Body sagt der Encoder eine latente Aktion voraus. Da diese Aktion durch die Flugbahn und den Ego-Zustand von der Fahrzeugdynamik abhängig ist, muss sie nur modelliert werden Umweltdynamik um dem Decoder die Rekonstruktion des nächsten Frames zu ermöglichen. Das „Umweltschutzmaßnahmen“ wird dann quantisiert und das hierfür verwendete Codebuch für die nächste Stufe eingefroren.
2. Bedingt durch den vorherigen Body und die Umweltmaßnahmenkodiert der Encoder eine weitere latente Aktion. Da die Umweltdynamik bekannt und Teil der Konditionierung ist, muss diese zweite latente Aktion ebenfalls kodiert werden egozentrische Dynamik. Mithilfe eines neuen Codebuchs wird diese Aktion in eine diskrete Quantisierung umgewandelt Ego-Aktion.

Schließlich geben wir beide Aktionen an den Decoder weiter, um den nächsten Body zu rekonstruieren. Dieser Aufbau gewährleistet eine klare Trennung von Ego-Aktionen und Umweltdynamik.

VLM-Schulung

Aufbauend auf der erlernten Aktionsdarstellung trainieren die Autoren ein Qwen2.5-VL-Modell, um dieselben latenten Aktionen wie das Encoder-Decoder-Modell vorherzusagen. Dies wird erreicht, indem der Encoder eine Trajektorie von 12 latenten Aktionen für einen bestimmten Eingaberahmen vorhersagt und der VLM seine unfavourable Log-Probability optimiert:

Ein auffälliger Unterschied zu anderen Ansätzen, die Aktionscodebücher verwenden, ist die Anzahl der von LatentVLA verwendeten Aktions-Tokens. Während andere Modelle wie AutoVLA ein Aktionscodebuch mit 2048 Spezialtoken verwenden, LatentVLA verwendet nur 16.

Daraus ergibt sich:

1. Eine einfachere Lernaufgabe: In einem 2048-dimensionalen Codebuch repräsentieren Aktionen wahrscheinlich sehr präzise Fahrentscheidungen wie „im 16-Grad-Winkel nach hyperlinks lenken“. Mit nur 16 Token übernimmt das Modell wahrscheinlich übergeordnete Anweisungen wie „leicht beschleunigen“ oder „eine schmale Rechtskurve nehmen“, deren Erlernen weniger Demonstrationen erfordert.
2. Bewahrung des VLM-Vorwissens vor dem Coaching: Es müssen nicht über 2000 „neue Wörter“ gelernt werden.

Wissensdestillation

Während AlpamayoR1 auf effiziente Tokenisierung und Circulate-Matching-Diffusion setzte, um die Echtzeitleistung aufrechtzuerhalten, verfolgt LatentVLA einen völlig anderen Ansatz: Wissensdestillation. Zu diesem Zweck führen die Autoren a Fusionsmodul innerhalb bestehender E2E-Architekturen (iPad (4) und Transfuser (5)). Dieses Fusionsmodul wird vom VLM mit visuellen und aktionsbezogenen Einbettungen versorgt und gibt Options im BEV-Raum (Chook’s-Eye-View) aus. Diese Einbettungen dienen als Schlüssel und Werte im Zusammenhang mit BEV-Abfragen, die vom E2E-Modell erzeugt werden. Dadurch kann das E2E-Modell Erkenntnisse aus dem VLM integrieren.

Allerdings bleibt der VLM zu groß, um zum Testzeitpunkt effizient genutzt zu werden. Daher ein kleines 50M-Parameter Entscheidungstransformator ist darauf trainiert, die Großen nachzuahmen 3.8B Qwen2.5-VL VLM. Dies wird durch die Minimierung der KL-Divergenz zwischen der Lehrer- und Schülerverteilung erreicht:

Dieses Framework ermöglicht LatentVLA den Betrieb mit einem sehr kompakten Argumentations-Spine und bietet einen allgemeinen Ansatz zur Integration von VLM-Wissen in traditionelle E2E-Architekturen zu geringeren Kosten.

Auswertung

LatentVLA wird auf NavSim (6) trainiert und ausgewertet, einem Datensatz, der aus über 100.000 Frames besteht, die in realen Fahrsimulationen gesammelt wurden. NavSim enthält außerdem a nicht reaktiv Simulator zur Bewertung der Open-Loop-Planung.

Mit anderen Worten: Die Modelle sagen anhand der Eingabebilder eine Flugbahn für die nächsten Sekunden voraus. Anschließend wird diese Trajektorie in einer BEV-Simulation ausgeführt, die unter der Annahme erfolgt, dass Aktionen des Ego-Fahrzeugs erfolgen keinen Einfluss haben die Aktionen anderer Agenten (additionally „nicht reaktiv“). Dies ermöglicht die einfache Messung planungsbezogener Metriken wie des Predictive Driver Mannequin Rating (PDMS): eine zusammengesetzte Metrik, die Fahrsicherheit, Leistung und Risiko durch Integration von Simulationsergebnissen quantifiziert.

Diese Artwork der Bewertung weist jedoch einige wichtige Mängel auf, auf die wir später noch eingehen werden.

Bei diesem Benchmark erzielt LatentVLA Ergebnisse auf dem neuesten Stand der Technik und übertrifft Commonplace-E2E- und LLM-basierte Architekturen. Allerdings scheint die Leistungssteigerung durch die Integration von VLM-Wissen in iPad und Transfuser begrenzt zu sein. Wenn wir uns auf das PDMS konzentrieren, stellen wir fest, dass die iPad-Basislinie einen Wert von 91,7 % erreicht. Die destillierte LatentVLA-Different erhöht den Wert auf 92,1 (+0,4 %) und die nicht destillierte Model erreicht 92,4 (weitere +0,3 %).

Diese kleine Verbesserung wirft die Frage auf, ob ein höheres Denkvermögen und Weltwissen wirklich für das Autofahren unerlässlich sind.

Meiner Meinung nach haben sie das Potenzial, ein neues Niveau an Fahrleistungen zu erschließen, aber dies wird von nicht interaktiven Planungssimulatoren nur unzureichend gemessen.

Die Grenzen der Open-Supply-Planung

In den letzten Jahren hat sich weitgehend die Einsicht durchgesetzt, dass nur die Bewertung von Fahrmodellen im Rahmen der Open-Loop-Planung ein unvollständiges Bild ihrer tatsächlichen Fahrfähigkeiten liefert. Tatsächlich unterscheidet sich die Planung im offenen Regelkreis grundlegend vom Autofahren und ist wohl einfacher. Der Hauptgrund dafür ist, dass die Open-Loop-Planung keine Interaktionen mit der Umgebung beinhaltet (bestenfalls der Simulator). nicht reaktiv) und reduziert sich auf die Nachahmung der Flugbahn eines Experten. Dies führt in realen Szenarien zu mehreren Problemen:

1. Kleine Abweichungen von den gelernten Trajektorien führen zu kaskadierenden Fehlern: Ohne dynamische Interaktionen mit der Umgebung und anderen Agenten haben Open-Loop-Modelle Schwierigkeiten, Flugbahnen zu korrigieren, die leicht von den gelernten abweichen.
2. Flugbahnen sind von Natur aus multimodal: Für jede Fahrsituation gibt es mehrere Trajektorien und Beschleunigungsmuster, die zu sicheren Fahrergebnissen führen. Durch Nachahmungslernen auf einer einzelnen Expertentrajektorie wird diese Multimodalität jedoch zerstört, wodurch die Generalisierungsfähigkeiten des Modells eingeschränkt werden.

Aus diesen Gründen ist es wichtig, Fahrmodelle in geschlossenen (d. h. reaktiven) Simulatoren gründlich zu evaluieren und rechtfertigt die Verwendung von RL-Put up-Coaching-Methoden, wie im AR1-Artikel beschrieben.

Ich wette, dass die Diskrepanz zwischen LatentVLA und seinen Nicht-VLM-Basislinien in diesen Szenarien größer ist, da Argumente dazu beitragen könnten, die Einschränkungen des Open-Loop-Trainings zu mildern.

Abschluss

In diesem Artikel haben wir LatentVLA besprochen, einen Ansatz, der darauf abzielt, VLM-Wissen in Commonplace-E2E-Modelle zu integrieren, ohne auf natürliche Sprache angewiesen zu sein. Dieser Ansatz ist insofern innovativ, als er das Erlernen nützlicher Darstellungen aus unbeschrifteten Daten ermöglicht, während konkurrierende Arbeiten wie AR1 auf sorgfältig annotierten umfangreichen Datensätzen basieren, um die Mehrdeutigkeit natürlicher Sprache zu umgehen.

LatentVLA würde jedoch von einer gründlicheren Evaluierung profitieren, insbesondere in geschlossenen Regelkreisen.

Vielen Dank, dass Sie bis hierher gelesen haben!

Wenn Sie diesen Artikel nützlich fanden, denken Sie bitte darüber nach es teilen; Es trägt wirklich dazu bei, den Zeit- und Arbeitsaufwand zu decken, der in die Erstellung dieser Arbeit investiert wird. Wie immer, zögern Sie nicht Kontaktieren Sie mich wenn Sie Fragen, Gedanken oder Ideen für Folgemaßnahmen haben. Wenn Sie meine unabhängige Forschung und mein Schreiben unterstützen möchten, können Sie dies gerne tun kauf mir einen Kaffee

Bis zum nächsten Mal!

Referenzen

1. LatentVLA
2. LAPO
3. VQ-VAE
4. iPad
5. Transfuser

Wie erhält man Argumente auf GPT-5-Ebene für reale Workloads mit langem Kontext und Werkzeugnutzung, ohne auf die quadratische Aufmerksamkeit und die GPU-Kosten zu achten, die diese Systeme normalerweise unpraktisch machen? DeepSeek-Forschung stellt vor DeepSeek-V3.2 und DeepSeek-V3.2-Speciale. Dabei handelt es sich um Reasoning-First-Modelle, die für Agenten entwickelt wurden und auf hochwertige Argumentation, lange Kontext- und Agenten-Workflows mit offenen Gewichtungen und Produktions-APIs abzielen. Die Modelle kombinieren DeepSeek Sparse Consideration (DSA), einen skalierten GRPO-Lernstapel zur Verstärkung und ein agentennatives Instrument-Protokoll und berichten über eine mit GPT 5 vergleichbare Leistung DeepSeek-V3.2-Speciale Erreichen des Gemini 3.0 Professional-Niveaus durch Argumentation bei öffentlichen Benchmarks und Wettbewerben.

Geringe Aufmerksamkeit mit nahezu linearen Kosten für lange Kontexte

Beide DeepSeek-V3.2 und DeepSeek-V3.2-Speciale Verwenden Sie den DeepSeek-V3 Combination of Specialists-Transformator mit etwa 671 B Gesamtparametern und 37 B aktiven Parametern professional Token, geerbt von V3.1 Terminus. Die einzige strukturelle Änderung ist DeepSeek Sparse Consideration, die durch kontinuierliches Vortraining eingeführt wurde.

DeepSeek Sparse Consideration teilt die Aufmerksamkeit in 2 Komponenten. A Blitzindexer führt eine kleine Anzahl von Köpfen mit niedriger Präzision über alle Token-Paare aus und erzeugt Relevanzwerte. A Feinkörniger Selektor Behält die Prime-Ok-Schlüsselwertpositionen professional Abfrage bei, und der Hauptaufmerksamkeitspfad führt Multi-Question-Consideration und Multi-Head-Latent-Consideration für diesen spärlichen Satz aus.

Dadurch ändert sich die vorherrschende Komplexität von O(L²) zu O(kL), wobei L die Sequenzlänge und ok die Anzahl der ausgewählten Token ist und viel kleiner als L ist. Basierend auf den Benchmarks, DeepSeek-V3.2 entspricht hinsichtlich der Genauigkeit der dichten Terminus-Basislinie und reduziert gleichzeitig die Kosten für lange Kontextinferenzen um etwa 50 Prozent, mit schnellerem Durchsatz und geringerer Speichernutzung auf {Hardware} der H800-Klasse sowie auf vLLM- und SGLang-Backends.

Fortsetzung des Pre-Trainings für DeepSeek Sparse Consideration

DeepSeek spärliche Aufmerksamkeit (DSA) wird durch fortlaufende Vorschulung eingeführt DeepSeek-V3.2 Endstation. In der dichten Aufwärmphase bleibt die dichte Aufmerksamkeit aktiv, alle Spine-Parameter werden eingefroren und nur der Lightning-Indexer wird mit einem Kullback-Leibler-Verlust trainiert, um der dichten Aufmerksamkeitsverteilung in 128K-Kontextsequenzen zu entsprechen. In dieser Section werden nur wenige Schritte und etwa 2 Milliarden Token benötigt, was ausreicht, damit der Indexer nützliche Ergebnisse erlernen kann.

In der Sparse-Section behält der Selektor 2048 Schlüsselwerteinträge professional Abfrage bei, das Spine wird freigegeben und das Modell trainiert weiter mit etwa 944 B Tokens. Steigungen für den Indexierer ergeben sich immer noch nur aus dem Ausrichtungsverlust bei starker Aufmerksamkeit auf die ausgewählten Positionen. Dieser Zeitplan macht DeepSeek spärliche Aufmerksamkeit (DSA) verhalten sich als Ersatz für dichte Aufmerksamkeit mit ähnlicher Qualität und geringeren langfristigen Kontextkosten.

GRPO mit mehr als 10 Prozent RL Compute

Zusätzlich zur spärlichen Architektur verwendet DeepSeek-V3.2 Group Relative Coverage Optimization (GRPO) als wichtigste Methode des verstärkenden Lernens. Das Forschungsteam gibt an, dass nach dem Coaching Verstärkungslernen Die RL-Rechenleistung übersteigt 10 Prozent der Rechenleistung vor dem Coaching.

RL ist nach Fachgebieten organisiert. Das Forschungsteam trainiert spezielle Läufe für Mathematik, Wettbewerbsprogrammierung, allgemeines logisches Denken, Shopping und Agentenaufgaben sowie Sicherheit und destilliert diese Spezialisten dann in die gemeinsame 685B-Parameterbasis für DeepSeek-V3.2 und DeepSeek-V3.2-Speciale. GRPO wird mit einem unvoreingenommenen KL-Schätzer, Off-Coverage-Sequenzmaskierung und Mechanismen zur Beibehaltung implementiert Mischung aus Experten (MoE) Routing- und Sampling-Masken, die zwischen Coaching und Sampling konsistent sind.

Agentendaten, Denkmodus und Toolprotokoll

Das DeepSeek-Forschungsteam erstellt einen großen Datensatz synthetischer Agenten, indem es mehr als 1.800 Umgebungen und mehr als 85.000 Aufgaben für Code-Agenten, Suchagenten, allgemeine Instruments und Code-Interpreter-Setups generiert. Aufgaben sind so konstruiert, dass sie schwer zu lösen und leicht zu überprüfen sind, und werden zusammen mit echten Codierungs- und Suchspuren als RL-Ziele verwendet.

Zum Zeitpunkt der Schlussfolgerung DeepSeek-V3.2 führt explizite Denk- und Nicht-Denkmodi ein. Der Deepseek-Reasoner-Endpunkt stellt standardmäßig den Denkmodus bereit, bei dem das Modell vor der endgültigen Antwort eine interne Gedankenkette erzeugt. Der Leitfaden „Denken mit Instruments“ beschreibt, wie Argumentationsinhalte über alle Instrument-Aufrufe hinweg beibehalten und gelöscht werden, wenn eine neue Benutzernachricht eintrifft, und wie Instrument-Aufrufe und Instrument-Ergebnisse im Kontext bleiben, selbst wenn der Argumentationstext auf das Price range gekürzt wird.

Die Chat-Vorlage wird entsprechend diesem Verhalten aktualisiert. Der DeepSeek-V3.2 Speciale Das Repository liefert Python-Encoder- und -Decoder-Helfer anstelle einer Jinja-Vorlage. Nachrichten können neben dem Inhalt auch ein Feld reasoning_content enthalten, das durch einen Denkparameter gesteuert wird. Eine Entwicklerrolle ist Suchagenten vorbehalten und wird in allgemeinen Chatflows von der offiziellen API nicht akzeptiert, was diesen Kanal vor versehentlichem Missbrauch schützt.

Benchmarks, Wettbewerbe und offene Artefakte

Zu Normal-Benchmarks für Argumentation und Kodierung, DeepSeek-V3.2 und vor allem DeepSeek-V3.2 Besonderes werden auf Suiten wie AIME 2025, HMMT 2025, GPQA und LiveCodeBench als vergleichbar mit GPT-5 und nahe an Gemini-3.0 Professional gemeldet, mit verbesserter Kosteneffizienz bei langen Kontext-Workloads.

Für formelle Wettbewerbe gibt das DeepSeek-Forschungsteam dies an DeepSeek-V3.2 Besonderes erreicht Leistungen auf Goldmedaillenniveau bei der Internationalen Mathematikolympiade 2025, der Chinesischen Mathematikolympiade 2025 und der Internationalen Informatikolympiade 2025 sowie wettbewerbsfähige Leistungen auf Goldmedaillenniveau bei den ICPC-Weltfinals 2025.

Wichtige Erkenntnisse

1. DeepSeek-V3.2 fügt DeepSeek Sparse Consideration hinzu, was zu nahezu linearen O(kL)-Aufmerksamkeitskosten führt und etwa 50 % niedrigere API-Kosten für lange Kontexte im Vergleich zu früheren dichten DeepSeek-Modellen liefert, während die Qualität ähnlich wie bei DeepSeek-V3.1 Terminus bleibt.
2. Die Modellfamilie behält das 671B-Parameter-MoE-Spine mit 37B aktiven Parametern professional Token bei und stellt ein vollständiges 128K-Kontextfenster in Produktions-APIs zur Verfügung, was lange Dokumente, mehrstufige Ketten und große Werkzeugspuren praktisch und nicht nur eine Laborfunktion darstellt.
3. Nach dem Coaching kommt Group Relative Coverage Optimization (GRPO) mit einem Rechenbudget von mehr als 10 Prozent des Vortrainings zum Einsatz, wobei der Schwerpunkt auf Mathematik, Code, allgemeinem Denken, Shopping oder Agentenarbeitsbelastung und Sicherheit liegt, zusammen mit Spezialisten im Wettbewerbsstil, deren Fälle zur externen Überprüfung freigegeben werden.
4. DeepSeek-V3.2 ist das erste Modell in der DeepSeek-Familie, das das Denken direkt in die Instrument-Nutzung integriert und sowohl denkende als auch nicht denkende Instrument-Modi sowie ein Protokoll unterstützt, bei dem internes Denken über alle Instrument-Aufrufe hinweg bestehen bleibt und nur bei neuen Benutzernachrichten zurückgesetzt wird.

Schauen Sie sich das an Papier Und Modellgewichte. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. 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.

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.

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

Kann ein iterativer Draft-Revise-Löser, der einen latenten Scratchpad wiederholt aktualisiert, weitaus größere autoregressive LLMs auf ARC-AGI übertreffen? Samsung SAIT (Montreal) hat veröffentlicht Winziges rekursives Modell (TRM)– ein zweischichtiger rekursiver Reasoner mit ca. 7 Millionen Parametern, der Berichte erstellt 44,6–45 % Testgenauigkeit auf ARC-AGI-1 Und 7,8–8 % An ARC-AGI-2was die Ergebnisse übertrifft, die für wesentlich größere Sprachmodelle wie DeepSeek-R1, o3-mini-high und Gemini 2.5 Professional bei denselben öffentlichen Bewertungen gemeldet wurden. TRM verbessert auch Puzzle-Benchmarks Sudoku-Extrem (87,4 %) Und Labyrinthhart (85,3 %) gegenüber dem Prior Hierarchisches Argumentationsmodell (HRM, 27 Mio. Parameter)wobei weitaus weniger Parameter und ein einfacheres Trainingsrezept verwendet werden.

Was genau ist neu?

TRM entfernt die Zwei-Modul-Hierarchie und die Festkomma-Gradientennäherung von HRM zugunsten von a einzelnes kleines Netzwerk Das rekursiert auf einem latenten „Notizblock“ (z) und a aktuelle Lösungseinbettung (y):

• Einzelner winziger wiederkehrender Kern. Ersetzt die Zwei-Modul-Hierarchie von HRM durch ein zweischichtiges Netzwerk, das gemeinsam einen latenten Notizblock 𝑧 z und eine aktuelle Lösung, die 𝑦 y einbettet, verwaltet. Das Modell wechselt: suppose: replace 𝑧 ← 𝑓 ( 𝑥 , 𝑦 , 𝑧 ) z←f(x,y,z) für 𝑛 n innere Schritte; Akt: aktualisieren 𝑦 ← 𝑔 ( 𝑦 , 𝑧 ) y←g(y,z).
• Tief überwachte Rekursion. Der Suppose→Act-Block ist bis zu 16 Mal abgerollt mit gründlicher Aufsicht und einem erlernten Haltekopf, der während des Trainings verwendet wird (vollständiges Ausrollen zum Testzeitpunkt). Signale werden über (y,z)(y, z)(y,z) über Schritte hinweg übertragen.
• Voller Backprop durch die Schleife. Im Gegensatz zu HRMs einstufiger impliziter (Festkomma-)Gradient Näherung, TRM führt eine Rückwärtsausbreitung durch alle rekursiven Schritte durchwas das Forschungsteam für die Verallgemeinerung als wesentlich erachtet.

Architektonisch bleibt das leistungsstärkste Setup für ARC/Maze erhalten Selbstaufmerksamkeit; Für die kleinen festen Gitter von Sudoku tauscht das Forschungsteam die Selbstaufmerksamkeit gegen eine aus Token-Mixer im MLP-Mixer-Stil. Eine kleine EMA (exponentieller gleitender Durchschnitt) Übergewichte stabilisieren das Coaching auf begrenzten Daten. Nettotiefe wird effektiv erzeugt durch Rekursion (z.B, T = 3, n = 6) anstatt Schichten zu stapeln; bei Ablationen, zwei Schichten besser verallgemeinern als tiefere Varianten bei gleicher effektiver Rechenleistung.

Die Ergebnisse verstehen

• ARC-AGI-1 / ARC-AGI-2 (zwei Versuche): TRM-Attn (7M): 44,6 % / 7,8 % vs HRM (27 Mio.): 40,3 % / 5,0 %. Die vom Forschungsteam gemeldeten LLM-Grundwerte: DeepSeek-R1 (671B) 15,8 % / 1,3 %, o3-mini-hoch 34,5 % / 3,0 %, Gemini 2.5 Professional 37,0 % / 4,9 %; größere maßgeschneiderte Grok-4-Einträge sind höher (66,7–79,6 % / 16–29,4 %).
• Sudoku-Excessive (9×9, 1 km Zug / 423 km Take a look at): 87,4 % mit aufmerksamkeitsfreiem Mixer vs. HRM 55,0 %.
• Labyrinthhart (30×30): 85,3 % vs. HRM 74,5 %.

Diese sind direkte Vorhersage Modelle, die von Grund auf auf kleinen, stark erweiterten Datensätzen trainiert wurden – kein „Fewly-Shot-Prompting“. ARC bleibt das kanonische Ziel; Der breitere Kontext und die Regeln der Rangliste (z. B. ARC-AGI-2-Grenzwert für den Hauptpreis bei 85 % privatem Satz) werden von der ARC Prize Basis verfolgt.

Warum kann ein 7M-Modell bei diesen Aufgaben viel größere LLMs schlagen?

1. Entscheidung-dann-Revision statt Token für Token: TRM entwirft eine vollständige Kandidatenlösung und verbessert sie dann latente iterative Konsistenzprüfungen gegen die Eingabe – Reduzierung der Belichtungsverzerrung durch autoregressive Dekodierung bei strukturierten Ausgaben.
2. Rechenaufwand für Argumentation während der Testzeit, nicht für die Parameteranzahl: Effektive Tiefe entsteht durch Rekursion (emulierte Tiefe ≈ T·(n+1)·Schichten), was den Forschern zufolge bei konstanter Berechnung eine bessere Verallgemeinerung ergibt als das Hinzufügen von Ebenen.
3. Strengere induktive Voreingenommenheit gegenüber Gitterbegründung: Bei kleinen festen Gittern (z. B. Sudoku) reduziert das aufmerksamkeitsfreie Mischen die Überkapazität und verbessert den Kompromiss zwischen Bias und Varianz. Die Selbstaufmerksamkeit bleibt bei größeren 30×30-Rastern erhalten.

Wichtige Erkenntnisse

• Architektur: Ein ~7M-paramiger, zweischichtiger rekursiver Löser, der latente „Denk“-Aktualisierungen 𝑧 ← 𝑓 ( 𝑥 , 𝑦 , 𝑧 ) z←f(x,y,z) und eine „Akt“-Verfeinerung 𝑦 ← 𝑔 ( 𝑦 , 𝑧 ) abwechselt y←g(y,z), unter intensiver Aufsicht bis zu 16 Schritte abgerollt; Gradienten werden durch die vollständige Rekursion propagiert (keine Festkomma-/IFT-Näherung).
• Ergebnisse: Berichte ~44,6–45 % An ARC-AGI-1 Und ~7,8–8 % An ARC-AGI-2 (zwei Versuche)und übertrifft damit mehrere viel größere LLMs, die im Vergleich der Forschungsarbeit genannt wurden (z. B. Gemini 2.5 Professional, o3-mini-high, DeepSeek-R1) unter dem angegebenen Evaluierungsprotokoll.
• Effizienz/Muster: Zeigt, dass die Zuweisung von Testzeitberechnungen zur rekursiven Verfeinerung (Tiefe durch Entrollen) die Parameterskalierung bei symbolisch-geometrischen Aufgaben übertreffen kann und ein kompaktes, von Grund auf neu entwickeltes Rezept mit öffentlich veröffentlichtem Code bietet.

Diese Untersuchung demonstriert einen zweischichtigen rekursiven Löser mit ca. 7 Millionen Parametern, der bis zu 16 Entwurfs-Überarbeitungs-Zyklen mit ca. 6 latenten Aktualisierungen professional Zyklus abwickelt und ca. 45 % für ARC-AGI-1 und ca. 8 % (zwei Versuche) für ARC-AGI-2 meldet. Das Forschungsteam veröffentlichte Code auf GitHub. ARC-AGI bleibt im großen Maßstab ungelöst (Ziel 85 % für ARC-AGI-2), sodass der Beitrag eher ein Ergebnis der Architektureffizienz als ein allgemeiner Schlussfolgerungsdurchbruch ist.

Schauen Sie sich das an Technisches Papier Und GitHub-Seite. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. 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.

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.

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

Generative KI wurde häufig wegen seiner Unfähigkeit, effektiv zu argumentieren, kritisiert, insbesondere in Szenarien, die präzise und deterministische Ergebnisse erfordern. Es hat sich als sehr schwierig erwiesen, den nächsten Token kaum vorherzusagen, wenn der nächste Token so genau sein muss wie eine einzelne Choice. Beispielsweise kann das Schreiben eines Aufsatzes tausend Formen annehmen und dennoch akzeptabel sein, aber die Lösung einer quadratischen Gleichung muss eine bestimmte endgültige Antwort liefern. Genau dieses Drawback hat Alibabas KI-Abteilung MarcoPolo dazu veranlasst, den bahnbrechenden Marco-o1 zu entwickeln großes Sprachmodell (LLM), der die Messlatte für komplexe Denkaufgaben höher legt. Dieses revolutionary Modell zeichnet sich in verschiedenen Bereichen wie Mathematik, Physik, Codierung und mehrsprachigen Anwendungen aus und bietet reale Lösungen für konventionelle und offene Herausforderungen.

Lernziele

• Das Konzept und die Bedeutung von Massive Reasoning Fashions (LRMs).
• Die wichtigsten technologischen Innovationen von Marco-o1 und wie sie es auszeichnen.
• Benchmarks und Ergebnisse unterstreichen seine fortschrittlichen Fähigkeiten.
• Praktische Anwendungen, insbesondere bei der mehrsprachigen Übersetzung.
• Einblicke in Transparenz, Herausforderungen und Zukunftspläne für Marco-o1.

Dieser Artikel wurde im Rahmen der veröffentlicht Knowledge Science-Blogathon.

Kerninnovationen hinter Marco-o1

Marco-o1 unterscheidet sich von anderen Modellen durch die Integration einer Kombination fortschrittlicher Techniken zur Optimierung von Argumentation, Entscheidungsfindung und Genauigkeit. Dies sind einige Dinge, die herkömmliche LLMs nicht leisten.

Hier ist ein Screenshot, der die beliebte Zählung des Buchstabens r im Wort „Erdbeere“ zeigt.

Chain-of-Thought (CoT) Feinabstimmung

Dieser Ansatz ermöglicht es dem Modell, Schritt für Schritt zu argumentieren und nachzuahmen, wie Menschen komplexe Probleme lösen. Die Feinabstimmung mit Open-Supply-CoT-Datensätzen und Alibabas proprietären synthetischen Datensätzen hat Marco-o1s Fähigkeit, komplizierte Aufgaben zu bewältigen, verbessert.

Monte-Carlo-Baumsuche (MCTS)

Mit dieser Methode kann das Modell mehrere Argumentationspfade erkunden, von umfassenden Strategien bis hin zu detaillierten Minischritten (z. B. die gleichzeitige Generierung von 32 oder 64 Token). MCTS erweitert den Lösungsraum und ermöglicht eine fundiertere Entscheidungsfindung.

Reflexionsmechanismen

Ein herausragendes Merkmal von Marco-o1 ist seine Fähigkeit zur Selbstreflexion. Das Modell bewertet seine Argumentationsprozesse, identifiziert Ungenauigkeiten und iteriert seine Ergebnisse, um bessere Ergebnisse zu erzielen.

Mehrsprachige Beherrschung

Marco-o1 zeichnet sich durch hervorragende Übersetzungen aus, da es mit beispielloser Leichtigkeit kulturelle Nuancen, idiomatische Ausdrücke und umgangssprachliche Ausdrücke handhabt, was es zu einem leistungsstarken Werkzeug für die globale Kommunikation macht.

Einige beeindruckende Benchmarks und Ergebnisse von Marco-o1

Die Fähigkeiten von Marco-o1 spiegeln sich in seinen beeindruckenden Leistungskennzahlen wider. Es hat erhebliche Verbesserungen bei Argumentations- und Übersetzungsaufgaben gezeigt:

• +6,17 % Genauigkeit beim englischen MGSM-Datensatz.
• +5,60 % Genauigkeit beim chinesischen MGSM-Datensatz.
• Außergewöhnlicher Umgang mit mehrsprachigen Übersetzungen, präzise Erfassung kultureller Feinheiten und umgangssprachlicher Phrasen.

Diese Ergebnisse stellen einen bedeutenden Fortschritt in der Fähigkeit des Modells dar, Sprache und Logik effektiv zu kombinieren.

Anwendungen: Mehrsprachige Übersetzung und darüber hinaus

Marco-o1 ist Vorreiter beim Einsatz von Massive Reasoning Fashions (LRM) in der maschinellen Übersetzung. Die mehrsprachigen Fähigkeiten des Modells gehen über die bloße Übersetzung hinaus, indem sie Skalierungsgesetze zum Zeitpunkt der Inferenz untersuchen, was es zu einem robusten Werkzeug für die globale Kommunikation macht. Es leistet Pionierarbeit beim Einsatz von LRMs in verschiedenen realen Szenarien:

• Mehrsprachige Übersetzung: Über grundlegende Übersetzungen hinaus nutzt es Skalierungsgesetze während der Inferenz, um die sprachliche Präzision und das Kontextbewusstsein zu verbessern.
• Kodierung und wissenschaftliche Forschung: Seine klaren Argumentationspfade machen es zu einem zuverlässigen Werkzeug zur Lösung von Programmierproblemen und zur Unterstützung wissenschaftlicher Entdeckungen.
• Globale Problemlösung: Ob im Bildungswesen, im Gesundheitswesen oder in der Wirtschaft, das Modell passt sich nahtlos an Aufgaben an, die Logik und Argumentation erfordern.

Transparenz und Open Entry

Alibaba hat mit der Veröffentlichung von Marco-o1 und seinen Datensätzen auf GitHub einen mutigen Schritt getan und so Zusammenarbeit und Innovation gefördert. Entwickler und Forscher haben Zugriff auf:

• Umfangreiche Dokumentation.
• Implementierungsleitfäden.
• Beispielskripte für die Bereitstellung, einschließlich der Integration mit Frameworks wie FastAPI mithilfe von vLLM (die wir in diesem Artikel sehen werden).

Diese Offenheit ermöglicht es der KI-Neighborhood, die Fähigkeiten von Marco-o1 für breitere Anwendungen zu verfeinern und zu erweitern.

Warum Marco-o1 wichtig ist

Die Enthüllung von Marco-o1 markiert einen entscheidenden Second in der KI-Entwicklung. Seine Fähigkeit, komplexe Probleme zu lösen, sich an mehrsprachige Kontexte anzupassen und sich selbst zu reflektieren, macht es an die Spitze der KI der nächsten Technology. Ob es darum geht, wissenschaftliche Herausforderungen anzugehen, differenzierte Texte zu übersetzen oder offene Fragen zu beantworten, Marco-o1 ist bereit, die Landschaft der KI-Anwendungen neu zu gestalten.

Für Forscher und Entwickler ist Marco-o1 nicht nur ein Werkzeug, sondern eine Einladung zur Zusammenarbeit bei der Neudefinition dessen, was KI leisten kann. Indem Marco-o1 die Lücke zwischen Argumentation und Kreativität schließt, setzt er einen neuen Normal für die Zukunft der künstlichen Intelligenz.

Praktisch: Marco-o1 mithilfe von Code erkunden

Das offizielle Github-Repo enthält schöne Beispiele, die Ihnen helfen, das Modell mit verschiedenen Anwendungsfällen zu testen. Weitere Beispiele finden Sie hier https://github.com/AIDC-AI/Marco-o1/tree/most important/examples

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
import torch
from vllm import LLM, SamplingParams
from transformers import AutoTokenizer

# Initialize FastAPI app
app = FastAPI()

# Outline a request mannequin utilizing Pydantic for validation
class ChatRequest(BaseModel):
    user_input: str  # The consumer's enter textual content
    historical past: record  # An inventory to retailer chat historical past

# Variables for mannequin and tokenizer
tokenizer = None
mannequin = None

@app.on_event("startup")
def load_model_and_tokenizer():
    """
    Load the mannequin and tokenizer as soon as throughout startup.
    This ensures sources are initialized solely as soon as, bettering effectivity.
    """
    international tokenizer, mannequin
    path = "AIDC-AI/Marco-o1"  # Path to the Marco-o1 mannequin
    tokenizer = AutoTokenizer.from_pretrained(path, trust_remote_code=True)
    mannequin = LLM(mannequin=path, tensor_parallel_size=4)  # Parallelize mannequin processing

def generate_response_stream(mannequin, textual content, max_new_tokens=4096):
    """
    Generate responses in a streaming vogue.
    :param mannequin: The language mannequin to make use of.
    :param textual content: The enter immediate.
    :param max_new_tokens: Most variety of tokens to generate.
    """
    new_output=""  # Initialize the generated textual content
    sampling_params = SamplingParams(
        max_tokens=1,  # Generate one token at a time for streaming
        temperature=0,  # Deterministic technology
        top_p=0.9  # Controls variety in token choice
    )
    with torch.inference_mode():  # Allow environment friendly inference mode
        for _ in vary(max_new_tokens):  # Generate tokens as much as the restrict
            outputs = mannequin.generate(
                (f'{textual content}{new_output}'),  # Concatenate enter and present output
                sampling_params=sampling_params,
                use_tqdm=False  # Disable progress bar for cleaner streaming
            )
            next_token = outputs(0).outputs(0).textual content  # Get the subsequent token
            new_output += next_token  # Append token to the output
            yield next_token  # Yield the token for streaming

            if new_output.endswith('</Output>'):  # Cease if the top marker is discovered
                break

@app.submit("/chat/")
async def chat(request: ChatRequest):
    """
    Deal with chat interactions by way of POST requests.
    :param request: Accommodates consumer enter and chat historical past.
    :return: Streamed response or error message.
    """
    # Validate consumer enter
    if not request.user_input:
        increase HTTPException(status_code=400, element="Enter can't be empty.")

    # Deal with exit instructions
    if request.user_input.decrease() in ('q', 'stop'):
        return {"response": "Exiting chat."}

    # Deal with clear command to reset chat historical past
    if request.user_input.decrease() == 'c':
        request.historical past.clear()
        return {"response": "Clearing chat historical past."}

    # Replace historical past with consumer enter
    request.historical past.append({"function": "consumer", "content material": request.user_input})

    # Create the mannequin immediate with historical past
    textual content = tokenizer.apply_chat_template(request.historical past, tokenize=False, add_generation_prompt=True)

    # Stream the generated response
    response_stream = generate_response_stream(mannequin, textual content)

    # Return the streamed response
    return StreamingResponse(response_stream, media_type="textual content/plain")

Der obige Code stammt aus dem offiziellen Repo. Wenn das Skript jedoch abstürzt, bevor es reagiert, liegt möglicherweise eine Diskrepanz zwischen der Speicherkapazität Ihrer GPU und den Anforderungen des Modells vor. Dies ist häufig der Fall, wenn Sie mit großen Modellen arbeiten, die mehr VRAM benötigen, als auf Ihrer GPU verfügbar ist. Da es sich um einen Fastapi-Code handelt, ist es sinnvoller, ihn auf Ihrem Laptop auszuführen, der möglicherweise nicht über einen geeigneten VRAM verfügt.

Ich habe versucht, ngrok zu verwenden, um die API mithilfe von Google Colab verfügbar zu machen, damit Sie dort die kostenlose GPU genießen können, die Sie in diesem Artikel-Repo finden: https://github.com/inuwamobarak/largeReasoningModels/tree/most important/Marco-01

Wrapper-Skript mit GPU

Um Ihnen beim Testen der Leistung dieses Modells zu helfen, finden Sie hier ein Wrapper-Skript, mit dem Sie es unterwegs in Google Colab mithilfe einer GPU ausführen können. Beachten Sie, dass ich Float 16 hinzugefügt habe und es über 13 GB GPU verbraucht.

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

Wrapper-Skript mit 16 Float-Genauigkeit:

class ModelWrapper:
    def __init__(self, model_name):
        self.system = torch.system("cuda" if torch.cuda.is_available() else "cpu")
        # Load mannequin with half-precision if supported, or use device_map for environment friendly placement
        strive:
            self.mannequin = AutoModelForCausalLM.from_pretrained(
                model_name, 
                torch_dtype=torch.float16 if torch.cuda.is_available() else None, 
                device_map="auto"
            )
        besides Exception as e:
            print(f"Error loading mannequin: {e}")
            increase
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)

        # Allow gradient checkpointing for big fashions
        self.mannequin.gradient_checkpointing_enable()

        # Debug: Test if mannequin is on GPU
        print(f"Mannequin loaded to system: {subsequent(self.mannequin.parameters()).system}")

    def generate_text(self, immediate, max_length=100, num_return_sequences=1):
        inputs = self.tokenizer(immediate, return_tensors="pt")
        inputs = {key: worth.to(self.system) for key, worth in inputs.objects()}  # Transfer inputs to GPU
        outputs = self.mannequin.generate(
            **inputs, max_length=max_length, num_return_sequences=num_return_sequences
        )
        generated_texts = (
            self.tokenizer.decode(output, skip_special_tokens=True) for output in outputs
        )
        return generated_texts

Beispiel eins

# Instance utilization
if __name__ == "__main__":
    model_name = "AIDC-AI/Marco-o1"
    model_wrapper = ModelWrapper(model_name)

    immediate = "As soon as upon a time, in a land far, far-off,"
    generated_texts = model_wrapper.generate_text(immediate, max_length=50, num_return_sequences=1)

    for i, textual content in enumerate(generated_texts):
        print(f"Generated Textual content {i+1}:n{textual content}n")

Mannequin loaded to system: cuda:0 Generated Textual content 1: As soon as upon a time, in a land far, far-off, there lived a king who was very keen on his backyard. He had an exquisite backyard with many flowers and bushes. Someday, he determined to plant some new bushes in his backyard. 

Beispiel zwei

immediate = "What number of S's are there in Mississippi"
generated_texts = model_wrapper.generate_text(immediate, num_return_sequences=1)

for i, textual content in enumerate(generated_texts):
    print(f"Generated Textual content {i+1}:n{textual content}n")

Generated Textual content 1:
What number of S's are there in Mississippi? To find out what number of 'S's are within the phrase "Mississippi," let's analyze the phrase step-by-step.

First, let's write out the phrase:
M-I-S-S-I-S-S-I-P-P-I

Now, let's establish every letter and rely the 'S's:
1. The primary letter is M.
2. The second letter is I.
3. The third letter is S.
4. The fourth letter is S.
5. The fifth letter is I.
6. The sixth letter is S.
7. The seventh letter is S.
8. The eighth letter is I.
9. The ninth letter is P.
10. The tenth letter is P.
11. The eleventh letter is I.

From this evaluation, we will see that the letters 'S' seem at positions 3, 4, 6, 7, and 11. That is a complete of 5 'S's.

To double-check, let's rely them once more:
- Place 3: S
- Place 4: S
- Place 6: S
- Place 7: S
- Place 11: S

Sure, there are certainly 5 'S's within the phrase "Mississippi."

Due to this fact, the variety of 'S's in Mississippi is boxed{4}. Wait, that is incorrect based mostly on the earlier rely. Let me recount fastidiously.

Upon re-examining:
1. M
2. I
3. S
4. S
5. I
6. S
7. S
8. I
9. P
10. P
11. I

Counting the 'S's:
- Place 3: S
- Place 4: S
- Place 6: S
- Place 7: S

That is 4 'S's. It appears I initially miscounted the final 'S' at place 11 as an 'I.' Due to this fact, the right variety of 'S's in Mississippi is boxed{4}. 

Nevertheless, to make sure accuracy, let's use one other technique. The phrase "Mississippi" has 11 letters in complete. The vowels are I, I, I, and I (4 'I's), and the consonants are M, S, S, S, S, P, P. Counting the 'S's among the many consonants offers us 4 'S's.

Sie werden feststellen, dass das Modell versucht, zu überlegen, wie es die ihm gestellten Probleme löst. Dies ist der Unterschied zwischen LRM und früheren LLMs.

Herausforderungen und Zukunftspläne

Während Marco-o1 neue Maßstäbe gesetzt hat, erkennt das Entwicklungsteam Raum für Wachstum. Die Argumentationsfähigkeiten des Modells sind strong, aber noch nicht vollständig optimiert. Um dieses Drawback anzugehen, plant Alibaba Folgendes zu integrieren:

• Final result Reward Modeling (ORM) und Course of Reward Modeling (PRM) zur Verfeinerung der Entscheidungsfindung.
• Verstärkungslerntechniken zur weiteren Verbesserung der Problemlösung.

Diese Bemühungen unterstreichen das Engagement von MarcoPolo für die Weiterentwicklung der Denkfähigkeiten der KI.

Abschluss

Marco-o1 stellt einen entscheidenden Fortschritt in der künstlichen Intelligenz dar, der kritische Einschränkungen traditioneller Sprachmodelle durch die Integration robuster Argumentations- und Entscheidungsfähigkeiten angeht. Seine bahnbrechenden Innovationen – die, wie wir gesehen haben, das Denken in der Gedankenkette, die Monte-Carlo-Baumsuche, die Selbstreflexion und die Beherrschung mehrerer Sprachen umfassen – demonstrieren einen neuen Normal für die Lösung komplexer, realer Probleme. Mit beeindruckenden Benchmarks und offenem Zugang zu seiner Architektur bietet Marco-o1 nicht nur branchenübergreifende transformative Lösungen, sondern lädt auch die globale KI-Neighborhood ein, zusammenzuarbeiten, um die Grenzen des Möglichen zu erweitern. Wir können sagen, dass Marco-o1 die Zukunft argumentationsgesteuerter Sprachmodelle veranschaulicht.

Wichtige Erkenntnisse

• Marco-o1 geht über die Token-Vorhersage hinaus, indem es Techniken wie Chain-of-Thought und Monte-Carlo-Baumsuche zur erweiterten Problemlösung einbezieht.
• Die Fähigkeit des Modells, seine Argumentation zu bewerten und zu verfeinern, zeichnet es aus und gewährleistet eine höhere Genauigkeit und Anpassungsfähigkeit.
• Unübertroffene Übersetzungsfähigkeiten ermöglichen es Marco-o1, kulturelle Nuancen und idiomatische Ausdrücke präzise zu verarbeiten.
• Durch die Veröffentlichung der Datensätze und Implementierungshandbücher von Marco-o1 auf GitHub fördert Alibaba die Zusammenarbeit und fördert weitere Fortschritte in der KI-Forschung.

Referenzlinks

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Ich bin ein KI-Ingenieur mit einer großen Leidenschaft für die Forschung und die Lösung komplexer Probleme. Ich biete KI-Lösungen an, die Massive Language Fashions (LLMs), GenAI, Transformer-Modelle und Secure Diffusion nutzen.