print("n" + "="*70 + "n4. Variable-length packed batch — no padding wasten" + "="*70)
seqlens = (37, 120, 8, 200)
whole = sum(seqlens)
H, Ok = 8, 64
q = torch.randn(1, whole, H, Ok, machine=machine, dtype=torch.float16)
okay = torch.randn(1, whole, H, Ok, machine=machine, dtype=torch.float16)
v = torch.randn(1, whole, H, Ok, machine=machine, dtype=torch.float16)
attempt:
   bias = ab.BlockDiagonalMask.from_seqlens(seqlens)
   out_packed = xops.memory_efficient_attention(q, okay, v, attn_bias=bias)
   s0 = seqlens(0)
   ref0 = vanilla_attention(q(:, :s0), okay(:, :s0), v(:, :s0)).half()
   print("packed form         :", tuple(out_packed.form), "(all", whole, "tokens, no pad)")
   print("segment-0 max diff   : {:.2e}".format((out_packed(:, :s0) - ref0).abs().max().merchandise()))
   cbias = ab.BlockDiagonalCausalMask.from_seqlens(seqlens)
   _ = xops.memory_efficient_attention(q, okay, v, attn_bias=cbias)
   print("-> additionally did a packed CAUSAL move. That is how vLLM-style engines")
   print("   batch requests of various lengths with zero padding overhead.")
   splits = bias.cut up(out_packed)
   print("recovered segments   :", (tuple(t.form) for t in splits))
besides Exception as e:
   print("BlockDiagonalMask path skipped on this model/backend:", repr(e))
print("n" + "="*70 + "n5. Grouped-query consideration (5-D BMGHK format)n" + "="*70)
B, M, Ok = 2, 256, 64
n_q_heads, n_kv_heads = 8, 2
G, Hq = n_kv_heads, n_q_heads // n_kv_heads
attempt:
   qg = torch.randn(B, M, G, Hq, Ok, machine=machine, dtype=torch.float16)
   kg = torch.randn(B, M, G, 1,  Ok, machine=machine, dtype=torch.float16)
   vg = torch.randn(B, M, G, 1,  Ok, machine=machine, dtype=torch.float16)
   out_gqa = xops.memory_efficient_attention(qg, kg, vg)
   print("GQA output form     :", tuple(out_gqa.form), "= (B, M, G, Hq, Ok)")
   print(f"-> {n_q_heads} question heads, solely {n_kv_heads} KV heads: smaller KV-cache,")
   print("   which is strictly what Llama-/Mistral-class fashions use at inference.")
besides Exception as e:
   print("GQA 5-D path skipped on this model/backend:", repr(e))

Aktie

Publish


Aktie

In diesem Artikel erfahren Sie, wie Sie lokal gehostete Sprachmodelle über Ollama verwenden, um Textklassifizierungsaufgaben durchzuführen, ohne einen Cent für API-Aufrufe auszugeben.

Zu den Themen, die wir behandeln werden, gehören:

• So installieren Sie Ollama und laden Open-Supply-Modelle wie Llama 3, Mistral und Gemma herunter, um sie lokal auf Ihrem Pc auszuführen.
• So konfigurieren Sie die Scikit-LLM-Bibliothek so, dass Anfragen an einen lokalen Ollama-Endpunkt statt an eine kostenpflichtige Cloud-API weitergeleitet werden.
• So erstellen Sie einen Zero-Shot-Textklassifizierer mithilfe eines lokalen Modells für große Sprachen und scikit-LLM in einem vertrauten Workflow im Scikit-Be taught-Stil.

Verwendung von Scikit-LLM mit Open-Supply-LLMs

Einführung

In diesem Artikel erfahren Sie, wie Sie eine Sprachaufgabe wie die Textklassifizierung durch die Integration lokal gehosteter großer Sprachmodelle (LLMs) überschaubarer Größe wie Mistral, Gemma und Llama 3 durchführen: alles kostenlos dank Ollama – ein kostenloses Repository für lokale LLMs – und das Scikit-LLM Python-Bibliothek.

Voraussetzung: Ollama installieren

Es wird empfohlen, zum Ausführen dieses Tutorials eine IDE zu verwenden, da wir von dort aus mit Ihrer lokal installierten Model von Ollama interagieren müssen. Neu in Ollama? Dann empfehle ich Ihnen, dies zu überprüfen dieser Artikel zuerst raus. Dennoch finden Sie hier eine Zusammenfassung dessen, was Sie im lokalen Befehlszeilenterminal tun müssen, um nach der Set up ein lokales LLM herunterzuladen Ollama auf Ihrem Pc.

Sobald Sie das Modellinteraktionsfenster im Terminal sehen, können Sie „/bye“ eingeben, damit es im Hintergrund weiterläuft und auf API-Aufrufe wartet. In der Zwischenzeit müssen in einem neu erstellten Projekt in Ihrer Python-IDE die folgenden Bibliotheken installiert sein:

Wenn beim Ausführen des Python-Codes der Fehler „Modul nicht gefunden“ auftritt, versuchen Sie, die oben genannten Abhängigkeiten nacheinander zu installieren.

Okay! Es ist Zeit, unsere Python-Codedatei Schritt für Schritt auszufüllen (benennen Sie sie nach Ihren Wünschen!). Zuerst kommen natürlich die Importe. Einer davon ist die Klasse ZeroShotGPTClassifier. Ähnlich wie beim klassischen Scikit-Be taught handelt es sich hierbei um eine spezielle Klasse für das Coaching und die Verwendung eines Modells für die Zero-Shot-Klassifizierung: konkret ein LLM von Ollama.

Als nächstes müssen wir einige spezifische Konfigurationen anwenden, um mit Ollama kommunizieren zu können.

Anschließend erstellen wir einen kleinen Datensatz und bereiten ihn für die Klassifizierung vor. Da wir in diesem Tutorial nicht die Klassifizierungsleistung des Modells bewerten werden – unser Hauptziel besteht darin, zu lernen, wie man Scikit-LLM lokal mit Open-Supply-Modellen wie den über Ollama verfügbaren verwendet –, benötigen wir keine große Anzahl von Datenbeispielen.

Der Datensatz enthält Benutzerbewertungen und die entsprechenden Kategorien, z. B. Arten von Kundenanfragen oder Suggestions. Wir haben auch wie üblich eine Schulungs-/Testaufteilung mit maschineller Lernmodellierung durchgeführt.

Im nächsten Teil des Codes fügen wir die notwendigen Anweisungen zum Initialisieren und Ausführen unseres Klassifikators hinzu, der im Kern eine aufgabenangepasste laufende Instanz eines unserer installierten Ollama-Modelle wie Llama 3 sein wird:

Zum Abschluss drucken wir einige Ausgaben aus, die aus einigen Modellinferenzergebnissen (Klassifizierungsvorhersagen) für die beiden im Testsatz enthaltenen Beispiele bestehen. Dies ist ein sehr kleiner Datensatz, aber das Ziel hier ist es zu zeigen, wie wir es geschafft haben, Scikit-LLM mit einem lokalen, kostenlosen Ollama-Modell zu verknüpfen, um ein LLM elegant und kostenlos für eine bestimmte Aufgabe zu nutzen!

Das Ergebnis (es kann je nach Ihren Testbeispielen variieren):

Alternativ können Sie Ihr Python-Skript auch von Ihrem Terminal aus ausführen. Zum Beispiel, wenn Sie es benannt haben local_classification.pyführen Sie diesen Befehl aus:

So oder so, wenn Sie alle Schritte befolgt haben, sollte es funktionieren. Intestine gemacht!

Zusammenfassung

In diesem Artikel wurde erläutert, wie Sie kostenlose, lokal ausgeführte Modelle, die über Ollama bereitgestellt werden, wie Llama, Mistral oder Gemma, austauschen können – alles kostenlos und in wenigen einfachen Schritten – dank der Scikit-LLM-Bibliothek von Python, die die Verwendung modernster LLMs innerhalb eines vertrauten klassischen maschinellen Lernworkflows ermöglicht.

Aktie

Publish


Aktie

eventualities = (
   {
       "title": "Secure database learn",
       "device": research_db,
       "kwargs": {
           "desk": "prospects",
           "operation": "choose",
           "kind": "choose",
           "sensitivity": "medium"
       }
   },
   {
       "title": "Blocked harmful database motion",
       "device": research_db,
       "kwargs": {
           "desk": "prospects",
           "operation": "drop",
           "kind": "drop_table",
           "sensitivity": "crucial"
       }
   },
   {
       "title": "Exterior e mail requiring approval",
       "device": research_email,
       "kwargs": {
           "to": "(e mail protected)",
           "recipient_domain": "instance.com",
           "topic": "Quarterly replace",
           "physique": "Sharing a non-confidential quarterly replace.",
           "kind": "send_email",
           "sensitivity": "medium"
       }
   },
   {
       "title": "Exterior e mail denied attributable to approval rejection",
       "device": research_email,
       "kwargs": {
           "to": "(e mail protected)",
           "recipient_domain": "instance.com",
           "topic": "Confidential technique",
           "physique": "This incorporates confidential technique.",
           "kind": "send_email",
           "sensitivity": "crucial"
       }
   },
   {
       "title": "Secure sandbox shell command",
       "device": ops_shell,
       "kwargs": {
           "command": "echo Agent governance is lively",
           "kind": "shell_exec",
           "sensitivity": "low"
       }
   },
   {
       "title": "Harmful shell command blocked",
       "device": ops_shell,
       "kwargs": {
           "command": "rm -rf /content material/one thing",
           "kind": "shell_exec",
           "sensitivity": "crucial"
       }
   },
   {
       "title": "Low-trust agent blocked from delicate information",
       "device": shadow_db,
       "kwargs": {
           "desk": "executive_compensation",
           "operation": "choose",
           "kind": "choose",
           "sensitivity": "crucial"
       }
   },
   {
       "title": "Monetary switch requiring approval",
       "device": finance_transfer,
       "kwargs": {
           "quantity": 2500,
           "vacation spot": "vendor-123",
           "kind": "transfer_money",
           "sensitivity": "excessive"
       }
   },
   {
       "title": "Giant monetary switch rejected",
       "device": finance_transfer,
       "kwargs": {
           "quantity": 15000,
           "vacation spot": "vendor-999",
           "kind": "transfer_money",
           "sensitivity": "crucial"
       }
   },
)
outcomes = ()
for state of affairs in eventualities:
   strive:
       output = state of affairs("device")(**state of affairs("kwargs"))
       outcomes.append({
           "state of affairs": state of affairs("title"),
           "standing": "executed",
           "output": output
       })
   besides Exception as e:
       outcomes.append({
           "state of affairs": state of affairs("title"),
           "standing": "blocked_or_pending",
           "error": str(e)
       })
audit_df = audit_log.to_dataframe()
display_cols = (
   "timestamp",
   "agent_name",
   "tool_name",
   "choice",
   "matched_rule",
   "severity",
   "cause",
   "record_hash"
)
show(audit_df(display_cols))
test_cases = (
   {
       "title": "drop_table should be denied",
       "id": research_agent,
       "tool_name": "query_database",
       "motion": {"kind": "drop_table", "sensitivity": "crucial", "autonomous": True},
       "anticipated": "deny"
   },
   {
       "title": "secure choose ought to be allowed",
       "id": research_agent,
       "tool_name": "query_database",
       "motion": {"kind": "choose", "sensitivity": "low", "autonomous": True},
       "anticipated": "enable"
   },
   {
       "title": "exterior e mail ought to require approval",
       "id": research_agent,
       "tool_name": "send_email",
       "motion": {
           "kind": "send_email",
           "recipient_domain": "instance.com",
           "sensitivity": "medium",
           "autonomous": True
       },
       "anticipated": "require_approval"
   },
   {
       "title": "low belief delicate entry denied",
       "id": unknown_agent,
       "tool_name": "query_database",
       "motion": {"kind": "choose", "sensitivity": "crucial", "autonomous": True},
       "anticipated": "deny"
   },
   {
       "title": "shell command ought to enter sandbox",
       "id": ops_agent,
       "tool_name": "shell_exec",
       "motion": {
           "kind": "shell_exec",
           "command": "echo whats up",
           "sensitivity": "low",
           "autonomous": True
       },
       "anticipated": "sandbox"
   },
)
test_results = ()
for check in test_cases:
   choice = engine.consider(
       id=check("id"),
       tool_name=check("tool_name"),
       motion=check("motion")
   )
   handed = choice.choice == check("anticipated")
   test_results.append({
       "check": check("title"),
       "anticipated": check("anticipated"),
       "precise": choice.choice,
       "handed": handed,
       "matched_rule": choice.matched_rule
   })
test_df = pd.DataFrame(test_results)
show(test_df)
engine.activate_kill_switch()
strive:
   research_db(
       desk="prospects",
       operation="choose",
       kind="choose",
       sensitivity="low"
   )
besides Exception as e:
   move
engine.deactivate_kill_switch()
audit_df = audit_log.to_dataframe()
abstract = (
   audit_df
   .groupby(("choice", "severity"), dropna=False)
   .measurement()
   .reset_index(title="depend")
   .sort_values("depend", ascending=False)
)
show(abstract)
agent_summary = (
   audit_df
   .groupby(("agent_name", "choice"))
   .measurement()
   .reset_index(title="depend")
   .sort_values(("agent_name", "depend"), ascending=(True, False))
)
show(agent_summary)
decision_counts = audit_df("choice").value_counts()
plt.determine(figsize=(8, 5))
decision_counts.plot(form="bar")
plt.title("Governance Selections Throughout Agent Actions")
plt.xlabel("Choice")
plt.ylabel("Depend")
plt.xticks(rotation=30)
plt.tight_layout()
plt.present()
severity_counts = audit_df("severity").fillna("none").value_counts()
plt.determine(figsize=(8, 5))
severity_counts.plot(form="bar")
plt.title("Governance Occasions by Severity")
plt.xlabel("Severity")
plt.ylabel("Depend")
plt.xticks(rotation=30)
plt.tight_layout()
plt.present()
G = nx.DiGraph()
for _, row in audit_df.iterrows():
   agent_node = f"Agent: {row('agent_name')}"
   tool_node = f"Instrument: {row('tool_name')}"
   decision_node = f"Choice: {row('choice')}"
   rule_node = f"Rule: {row('matched_rule')}" if pd.notna(row("matched_rule")) else "Rule: default"
   G.add_node(agent_node, node_type="agent")
   G.add_node(tool_node, node_type="device")
   G.add_node(decision_node, node_type="choice")
   G.add_node(rule_node, node_type="rule")
   G.add_edge(agent_node, tool_node, relation="calls")
   G.add_edge(tool_node, decision_node, relation="produces")
   G.add_edge(decision_node, rule_node, relation="matched")
plt.determine(figsize=(14, 9))
pos = nx.spring_layout(G, seed=42, okay=0.8)
nx.draw_networkx_nodes(G, pos, node_size=1800)
nx.draw_networkx_edges(G, pos, arrows=True, arrowstyle="->", arrowsize=15)
nx.draw_networkx_labels(G, pos, font_size=8)
plt.title("Agent Governance Graph: Brokers, Instruments, Selections, and Coverage Guidelines")
plt.axis("off")
plt.tight_layout()
plt.present()
EXPORT_DIR = "/content material/agt_tutorial_outputs"
os.makedirs(EXPORT_DIR, exist_ok=True)
audit_json_path = os.path.be a part of(EXPORT_DIR, "tamper_evident_audit_log.json")
audit_csv_path = os.path.be a part of(EXPORT_DIR, "governance_audit_log.csv")
policy_copy_path = os.path.be a part of(EXPORT_DIR, "advanced_agent_policy.yaml")
test_results_path = os.path.be a part of(EXPORT_DIR, "policy_test_results.csv")
with open(audit_json_path, "w") as f:
   json.dump((asdict(r) for r in audit_log.data), f, indent=2, default=str)
audit_df.to_csv(audit_csv_path, index=False)
test_df.to_csv(test_results_path, index=False)
shutil.copy(POLICY_PATH, policy_copy_path)

import subprocess, sys
def pip(*pkgs):
   subprocess.check_call((sys.executable, "-m", "pip", "set up", "-q", *pkgs))
pip("llmcompressor", "compressed-tensors",
   "transformers>=4.45", "speed up", "datasets")
import os, gc, time, json, math
from pathlib import Path
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset
assert torch.cuda.is_available(), 
   "Allow a GPU: Runtime > Change runtime sort > T4 GPU"
print("GPU:", torch.cuda.get_device_name(0),
     "| CUDA:", torch.model.cuda,
     "| torch:", torch.__version__)
MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
WORKDIR = Path("/content material/quant_lab"); WORKDIR.mkdir(exist_ok=True)
os.chdir(WORKDIR)
def free_mem():
   gc.accumulate(); torch.cuda.empty_cache()
def dir_size_gb(path):
   complete = 0
   for root, _, information in os.stroll(path):
       for f in information:
           complete += os.path.getsize(os.path.be part of(root, f))
   return complete / 1e9
def time_generation(mannequin, tok, immediate, max_new_tokens=64):
   """Grasping decode; reviews latency & tokens/sec after a short warmup."""
   inputs = tok(immediate, return_tensors="pt").to(mannequin.system)
   _ = mannequin.generate(**inputs, max_new_tokens=4, do_sample=False)
   torch.cuda.synchronize()
   t0 = time.time()
   out = mannequin.generate(**inputs, max_new_tokens=max_new_tokens,
                        do_sample=False, pad_token_id=tok.eos_token_id)
   torch.cuda.synchronize()
   dt = time.time() - t0
   new_ids = out(0)(inputs("input_ids").form(1):)
   return tok.decode(new_ids, skip_special_tokens=True), dt, max_new_tokens/dt
@torch.no_grad()
def wikitext_ppl(mannequin, tok, seq_len=512, max_chunks=20, stride=512):
   """Gentle WikiText-2 perplexity probe (quick, indicative)."""
   ds = load_dataset("wikitext", "wikitext-2-raw-v1", cut up="take a look at")
   textual content = "nn".be part of(t for t in ds("textual content")(:400) if t.strip())
   enc = tok(textual content, return_tensors="pt").input_ids.to(mannequin.system)
   nll_sum, tok_count = 0.0, 0
   for start in vary(0, enc.dimension(1) - seq_len, stride):
       chunk = enc(:, start:start+seq_len)
       out = mannequin(chunk, labels=chunk)
       nll_sum += out.loss.float().merchandise() * seq_len
       tok_count += seq_len
       if tok_count // seq_len >= max_chunks: break
   return math.exp(nll_sum / tok_count)
outcomes = {}
PROMPT = ("<|im_start|>usernIn two sentences, clarify why post-training "
         "quantization works for big language fashions.<|im_end|>n"
         "<|im_start|>assistantn")
def benchmark(label, model_path_or_id):
   free_mem()
   print(f"n──── benchmarking: {label} ────")
   tok = AutoTokenizer.from_pretrained(model_path_or_id)
   m = AutoModelForCausalLM.from_pretrained(
           model_path_or_id, torch_dtype="auto", device_map="cuda").eval()
   pattern, dt, tps = time_generation(m, tok, PROMPT)
   ppl = wikitext_ppl(m, tok)
   dimension = dir_size_gb(model_path_or_id) if os.path.isdir(str(model_path_or_id)) else None
   outcomes(label) = {"size_gb": dimension, "ppl": spherical(ppl, 3),
                     "latency_s": spherical(dt, 3), "tok_per_s": spherical(tps, 1),
                     "pattern": pattern.strip().substitute("n", " ")(:180)}
   print(json.dumps(outcomes(label), indent=2))
   del m; free_mem()

# Einführung

Im letzten Jahrzehnt Pandas conflict die Grundlage für die Datenarbeit in Python. Bei Datensätzen, die in den Speicher passen, ist es schnell und vertraut genug, dass einem Programmierer kaum in den Sinn kommt, die Bibliothek zu wechseln.

Sobald Sie jedoch mit der Arbeit mit Millionen von Zeilen beginnen, treten die Schwachstellen auf: Groupby-Vorgänge, die mehrere Sekunden dauern, Zwischenkopien, die RAM verbrauchen, und Fensterfunktionen, die als Schleifen auf Python-Ebene statt vektorisiert ausgeführt werden C oder Rost Code.

Polaren ist eine auf Rust basierende DataFrame-Bibliothek Apache-Pfeil. Es wurde mit den erstklassigen Merkmalen Parallelität und verzögerte Auswertung entwickelt. Pandas führt jeden Vorgang im Voraus und nacheinander aus, während Polars einen Abfrageplan erstellen und ihn vor der Ausführung optimieren kann, wobei die meisten Vorgänge automatisch auf allen verfügbaren CPU-Kernen gleichzeitig ausgeführt werden.

In diesem Artikel untersuchen wir drei reale Datenprobleme anhand realer Fragen aus dem StrataScratch Codierungsplattform. Für jedes Downside vergleichen wir die Lösungen beider Bibliotheken und zeigen auf, wo der Leistungsunterschied am wichtigsten ist.

# Verwendung von rank() vs. with_row_count(): Aktivitätsrang

In diese FrageZiel ist es, den E-Mail-Aktivitätsrang für jeden Benutzer basierend auf der Gesamtzahl der gesendeten E-Mails zu ermitteln. Der Benutzer mit den meisten E-Mails erhält Rang 1. Die Ergebnisse müssen nach der Gesamtzahl der E-Mails in absteigender Reihenfolge sortiert werden, wobei die alphabetische Reihenfolge als Tiebreaker verwendet wird, und jeder Rang muss eindeutig sein, auch wenn zwei Benutzer die gleiche E-Mail-Anzahl haben.

// Datenansicht

Der google_gmail_emails Die Tabelle speichert eine Zeile professional gesendeter E-Mail mit einer Absender-ID (from_user), Empfänger-ID (to_user) und den Tag, an dem die E-Mail gesendet wurde. Hier ist eine Vorschau der Tabelle:

Getreide (was eine Ausgabezeile bedeutet): ein Benutzer mit seiner gesamten E-Mail-Anzahl und seinem eindeutigen Aktivitätsrang.

// Häufiger Fehler

Die Frage fragt nach einem eindeutigen Rang, auch wenn zwei Benutzer die gleiche E-Mail-Anzahl haben. Ein häufiger Fehler ist die Verwendung von rank(technique='dense') Methode in Pandas, die gleichrangigen Benutzern den gleichen Rang zuweist. Die richtige Methode ist 'first'wodurch Bindungen nach Place im sortierten Rahmen aufgelöst werden. Da wir alphabetisch nach sortieren user_id Vor dem Rating sind die resultierenden Ränge eindeutig und deterministisch.

Die optimale Lösung von Polar vermeidet das rank voll funktionsfähig. Nach dem Sortieren nach ("total_emails", "user_id") in absteigender bzw. aufsteigender Reihenfolge .with_row_count("activity_rank", offset=1) Die Klausel weist sequentielle Ganzzahlen beginnend bei 1 zu. Es ist keine Tie-Breaking-Logik erforderlich, da die Sortierung dies bereits verarbeitet hat.

// Lösungen

1. Pandas-Lösung

Wir benennen um from_user Zu user_idnach Benutzer gruppieren, E-Mails zählen, den ersten Rang berechnen und nach E-Mail-Anzahl in absteigender Reihenfolge sortieren, mit alphabetischer Gleichstandstrennung.

import pandas as pd
import numpy as np
google_gmail_emails = google_gmail_emails.rename(columns={"from_user": "user_id"})
end result = google_gmail_emails.groupby(
    ('user_id')).dimension().to_frame('total_emails').reset_index()
end result('activity_rank') = end result('total_emails').rank(technique='first', ascending=False)
end result = end result.sort_values(by=('total_emails', 'user_id'), ascending=(False, True))

2. Polare Lösung

Wir verwenden a faule Kette das in einem einzigen Durchgang umbenennt, gruppiert, sortiert und Zeilennummern zuweist. Berufung .acquire() Am Ende materialisiert sich das Ergebnis.

import polars as pl
google_gmail_emails = google_gmail_emails.rename({"from_user": "user_id"})
end result = (
    google_gmail_emails.lazy()
    .group_by("user_id")
    .agg(total_emails = pl.depend())
    .kind(
        by=("total_emails", "user_id"),
        descending=(True, False)
    )
    .with_row_count("activity_rank", offset=1)
    .choose((
        pl.col("user_id"),
        "total_emails",
        "activity_rank"
    ))
    .acquire()
)

// Leistungsvergleich

Die Pandas-Lösung durchläuft die Daten nach der Gruppierung zweimal: einmal zur Berechnung der Größen und einmal zur Zuweisung von Rängen. Innen, rank(technique='first') weist ein Rangarray zu, löst Bindungen über argsort auf und schreibt zurück – was erheblich aufwendiger ist als die Suche nach einer einzelnen Spalte. Die Polaren group_by Die Funktion verteilt die Arbeitslast auf alle verfügbaren CPU-Kerne, was zu einer deutlich schnelleren Aggregation bei großen Tabellen führt. Und seit dem .with_row_count() Die Klausel ist ein einzelner sequenzieller O(n)-Durchlauf nach der Sortierung und ersetzt die Rangfunktion durch die kostengünstigste mögliche Operation. Bei einer Tabelle mit Millionen von E-Mail-Datensätzen kann die Verwendung der parallelen Aggregation ohne Rangfunktion zu einer 5- bis 10-fachen Verbesserung der Arbeitszeit im Vergleich zum Pandas-Ansatz führen.

Hier ist die Vorschau der Codeausgabe:

# Verwendung von cumcount() + Pivot() vs. over(): Suche nach Benutzerkäufen

In diese Fragewerden wir gebeten, wiederkehrende aktive Benutzer zu identifizieren – insbesondere diejenigen, die innerhalb von 1 und 7 Tagen nach ihrem ersten einen zweiten Kauf getätigt haben. Einkäufe, die am selben Tag getätigt wurden, sollten nicht berücksichtigt werden. Das Ergebnis ist lediglich eine Liste der qualifizierten Personen user_id Werte.

// Datenansicht

Der amazon_transactions Tabelle hat eine Zeile professional Kauf, mit user_id, merchandise, created_at Datum und income.

Hier ist eine Vorschau der Tabelle:

Getreide (was eine Ausgabezeile bedeutet): eine Benutzer-ID, die innerhalb von 7 Tagen nach ihrem ersten Kauf einen qualifizierten Rückkauf getätigt hat.

// Randgehäuse

Einkäufe am selben Tag sollten ignoriert werden, d. h. die Lücke zwischen dem ersten und zweiten Einkauf darf mehr als 0 Tage betragen und darf höchstens 7 Tage betragen. Ein Kunde, der am selben Tag zweimal kauft, ist nicht qualifiziert.

// Lösungen

Beide Lösungen ermitteln das früheste Kaufdatum jedes Benutzers und filtern dann nach Folgekäufen innerhalb des Zeitrahmens von 1 bis 7 Tagen. Eine Sache, die Sie beachten sollten: Wenn created_at Hat Zeitstempel anstelle von einfachen Datumsangaben, müssen Sie vor dem Vergleich auf das Datum kürzen. Andernfalls würden zwei Käufe, die zu unterschiedlichen Zeiten am selben Tag getätigt würden, fälschlicherweise die strenge Ungleichung erfüllen.

1. Pandas-Lösung

Bei Pandas besteht die Lösung darin, eindeutige Kaufdaten professional Benutzer zu isolieren und diese in eine Rangfolge zu bringen cumcount()Drehen, um das erste und zweite Datum nebeneinander anzuzeigen, und Berechnen der Tagesdifferenz.

import pandas as pd
amazon_transactions("purchase_date") = pd.to_datetime(amazon_transactions("created_at")).dt.date
day by day = amazon_transactions(("user_id", "purchase_date")).drop_duplicates()
ranked = day by day.sort_values(("user_id", "purchase_date"))
ranked("rn") = ranked.groupby("user_id").cumcount() + 1
first_two = (ranked(ranked("rn") <= 2)
             .pivot(index="user_id", columns="rn", values="purchase_date")
             .reset_index()
             .rename(columns={1: "first_date", 2: "second_date"}))
first_two = first_two.dropna(subset=("second_date"))
first_two("diff") = (pd.to_datetime(first_two("second_date")) - pd.to_datetime(first_two("first_date"))).dt.days
end result = first_two((first_two("diff") >= 1) & (first_two("diff") <= 7))(("user_id"))

2. Polare Lösung

Die Polars-Lösung beinhaltet die Berechnung des ersten Kaufdatums professional Benutzer als Fensterausdruck mit .over("user_id")Filterung nach Käufen, die in das Zeitfenster passen, und Rückgabe einer deduplizierten Datei user_id Liste.

import polars as pl
# returning energetic customers: 2nd buy 1–7 days after the primary (ignore same-day)
returning_users = (
    amazon_transactions
    .lazy()
    # first buy date per consumer (window so we keep away from .groupby on LazyFrame)
    .with_columns(
        pl.col("created_at").min().over("user_id").alias("first_purchase_date")
    )
    # maintain transactions strictly 1-7 days after that first buy
    .filter(
        (pl.col("created_at") > pl.col("first_purchase_date")) &
        (pl.col("created_at") <= pl.col("first_purchase_date") + pl.period(days=7))
    )
    # distinct consumer checklist
    .choose("user_id")
    .distinctive()
    .kind("user_id", descending=(False))
)

// Leistungsvergleich

Beachten Sie die Anzahl unterschiedlicher DataFrame-Zuweisungen in der Pandas-Lösung: die deduplizierte Tagestabelle, die sortierte Rangtabelle, der Pivot-Body usw dropna Ergebnis und die gefilterte Ausgabe. Diese bestehen aus fünf separaten Objekten, von denen jedes Daten in einen neuen Speicherblock kopiert. Bei einer großen Transaktionstabelle kann allein der Pivot-Schritt die Speichernutzung erheblich erhöhen, da er den gesamten Datensatz in ein breites Format umformt.

Die Lazy-Chain von Polars reserviert bis dahin keinen Speicher .acquire(). Der .over("user_id") Der Fensterausdruck berechnet das früheste Kaufdatum jedes Benutzers in einem Durchgang .filter() gilt sofort im selben Schritt, und .distinctive() läuft gleichzeitig auf allen CPU-Kernen. Es gibt keinen Pivot, keine sortierte Zwischenkopie und keinen separaten Datumsumwandlungsschritt – Polars verarbeitet die Datumsarithmetik nativ innerhalb der Ausdrucks-Engine. Dieser Ansatz verbraucht weniger Speicher und wird schneller ausgeführt, selbst bei mittelgroßen Datensätzen.

Hier ist die Vorschau der Codeausgabe:

# Verwendung von develop().imply() vs. cum_mean(): Gleitender monatlicher Umsatzdurchschnitt

In diese Fragewerden wir gebeten, einen kumulativen Durchschnitt für die monatlichen Buchverkäufe im Jahr 2022 zu ermitteln. Der Durchschnitt wächst jeden Monat unter Verwendung aller vorangegangenen Monate: Februar bildet den Durchschnitt für Januar und Februar, März den Durchschnitt für alle drei und so weiter. Die Ausgabe sollte den Monat, den Gesamtumsatz dieses Monats und den kumulierten Durchschnitt, gerundet auf die nächste ganze Zahl, umfassen.

// Datenansicht

Der amazon_books Die Tabelle hat eine Zeile professional Buch und ihren Einheitspreis. Der book_orders Die Tabelle enthält eine Zeile professional Bestellung, die eine Buch-ID mit einer Menge und einem Bestelldatum verknüpft. Hier ist eine Vorschau der Tabelle:

Der book_orders Die Tabelle enthält eine Zeile professional Buchbestellung, die jede Bestell-ID mit einem Bestelldatum, einer Buch-ID und der bestellten Menge verknüpft:

Getreide (was eine Ausgabezeile bedeutet): ein Monat im Jahr 2022, mit Gesamtverkäufen für diesen Monat und einem kumulierten Durchschnitt aller monatlichen Verkäufe bis einschließlich dieses Monats.

// Kompromisse

Mit Pandas, dem .increasing().imply() Die Klausel ist praktisch, arbeitet aber intern mit einer Schleife auf Python-Ebene über wachsende Fensterabschnitte. Bei einer monatlichen Zusammenfassung mit 12 Zeilen sind diese Kosten vernachlässigbar. Bei täglichen oder stündlichen Daten im großen Maßstab (z. B. stündliche Transaktionen über drei Jahre) erhöht jedes expandierende Fenstersegment den Overhead, der Zeile für Zeile ansteigt.

Polaren cum_mean() führt einen einzelnen Durchgang in Rust aus und ist im Maßstab von Natur aus schneller. Es gibt einen Haken: Die Frage muss auf die nächste ganze Zahl gerundet werden, und Pandas verwendet standardmäßig die Banker-Rundung (halbe auf gerade runden). Die Polars-Lösung verwendet NumPys Cumsum mit einem expliziten ground(x + 0.5) Formel zur Durchsetzung des Spherical-Half-Up-Verhaltens. Wenn Sie eine genaue Übereinstimmung mit der erwarteten Ausgabe benötigen, ist die NumPy-Methode zuverlässiger als die integrierte Rundung in beiden Bibliotheken.

// Lösungen

1. Pandas-Lösung

Wir führen Bücher mit Bestellungen zusammen, filtern nach 2022, aggregieren die monatlichen Verkäufe und bewerben uns .increasing().imply() um den kumulativen Durchschnitt zu berechnen.

import pandas as pd
import numpy as np
import datetime as dt
merged = pd.merge(book_orders, amazon_books, on="book_id", how="inside")
merged("order_date") = pd.to_datetime(merged("order_date"))
merged("order_month") = merged("order_date").dt.month
merged("yr") = merged("order_date").dt.yr
merged("gross sales") = merged("unit_price") * merged("amount")
merged = merged.loc((merged("yr") == 2022), :)
end result = (
    merged.groupby("order_month")("gross sales")
    .sum()
    .to_frame("monthly_sales")
    .sort_values(by="order_month")
    .reset_index()
)
end result("rolling_average") = end result("monthly_sales").increasing().imply().spherical(0)
end result

2. Polare: Aufbau der Lazy Pipeline und Sammeln

Wir verbinden die beiden Tabellen innerhalb einer Lazy Chain und berechnen den Umsatz als unit_price * amountnach 2022 filtern, nach Monat aggregieren und aufrufen .acquire() um vor dem NumPy-Rolling-Schritt in den Keen-Modus zu wechseln.

import polars as pl
import numpy as np
# Step 1: Put together month-to-month gross sales (LazyFrame)
monthly_sales_lazy = (
    book_orders.lazy()
    .be part of(amazon_books.lazy(), on="book_id", how="inside")
    .with_columns((
        (pl.col("unit_price") * pl.col("amount")).alias("gross sales"),
        pl.col("order_date").forged(pl.Datetime),
        pl.col("order_date").dt.yr().alias("yr"),
        pl.col("order_date").dt.month().alias("order_month")
    ))
    .filter(pl.col("yr") == 2022)
    .group_by("order_month")
    .agg(pl.col("gross sales").sum().alias("monthly_sales"))
    .kind("order_month")
)
# Step 2: Change to keen mode for rolling computation
monthly_sales = monthly_sales_lazy.acquire()

3. Berechnen des gleitenden Durchschnitts und Abschluss

Mit den monatlichen Verkäufen als NumPy-Array wenden wir eine Rundung zur Hälfte an, fügen das Ergebnis wieder zum Polars DataFrame hinzu und wählen die Ausgabespalten aus.

# Step 3: Rolling common with round-half-up
sales_np = monthly_sales("monthly_sales").to_numpy()
cumsum = np.cumsum(sales_np)
rolling_avg = np.ground(cumsum / np.arange(1, len(cumsum)+1) + 0.5).astype(int)
# Step 4: Add again to Polars DataFrame
monthly_sales = monthly_sales.with_columns((
    pl.Sequence("rolling_average", rolling_avg)
))
# Step 5: Closing end result with appropriate column names
end result = monthly_sales.choose(("order_month", "monthly_sales", "rolling_average"))

// Leistungsvergleich

Bei dieser Frage wirken sich zwei Vorgänge am stärksten auf die Leistung aus: der Be a part of und das kumulative Fenster. Bei Pandas, pd.merge Verbindet alle Zeilen aus beiden Tabellen, bevor nach 2022 gefiltert wird. Dies bedeutet, dass die Bestellungen jedes Jahres verarbeitet werden, bevor Zeilen außerhalb des Zielzeitraums verworfen werden. Polars erstellt einen Lazy-Question-Plan und pusht den filter(yr == 2022) Bedingung, bevor der Be a part of ausgeführt wird, sodass von Anfang an ein kleinerer Datensatz verknüpft wird. Dieser Prädikat-Pushdown erfolgt automatisch, ohne dass zusätzliches Schreiben erforderlich ist.

Der auffälligste Unterschied ist die Lücke im gleitenden Durchschnitt. Pandas .increasing().imply() Vergrößert sein Fenster zeilenweise, ruft für jedes Section C auf und bleibt dabei von einer Python-Schleife gesteuert. Polaren cum_mean() berechnet die gesamte Spalte in einer einzigen Rust-Schleife ohne Python-Overhead. Während der Unterschied bei monatlichen Daten möglicherweise nicht wahrnehmbar ist, wenn Sie dieselbe Abfrage drei Jahre lang (ungefähr 1.000 Zeilen) für tägliche Daten ausführen, wird die Polars-Model in Mikrosekunden abgeschlossen, während Pandas aufgrund des erweiterten Fensters eine messbare Latenz aufweist.

Hier ist die Vorschau der Codeausgabe:

# Abschluss

Bei allen drei Problemen folgen die Polars-Lösungen demselben Muster: Erstellen Sie einen Lazy-Question-Plan, übertragen Sie so viele Berechnungen wie möglich in den Optimierer und rufen Sie ihn auf .acquire() nur, wenn Sie ein konkretes Ergebnis benötigen.

Die Syntax erfordert einige Anpassungen, wenn Sie, wie die meisten Analysten, seit Jahren Pandas-Gewohnheiten haben, die Vorgänge jedoch eng übereinstimmen. .groupby() wird .group_by(), .rename() nimmt ein einfaches Diktat anstelle eines columns= Schlüsselwort, und das Rating wird zu einer Sortierung, gefolgt von .with_row_count().

Der wahre Unterschied zeigt sich im Maßstab. Bei kleinen Datensätzen liefern beide Bibliotheken Ergebnisse schnell genug, sodass der Unterschied nicht spürbar ist. Wenn die Anzahl der Zeilen Millionen erreicht, sind die Parallelitäts- und Single-Cross-Algorithmen auf Rust-Ebene von Polars deutlich überlegen. Wenn bei Pandas Leistungsprobleme auftreten, sind diese drei Herausforderungen ein guter Ausgangspunkt für die Migration.

Nate Rosidi ist Datenwissenschaftler und in der Produktstrategie tätig. Er ist außerdem außerordentlicher Professor für Analytik und Gründer von StrataScratch, einer Plattform, die Datenwissenschaftlern hilft, sich mit echten Interviewfragen von Prime-Unternehmen auf ihre Interviews vorzubereiten. Nate schreibt über die neuesten Tendencies auf dem Karrieremarkt, gibt Ratschläge zu Vorstellungsgesprächen, stellt Information-Science-Projekte vor und behandelt alles rund um SQL.

oder einfach dequeist eine ungewöhnliche Artwork der Sammlung. Wenn wir im Web suchen, finden wir viele Informationen zu Hear, Wörterbüchern und Tupeln, aber wenig zu Deque.

Deque (man kann es auch aussprechen „Deck“ ) ist eine interessante und nützliche Sammlungsart in Python. Was es von anderen Objekten unterscheidet, ist, dass es nur die gewünschte Anzahl an Elementen enthält oder weniger, niemals mehr.

Es funktioniert additionally genauso wie ein Deckmit dem FIFO-System (First In, First Out). Sobald das Deck voll ist und Sie ein weiteres Factor hinzufügen, wird das erste Factor auf der linken Seite gelöscht und das neue auf der rechten Seite hinzugefügt.

Sehen wir uns einige grundlegende Beispiele an, um diese Sammlung zu verstehen. Importieren Sie es zunächst aus Sammlungen: from collections import deque.

Erstellen einer Deque

Als nächstes erstellen wir ein einfaches Deck und fügen ihm eine maximale Länge von 3 Artikeln hinzu.

# Create a brand new deque with 3 (or much less) parts
my_deck = deque(maxlen = 3)

# Including one component
my_deck.append(1)
my_deck.append(2)
my_deck.append(3)

# View
my_deck
# deque((1, 2, 3))

Hübsch. Wenn unser Deck voll ist, beobachten Sie, was passiert, wenn ich versuche, ihm einen weiteren Wert hinzuzufügen. Das erste Factor auf der linken Seite (1) wird gelöscht und öffnet Platz für das neue Factor, das rechts angehängt wird (additional).

# It drops the primary component and provides the brand new one on the finish.
my_deck.append('additional')
deque((2, 3, 'additional'))

Es funktioniert genauso wie ein Deck mit dem FIFO-System (First In, First Out).

Elemente hyperlinks anhängen

Denken Sie daran, dass die Sammlung den Namen hat doppelendige Warteschlange ; Sie können additionally auch hyperlinks Elemente anhängen oder erweitern. In diesem Fall wird das Factor natürlich ganz rechts abgelegt.

# Append to left
my_deck.appendleft('left')
# (OUT): deque(('left', 2, 3))

# Prolong to left
my_deck.extendleft(('d', 'd'))
#(OUT): deque(('d', 'd', 'left'))

Elemente drehen

Sie können die Elemente auch drehen und sie um eine (oder mehrere) Positionen nach rechts oder hyperlinks verschieben.

# Create a brand new deque with 3 (or much less) parts
my_deck = deque(maxlen = 3)

# Including one component
my_deck.lengthen((1,2,3)) # deque((1, 2, 3))
# Rotating the weather by one place to the proper
my_deck.rotate() # deque((3, 1, 2))

# Rotate to the left
my_deck.rotate(-1) # deque((1, 2, 3))

Neben der Drehung ist es einfach, das Mähwerk komplett umzudrehen.

# New deck
my_deck.lengthen((1, 2, 3)) 
#(OUT): deque((1, 2, 3))

# Reverse deck
my_deck.reverse() 
# (OUT): deque((3, 2, 1))

Elemente entfernen

In einem Deck können Sie ein Factor von hyperlinks, rechts oder nach Namen entfernen.

# New deck
my_deck = deque(maxlen = 3)
my_deck.lengthen((1, 2, 3)) 
# (OUT): deque((1, 2, 3))

# Take away merchandise from the left
my_deck.popleft() 
# (OUT): deque((2, 3))

#---

# New deck
my_deck = deque(maxlen = 3)
my_deck.lengthen((1, 2, 3)) 
# (OUT): deque((1, 2, 3))

# Take away merchandise from the proper
my_deck.pop() 
# (OUT): deque((1, 2))

#---

# New deck
my_deck = deque(maxlen = 3)
my_deck.lengthen((1, 'a', 3)) 
# (OUT): deque((1, 'a', 3))

# Take away merchandise by identify
my_deck.take away('a') 
# (OUT): deque((1, 3))

Sie können auch alle Gegenstände entfernen und Ihr Deck leeren.

my_deck.clear() 
#(OUT): deque(())

Anwendungen

1. Der „Aktuelle Suchverlauf“ (Speicherverwaltung)

Während Hear ins Unendliche wachsen, deque hat ein maxlen Parameter. Dies ist perfekt für Funktionen wie „Zuletzt angesehen“ oder „Letzter Suchverlauf“, bei denen Sie nur den letzten behalten möchten N Elemente, ohne die alten manuell zu löschen.

# Hold solely the final 3 person searches
search_history = deque(maxlen=3)

search_history.append("Python tutorials")
search_history.append("Machine Studying")
search_history.append("Knowledge Science")
search_history.append("Deep Studying") # "Python tutorials" is robotically eliminated

print(record(search_history))
# Output: ('Machine Studying', 'Knowledge Science', 'Deep Studying')

2. Stay-Datenstream und gleitende Durchschnitte

In der Datenwissenschaft oder im IoT müssen Sie häufig einen gleitenden Durchschnitt eines Stroms berechnen (z. B. Temperatursensoren oder Aktienkurse). Mit a deque ermöglicht Ihnen die effiziente Verwaltung eines „gleitenden Datenfensters“.

def moving_average(stream, window_size=5):
    window = deque(maxlen=window_size)
    for val in stream:
        window.append(val)
        if len(window) == window_size:
            yield sum(window) / window_size

# Utilization: Calculating common of a sensor studying stream
data_stream = (20, 21, 20, 22, 23, 25, 24)
print(record(moving_average(data_stream, window_size=3)))

3. Multithread-Aufgabenwarteschlangen (Thread-Sicherheit)

Einer der „versteckten“ Vorteile von deque in CPython ist das so .append() Und .popleft() Sind Thread-sicher. Dies macht es zu einer ausgezeichneten Wahl für ein einfaches Producer-Client-Muster, bei dem ein Thread Aufgaben hinzufügt und ein anderer sie ausführt.

import threading
from collections import deque

task_queue = deque()

def producer():
    for i in vary(5):
        task_queue.append(f"Activity {i}") # Thread-safe append

def client():
    whereas True:
        attempt:
            activity = task_queue.popleft() # Thread-safe pop
            print(f"Processing {activity}")
        besides IndexError:
            break

Sehen wir uns das in Aktion an.

# Generate Duties
producer()
task_queue
# (OUT) deque(('Activity 0', 'Activity 1', 'Activity 2', 'Activity 3', 'Activity 4'))

# Eat Duties
client()
# (OUT)
# Processing Activity 0
# Processing Activity 1
# Processing Activity 2
# Processing Activity 3
# Processing Activity 4

# Test Queue
task_queue
# (OUT) deque(())

Bevor Sie gehen

Nun kennen Sie eine andere Artwork von Python-Sammlung. Sie können Ihrer Kreativität freien Lauf lassen und neue Wege finden, Ihr Programm oder Skript zu erstellen.
Die Zusammenfassung dieses Artikels ist einfach:

• Syntax: deque(maxlen = n) Wo Nist die Anzahl der Elemente, die in Ihrem Deck gespeichert werden sollen.
• Standardmäßig wird das erste Factor auf der linken Seite gelöscht, wenn Sie einem vollständigen Deck ein neues hinzufügen.
• Die Sammlung deque akzeptiert alle Arten von Objekten, z. B. int, float, string, dataframe usw.
• Es gibt viele Methoden, es zu manipulieren, z reverse , clear , rotate , appendleft.

Wenn dieser Inhalt für Sie interessant ist, lesen Sie mehr über meine Arbeit auf meiner Web site.

https://gustavorsantos.me

Referenzen

Sammlungen – Containerdatentypen

Deque in Python – GeeksforGeeks

Das „Gruppen sind bemerkenswert clever und oft schlauer als die klügsten Leute in ihnen.“ Er schrieb über Entscheidungsfindungaber das gleiche Prinzip gilt auch für die Klassifizierung: Beschreiben Sie genügend Personen, um dasselbe Phänomen zu beschreiben, und es entsteht eine Taxonomie, auch wenn keine zwei Personen es auf die gleiche Weise formulieren. Die Herausforderung besteht darin, dieses Sign aus dem Rauschen zu extrahieren.

Ich hatte mehrere tausend Zeilen mit Freitextdaten und musste genau das tun. In jeder Zeile befand sich eine kurze Erläuterung in natürlicher Sprache warum eine automatisierte Sicherheitsfeststellung irrelevant strugglewelche Funktionen für einen Repair verwendet werden sollen oder welche Codierungspraktiken zu befolgen sind. Eine Individual hat geschrieben „Das ist Testcode, der nirgendwo bereitgestellt wird.“ Ein anderer schrieb „Nicht-Produktionsumgebung, kann man getrost ignorieren.“ Ein Dritter schrieb „Läuft nur während Integrationstests in der CI/CD-Pipeline.“ Alle drei meinten dasselbe, aber keiner teilte mehr als ein oder zwei Worte miteinander.

Die Taxonomie struggle da drin. Ich brauchte nur das richtige Werkzeug, um es zu extrahieren. Herkömmliches Clustering und Key phrase-Matching kamen mit der Paraphrase-Variante nicht zurecht, additionally habe ich etwas ausprobiert, über das noch nicht viel diskutiert wurde: Verwendung eines lokal gehosteten LLM als Zero-Shot-Klassifikator. In diesem Weblog-Beitrag geht es um die Leistung und Funktionsweise sowie um einige Tipps für die eigene Verwendung und Bereitstellung dieser Systeme.

Warum traditionelles Clustering mit kurzen Freitexten zu kämpfen hat

Standardmäßiges unbeaufsichtigtes Clustering funktioniert durch die Suche nach mathematischer Nähe in einem bestimmten Merkmalsraum. Bei langen Dokumenten ist dies normalerweise in Ordnung. In Wortfrequenzen oder Einbettungsvektoren ist genügend Sign vorhanden, um kohärente Gruppen zu bilden. Aber kurze, semantisch dichte Texte widerlegen diese Annahmen auf einige spezifische Arten.

Durch die Einbettung von Ähnlichkeit werden unterschiedliche Bedeutungen vermischt. „Dieser Schlüssel wird nur in der Entwicklung verwendet“ Und „Dieser API-Schlüssel ist der Einfachheit halber fest codiert„Erzeugen Sie ähnliche Einbettungen, da sich das Vokabular überschneidet. Bei einem geht es jedoch um eine Nicht-Produktionsumgebung und bei dem anderen um einen absichtlichen Sicherheitskompromiss. Ok-bedeutet oder DBSCAN kann sie nicht unterscheiden, weil die Vektoren zu nahe beieinander liegen.

Themenmodelle bringen Wörter zum Vorschein, keine Konzepte. Latente Dirichlet-Zuordnung (LDA) und seine Varianten finden Muster des gleichzeitigen Vorkommens von Wörtern. Wenn Ihr Korpus aus Ein-Satz-Anmerkungen besteht, ist das Sign für das gemeinsame Vorkommen von Wörtern zu spärlich, um sinnvolle Themen zu bilden. Sie erhalten Cluster, die definiert sind durch „prüfen“ oder „Code“ oder „Sicherheit” statt kohärenter Themen.

Regex und Key phrase-Matching können Paraphrasenvariationen nicht verarbeiten. Sie könnten Regeln zum Fangen schreiben.Testcode“ Und „Nichtproduktion„Aber du würdest es vermissen“Wird nur während der CI verwendet„ „nie eingesetzt„ „Nur für die Entwicklung vorgesehenes Gerät“ und Dutzende anderer Formulierungen, die alle dieselbe Grundidee zum Ausdruck bringen.

Der rote Faden besteht darin, dass diese Methoden eher auf Oberflächenmerkmalen (Tokens, Vektoren, Mustern) als auf semantischen Bedeutungen basieren. Für Klassifizierungsaufgaben, bei denen die Bedeutung wichtiger ist als der Wortschatz, benötigen Sie etwas, das die Sprache versteht.

LLMs als Zero-Shot-Klassifikatoren

Die wichtigste Erkenntnis ist einfach: Anstatt einen Algorithmus mit der Entdeckung von Clustern zu beauftragen, definieren Sie Ihre Kandidatenkategorien basierend auf Domänenwissen und bitten Sie ein Sprachmodell, jeden Eintrag zu klassifizieren.

Dies funktioniert, weil LLMs semantische Bedeutungen verarbeiten und nicht nur Tokenmuster. „Dieser Schlüssel wird nur in der Entwicklung verwendet“ Und „Nicht-Produktionsumgebung, die Sie ignorieren können„Enthalten quick keine überlappenden Wörter, aber ein Sprachmodell erkennt, dass sie dieselbe Idee ausdrücken. Dies ist nicht nur eine Instinct. Chae und Davidson (2025) verglichen 10 Modelle mit Null-Schuss-, Wenig-Schuss- und fein abgestimmten Trainingsprogrammen und stellten fest, dass große LLMs im Null-Schuss-Modus mit fein abgestimmtem BERT bei Haltungserkennungsaufgaben konkurrenzfähig waren. Wang et al. (2023) fanden heraus, dass LLMs modernste Klassifizierungsmethoden bei drei von vier Benchmark-Datensätzen übertrafen, indem sie ausschließlich Zero-Shot-Prompts verwendeten und keine gekennzeichneten Trainingsdaten erforderlich waren.

Das Setup besteht aus drei Komponenten:

• Kandidatenkategorien. Eine Liste sich gegenseitig ausschließender Kategorien, die aus Domänenwissen definiert werden. In meinem Fall habe ich mit etwa 10 erwarteten Themen begonnen (Testcode, Eingabevalidierung, Framework-Schutz, Nicht-Produktionsumgebungen usw.) und nach Durchsicht eines Beispiels auf 20 Kandidaten erweitert.
• Eine Eingabeaufforderung zur Klassifizierung. Strukturiert, um eine Kategoriebezeichnung und einen kurzen Grund zurückzugeben. Niedrige Temperatur (0,1) für Konsistenz. Kurze maximale Ausgabe (100 Token), da wir nur ein Etikett und keinen Aufsatz benötigen.
• Ein lokales LLM. Ich habe verwendet Ollama um Modelle lokal auszuführen. Keine API-Kosten, keine Daten verlassen meinen Pc und schnell genug für Tausende von Klassifizierungen.

Hier ist der Kern der Klassifizierungsaufforderung:

CLASSIFICATION_PROMPT = """

Classify this textual content into considered one of these themes:

{themes}

Textual content:
"{content material}"

Reply with ONLY the theme quantity and identify, and a quick cause.
Format: THEME_NUMBER. THEME_NAME | Cause
Classification:

"""

Und der Ollama-Ruf:

response = ollama.generate(
    mannequin="gemma2",
    immediate=immediate,
    choices={
        "temperature": 0.1,  # Low temp for constant classification
        "num_predict": 100,  # Quick response, we simply want a label
    }
)

Zwei Dinge sind zu beachten. Zunächst kommt es auf die Temperatureinstellung an. Bei 0,7 oder höher kann die gleiche Eingabe in verschiedenen Läufen zu unterschiedlichen Klassifizierungen führen. Bei 0,1 ist das Modell nahezu deterministisch, was zu einer reibungslosen Klassifizierung beiträgt. Zweitens, einschränkend num_predict verhindert, dass das Modell Erklärungen generiert, die Sie nicht benötigen, was den Durchsatz erheblich beschleunigt.

Bau der Pipeline

Die vollständige Pipeline besteht aus drei Schritten: Vorverarbeitung, Klassifizierung, Analyse.

Vorverarbeitung Entfernt Inhalte, die Token hinzufügen, ohne ein Klassifizierungssignal hinzuzufügen. URLs, Standardphrasen („Weitere Informationen finden Sie unter…“) und alle Formatierungsartefakte werden entfernt. Allgemeine Begriffe werden normalisiert („falsch positiv„ wird zu „FP„ „Produktion„ wird zu „Prod„), um die Token-Variation zu reduzieren. Durch die Deduplizierung durch Content material-Hash werden exakte Wiederholungen entfernt. Dieser Schritt reduzierte mein Token-Price range ungefähr 30 % und die Klassifizierung konsistenter gemacht.

Einstufung führt jeden Eintrag mit den Kandidatenkategorien durch das LLM. Für ca. 7.000 Einträge dauerte dies auf einem MacBook Professional etwa 45 Minuten Gemma 2 (9B Parameter). Habe ich auch getestet Lama 3.2 (3B), das in Grenzfällen, in denen zwei Kategorien nahe beieinander lagen, schneller, aber etwas ungenauer struggle. Gemma 2 verarbeitete mehrdeutige Eingaben deutlich besser.

Ein praktisches Downside: Lange Läufe können auf halbem Weg scheitern. Die Pipeline speichert alle 100 Klassifizierungen Prüfpunkte, sodass Sie dort weitermachen können, wo Sie aufgehört haben.

Analyse fasst die Ergebnisse zusammen und generiert ein Verteilungsdiagramm. So sah die Ausgabe aus:

Das Diagramm erzählt eine klare Geschichte. Über ein Viertel aller Einträge beschrieb Code, der nur in Nicht-Produktionsumgebungen läuft. Weitere 21,9 % beschrieben Fälle, in denen ein Sicherheitsrahmen das Risiko bereits bewältigt. Allein diese beiden Kategorien machen die Hälfte des Datensatzes aus. Das ist die Artwork von Erkenntnissen, die auf andere Weise aus unstrukturiertem Textual content nur schwer zu extrahieren sind.

Wenn dieser Ansatz nicht die richtige Lösung ist

Diese Technik funktioniert am besten in einer bestimmten Nische: mittelgroße Datensätze (Hunderte bis Zehntausende Einträge), semantisch komplexer Textual content und Situationen, in denen Sie über genügend Domänenwissen verfügen, um Kandidatenkategorien zu definieren, aber keine gekennzeichneten Trainingsdaten.

Es ist nicht Das richtige Werkzeug, wenn:

• Ihre Kategorien sind schlüsselwortdefiniert (verwenden Sie einfach Regex),
• wenn Sie Trainingsdaten gekennzeichnet haben (trainieren Sie einen überwachten Klassifikator; das geht schneller und billiger),
• wenn Sie eine Latenzzeit von weniger als einer Sekunde im großen Maßstab benötigen (verwenden Sie Einbettungen und eine Suche nach dem nächsten Nachbarn),
• oder wenn Sie wirklich nicht wissen, welche Kategorien existieren. Führen Sie in diesem Fall zunächst eine explorative Themenmodellierung durch, um die Instinct zu entwickeln, und wechseln Sie dann zur LLM-Klassifizierung, sobald Sie Kategorien definieren können.

Die andere Einschränkung ist der Durchsatz. Selbst auf einer schnellen Maschine bedeutet die Klassifizierung eines Eintrags professional Sekundenbruchteil, dass 7.000 Einträge quick eine Stunde dauern. Für Datensätze mit mehr als 100.000 Einträgen benötigen Sie ein API-gehostetes Modell oder eine Batch-Strategie.

Andere Anwendungen, die einen Versuch wert sind

Die Pipeline lässt sich auf jedes Downside verallgemeinern, bei dem Sie unstrukturierten Textual content haben und strukturierte Kategorien benötigen.

Kundenfeedback. NPS-Antworten, Help-Tickets und offene Umfragen haben alle das gleiche Downside: unterschiedliche Formulierungen für eine begrenzte Anzahl zugrunde liegender Themen. „Ihre App stürzt jedes Mal ab, wenn ich die Einstellungen öffne“ und „SDie Einstellungsseite ist unter iOS defekt„gehören zur gleichen Kategorie, aber die Key phrase-Übereinstimmung wird das nicht erfassen.

Triage von Fehlerberichten. Freitext-Fehlerbeschreibungen können automatisch nach Komponente, Grundursache oder Schweregrad kategorisiert werden. Dies ist besonders nützlich, wenn die Individual, die den Fehler meldet, nicht weiß, welche Komponente dafür verantwortlich ist.

Klassifizierung der Codeabsicht. Dies ist etwas, das ich noch nicht ausprobiert habe, das ich aber überzeugend finde: Codefragmente klassifizieren, Semgrep-Regelnoder Konfigurationsregeln nach Zweck (Authentifizierung, Datenzugriff, Fehlerbehandlung, Protokollierung). Es gilt die gleiche Technik. Definieren Sie die Kategorien, schreiben Sie eine Klassifizierungsaufforderung und führen Sie den Korpus durch ein lokales Modell aus.

Erste Schritte

Die Pipeline ist unkompliziert: Definieren Sie Ihre Kategorien, schreiben Sie eine Klassifizierungsaufforderung und lassen Sie Ihre Daten durch ein lokales Modell laufen.

Der schwierigste Teil ist nicht der Code. Es geht darum, Kategorien zu definieren, die sich gegenseitig ausschließen und kollektiv erschöpfend sind. Mein Rat: Beginnen Sie mit einer Stichprobe von 100 Einträgen, klassifizieren Sie diese manuell, achten Sie darauf, nach welchen Kategorien Sie immer wieder greifen, und verwenden Sie diese als Kandidatenliste. Lassen Sie dann das LLM das Muster skalieren.

Ich habe diese Technik als Teil eines verwendet umfassendere Analyse darüber, wie Sicherheitsteams Schwachstellen beheben. Die Klassifizierungsergebnisse haben dazu beigetragen, herauszufinden, welche Arten von Sicherheitskontexten in Unternehmen am häufigsten vorkommen, und die obige Tabelle ist eines der Ergebnisse dieser Arbeit. Wenn Sie sich für den Sicherheitsaspekt interessieren, finden Sie den vollständigen Bericht unter diesem Hyperlink.

Z.ai bringt sein Flaggschiff-KI-Modell der nächsten Technology auf den Markt und hat es GLM-5.1 getauft. Mit seiner Kombination aus umfangreicher Modellgröße, betrieblicher Effizienz und überlegenen Argumentationsfunktionen stellt das Modell einen großen Fortschritt bei großen Sprachmodellen dar. Das System verbessert gegenüber früheren GLM-Modellen durch die Einführung einer erweiterten Funktion Mischung aus Experten Framework, das es ermöglicht, komplizierte mehrstufige Vorgänge schneller und mit präziseren Ergebnissen durchzuführen.

GLM-5.1 ist außerdem leistungsstark, da es die Entwicklung agentenbasierter Systeme unterstützt, die erweiterte Argumentationsfähigkeiten erfordern. Das Modell bietet sogar neue Funktionen, die sowohl die Codierungsfunktionen als auch das Verständnis langer Kontexte verbessern. All dies beeinflusst die tatsächlichen KI-Anwendungen und die Arbeitsprozesse der Entwickler.

Dies lässt keinen Zweifel daran, dass es sich bei der Einführung des GLM-5.1 um ein wichtiges Replace handelt. Hier konzentrieren wir uns genau darauf und erfahren alles über den neuen GLM-5.1 und seine Fähigkeiten.

GLM-5.1 Modellarchitekturkomponenten

GLM-5.1 baut auf modernen auf LLM-Designprinzipien durch die Kombination von Effizienz, Skalierbarkeit und Langkontextverarbeitung in einer einheitlichen Architektur. Durch die Fähigkeit, bis zu 100 Milliarden Parameter zu verarbeiten, trägt es zur Aufrechterhaltung der betrieblichen Effizienz bei. Dies ermöglicht eine praktische Leistung im täglichen Betrieb.

Das System verwendet a hybrider Aufmerksamkeitsmechanismus zusammen mit einer optimierten Decodierungspipeline. Dies ermöglicht eine effektive Ausführung von Aufgaben, die den Umgang mit langen Dokumenten, die Argumentation und die Codegenerierung erfordern.

Hier sind alle Komponenten, aus denen sich die Architektur zusammensetzt:

• Combination-of-Consultants (MoE): Das MoE-Modell verfügt über 744 Milliarden Parameter, die es auf 256 Experten aufteilt. Das System implementiert High-8-Routing, das es acht Experten ermöglicht, an jedem Token zu arbeiten, plus einem Experten, der über alle Token hinweg arbeitet. Das System benötigt etwa 40 Milliarden Parameter für jeden Token.
• Aufmerksamkeit: Das System verwendet zwei Arten von Aufmerksamkeitsmethoden. Dazu gehören Multi-Head Latent Consideration und DeepSeek Sparse Consideration. Das System kann bis zu 200.000 Token verarbeiten, da seine maximale Kapazität 202.752 Token erreicht. Das KV-Cache-System verwendet komprimierte Daten, die auf LoRA-Rang 512 und Kopfdimension 64 arbeiten, um die Systemleistung zu verbessern.
• Struktur: Das System enthält 78 Schichten, die mit einer versteckten Größe von 6144 arbeiten. Die ersten drei Schichten folgen einer standardmäßigen dichten Struktur, während die folgenden Schichten spärliche MoE-Blöcke implementieren.
• Spekulative Dekodierung (MTP): Der Decodierungsprozess wird durch Speculative Decoding schneller, da ein Multi-Token-Vorhersagekopf verwendet wird, der die gleichzeitige Vorhersage mehrerer Token ermöglicht.

GLM-5.1 erreicht seinen großen Umfang und sein erweitertes Kontextverständnis durch diese Funktionen, die weniger Rechenleistung erfordern als ein vollständig dichtes System.

So greifen Sie auf GLM-5.1 zu

Entwickler können GLM-5.1 auf verschiedene Arten nutzen. Die vollständigen Modellgewichte sind als Open-Supply-Software program unter der MIT-Lizenz verfügbar. Die folgende Liste enthält einige der verfügbaren Optionen:

• Hugging Face (MIT-Lizenz): Gewichte zum Obtain verfügbar. Als Mindestanforderung benötigt das System Enterprise-GPU-{Hardware}.
• Z.ai API/Codierungspläne: Der Dienst bietet direkten API-Zugriff zu einem Preis von etwa 1,00 US-Greenback professional Million Token und 3,20 US-Greenback professional Million Token. Das System funktioniert mit den aktuellen Claude- und OpenAI-System-Toolchains.
• Plattformen von Drittanbietern: Das System funktioniert mit Inferenz-Engines, zu denen OpenRouter und SGLang gehören, die voreingestellte GLM-5.1-Modelle unterstützen.
• Lokale Bereitstellung: Benutzer mit ausreichenden Hardwareressourcen können GLM-5.1 lokal über vLLM- oder SGLang-Instruments implementieren, wenn sie über mehrere B200-GPUs oder gleichwertige {Hardware} verfügen.

GLM-5.1 bietet offene Gewichtungen und kommerziellen API-Zugriff, wodurch es sowohl für Unternehmen als auch für Einzelpersonen verfügbar ist. Speziell für diesen Weblog werden wir den Hugging Face-Token verwenden, um auf dieses Modell zuzugreifen.

GLM-5.1-Benchmarks

Hier sind die verschiedenen Ergebnisse, die GLM-5.1 in verschiedenen Benchmarks erzielt hat.

Codierung

GLM-5.1 zeigt eine außergewöhnliche Fähigkeit, Programmieraufgaben zu erledigen. Seine Codierungsleistung erreichte auf SWE-Bench Professional einen Wert von 58,4 und übertraf damit sowohl GPT-5,4 (57,7) als auch Claude Opus 4.6 (57.3). GLM-5.1 erreichte in drei Codierungstests, darunter SWE-Bench Professional, Terminal-Bench 2.0 und CyberGym, eine Punktzahl von über 55 und sicherte sich damit weltweit den dritten Platz hinter GPT-5.4 (58,0) und Claude 4,6 (57,5) insgesamt. Das System übertrifft GLM-5 deutlich, was seine bessere Leistung bei Codierungsaufgaben mit Werten von 68,7 im Vergleich zu 48,3 zeigt. Das neue System ermöglicht es GLM-5.1, komplizierten Code mit größerer Genauigkeit als zuvor zu erstellen.

Agent

Der GLM-5.1 unterstützt Agenten-Workflows, die mehrere Schritte umfassen, die sowohl Planung als auch Codeausführung und Toolnutzung erfordern. Dieses System zeigt während längerer Betriebsperioden erhebliche Fortschritte. Durch seinen Betrieb auf der VectorDBBench Für die Optimierungsaufgabe führte GLM-5.1 655 Iterationen durch, die mehr als 6000 Toolfunktionen umfassten, um mehrere algorithmische Verbesserungen zu entdecken. Behält seinen Entwicklungspfad auch nach Erreichen von 1000 Werkzeugnutzungen bei, was seine Fähigkeit beweist, sich durch nachhaltige Optimierung kontinuierlich zu verbessern.

• VectorDBBench: Erzielte 21.500 QPS über 655 Iterationen (6-facher Gewinn) bei einer Indexoptimierungsaufgabe.
• KernelBench: 3,6-facher ML-Leistungszuwachs bei GPU-Kerneln gegenüber 2,6-fach bei GLM-5, weiterhin über 1000 Runden hinaus.
• Selbst-Debugging: Wie von Z.ai angegeben, hat er innerhalb von 8 Stunden einen kompletten Linux-Desktop-Stack von Grund auf erstellt (Planung, Assessments, Fehlerkorrektur).

Argumentation

GLM-5.1 liefert hervorragende Ergebnisse bei Standardtests zum logischen Denken und QA-Bewertungstests. Das System weist Leistungsergebnisse auf, die mit führenden Systemen zur allgemeinen Intelligenzbewertung übereinstimmen.

GLM-5.1 erreichte 95,3 % bei AIME, einem fortgeschrittenen Mathematikwettbewerb, und 86,2 % bei GPQA, bei dem fortgeschrittene Fähigkeiten zur Beantwortung von Fragen getestet werden. Die Ergebnisse nähern sich der höchsten Leistung der High-Systeme an, darunter GPT-5.4, das in zwei separaten Bewertungen 98,7 % und 94,3 % erreichte. GLM-5.1 weist umfangreiche akademische Fähigkeiten auf, die zu hohen Leistungen in mehreren Disziplinen und Olympia-Wettbewerben führen.

GLM-5.1-Funktionen

GLM-5.1 schneidet bei drei spezifischen Aufgaben außergewöhnlich intestine ab – langfristige Planung, Codegenerierung und logisches Denken mit mehreren Runden. Die Software program kann Computercode erstellen und debuggen, gleichzeitig schwierige Fragestellungen lösen und komplexe Aufgaben mit hervorragenden Ergebnissen ausführen. Das System ermöglicht es Entwicklern, „Agenten“ zu konstruieren, die seine Funktionsaufruf- und strukturierten Ausgabefunktionen nutzen, um mit verschiedenen Instruments zu interagieren. Die beiden hier gezeigten Aufgaben demonstrieren die Programmierfähigkeiten des Methods. Das System ermöglicht es Benutzern, Probleme durch Eingabeaufforderungen zu lösen, was zu präzisen Lösungen führt, die häufig Code enthalten.

Aufgabe 1: Ermitteln der Fakultät einer großen Zahl

Immediate:

„Hallo, Sie sind ein ausgezeichneter Code-Lehrer, additionally helfen Sie mir bei dieser Frage.

F. Schreiben Sie Python-Code zum Ermitteln der Fakultät einer großen Zahl.“

Antwort von GLM-5.1:

def factorial_large(n: int) -> str:
    if n < 0: return ""
    if n == 0: return "1"

    # Array to retailer particular person digits (saved in reverse order for simpler carry dealing with)
    res = (1)

    for x in vary(2, n + 1):
        carry = 0

        # Multiply x with each digit within the present outcome
        for i in vary(len(res)):
            product = res(i) * x + carry
            res(i) = product % 10
            carry = product // 10

        # Append the remaining carry to the outcome array
        whereas carry:
            res.append(carry % 10)
            carry //= 10

    # The digits are saved in reverse order, so reverse and be a part of them
    return "".be a part of(map(str, res(::-1)))

Ausgabe:

Urteil: Das System funktioniert effizient, da es einer Zwei-Punkte-Technik folgt und die besten Leistungsergebnisse liefert. Die Lösung verbraucht minimale Overhead-Ressourcen und implementiert gleichzeitig effektive Hilfsfunktionen. Die Implementierung liegt in einem kurzen Format vor, ohne vollständige Dokumentation und Kommentare. Dadurch eignet es sich besser für die schnelle Lösung von Problemen als für den Einsatz in Produktionsumgebungen, die lesbaren und wartbaren Code benötigen.

Aufgabe 2: Überprüfen, ob ein String ein Palindrom ist

Immediate:

„Hallo, Sie sind ein ausgezeichneter Code-Lehrer, additionally helfen Sie mir bei dieser Frage.

F. Geben Sie bei einer gegebenen Zeichenfolge s „true“ zurück, wenn s ein Palindrom sein kann, nachdem höchstens ein Zeichen daraus gelöscht wurde.“

Antwort von GLM-5.1:

def validPalindrome(s: str) -> bool:
    def is_palindrome(l: int, r: int) -> bool:
        whereas l < r:
            if s(l) != s(r):
                return False
            l += 1
            r -= 1
        return True

    left, proper = 0, len(s) - 1

    whereas left < proper:
        if s(left) != s(proper):
            return is_palindrome(left + 1, proper) or is_palindrome(left, proper - 1)
        left += 1
        proper -= 1

    return True

Ausgabe:

Urteil: Die Antwort von GLM-5.1 zeigt effiziente Leistung kombiniert mit technischer Validität. Es zeigt Kompetenz in der Ausführung umfangreicher numerischer Operationen durch manuelle Ziffernverarbeitung. Das System erreicht seine Entwurfsziele durch seine iterative Methode, die Leistung mit korrekter Ausgabe kombiniert. Die Implementierung liegt in einem Kurzformat vor und bietet eine begrenzte Dokumentation durch grundlegende Fehlerbehandlung. Dadurch ist der Code für die Algorithmenentwicklung geeignet, für den Produktionseinsatz jedoch ungeeignet, da diese Umgebung eine klare, erweiterbare und starke Leistung erfordert.

Gesamtüberblick über die GLM-5.1-Funktionen

GLM-5.1 bietet durch seine Open-Supply-Infrastruktur und sein ausgefeiltes Systemdesign mehrere Anwendungen. Dies ermöglicht es Entwicklern, tiefgreifende Argumentationsfunktionen, Funktionen zur Codegenerierung und Systeme zur Werkzeugnutzung zu erstellen. Das System behält alle bestehenden Stärken der GLM-Familie durch spärliche MoE- und Lengthy-Context-Funktionen bei. Außerdem werden neue Funktionen eingeführt, die adaptives Denken und die Ausführung von Debugging-Schleifen ermöglichen. Durch seine offenen Gewichte und kostengünstigen API-Optionen bietet das System Zugang zur Forschung und unterstützt gleichzeitig praktische Anwendungen in der Softwareentwicklung und anderen Bereichen.

Abschluss

Der GLM-5.1 ist ein lebendiges Beispiel dafür, wie aktuelle KI-Systeme ihre Effizienz und Skalierbarkeit entwickeln und gleichzeitig ihre Denkfähigkeiten verbessern. Mit seiner Combination-of-Consultants-Architektur garantiert es eine hohe Leistung bei gleichzeitig angemessenen Betriebskosten. Insgesamt ermöglicht dieses System die Handhabung realer KI-Anwendungen, die umfangreiche Operationen erfordern.

Während die KI auf sie zusteuert agentenbasierte Systeme und erweitertem Kontextverständnis schafft GLM-5.1 eine Grundlage für zukünftige Entwicklungen. Sein Routing-System und sein Aufmerksamkeitsmechanismus schaffen zusammen mit seinem Multi-Token-Vorhersagesystem neue Möglichkeiten für kommende große Sprachmodelle.