Hilfsfunktionen

analyse(state: Union[str, bytes, Mapping, list, None]) -> Dict[str, object]

Vollständiges Erkennungsergebnis für einen Zustand.

Gibt script, script_profile, language (nach bestem Bemühen, kann None sein), is_english, non_latin_fraction und mixed_segment zurück (die Zeile oder das Feld, die bzw. das einen überwiegend englischen Zustand nicht-englisch machte, sonst None).

Gelesen werden die String-Werte. Wenn ein Zustand mehrere davon hat, genügt ein nicht-englisches: Alle Werte in ein Fenster zu verbinden ließ eine lange englische Notiz die 4000 Zeichen füllen oder eine kurze deutsche Nachricht überstimmen, und diese Nachricht wurde dann an den englischen Checkpoint geschickt (#384). Der Segment-Scan hält trotzdem bei 4000 Zeichen an, was ein riesiges Feld günstig macht; ein Wert, den er nicht erreichte, wird danach für sich gelesen.

detect_script(text: str) -> str

Dominantes Schriftsystem von text: 'latin', 'han', 'devanagari', ... oder 'unknown', wenn es keine Buchstaben gibt.

is_english(state: Union[str, bytes, Mapping, list, None]) -> bool

True, wenn vom englischen Checkpoint erwartet werden kann, dass er diesen Zustand liest.

clean_email_body(body: str, max_chars: int = 3000) -> str

Entfernt zitierte E-Mail-Historie, Signaturen und Haftungsausschlüsse, um die Eingabe fokussiert zu halten.

max_chars ist die Länge, auf die das Ergebnis gekürzt wird, 3000 Zeichen, sofern nicht erhöht -- siehe email_state, das dasselbe Budget übernimmt und durchreicht.

email_state(
    subject: str,
    body: str,
    sender: Optional[str] = None,
    clean: bool = True,
    max_chars: int = 3000,
    extra,
) -> Dict

Konstruiert ein sauberes State-Dictionary für die E-Mail-Klassifikation.

max_chars ist das Budget, auf das clean_email_body den Text kürzt, und es lohnt sich, es für eine lange Nachricht zu erhöhen: beim Standard endet der Text nach 3000 Zeichen, eine Anfrage, die in den letzten Absätzen ankommt, erreicht das Modell also nie -- auch nicht über predict_long, das einen Zustand gerade in Fenstern scannt, um über eine Fensterlänge hinaus lesen zu können. Wird ignoriert, wenn clean=False, was den Text als Ganzes durchlässt.

Jedes andere Schlüsselwort wird ein Feld des Zustands und damit vom Modell gelesen; ein Tippfehler hier ist eine Eingabemutation, kein Fehler.

triage_questions() -> Dict

Voreingestellte Fragen für das Triaging von Kundensupport-Tickets.

email_questions(categories: Optional[Dict[str, str]] = None) -> Dict

Voreingestellte Fragen für das Triaging eingehender E-Mails und die Bedrohungsfilterung.

guard_questions() -> Dict

Voreingestellte Fragen für Leitplanken für LLM-Eingaben in Echtzeit.

moderation_questions() -> Dict

Voreingestellte Fragen für Inhaltssicherheit und Moderation.

router_questions() -> Dict

Voreingestellte Fragen für intelligentes Modell-Routing.

shortlist_choice(
    state: Any,
    criteria: Any,
    embed_fn: Callable[[Sequence[str]], Any],
    k: int = DEFAULT_SHORTLIST_K,
    DEFAULT_SHORTLIST_K,
    instructions: Optional[str] = None,
    return_scores: bool = False,
) -> Any

Gibt die k besten choice-Labels für state zurück.

embed_fn bildet eine Liste von Strings auf ein Array der Form (len(texts), dim) ab. Es wird einmal aufgerufen, zuerst mit dem Query-Text und dann mit einem String pro Option in criteria-Reihenfolge. Options-Strings stimmen mit render_options für eine choice-Frage überein.

Wenn k mindestens die Anzahl der Labels ist, wird jedes Label in seiner ursprünglichen Reihenfolge zurückgegeben und embed_fn nicht aufgerufen.

Gleichstände behalten das frühere Label. Die Rangfolge ist ein vorzeichenbehafteter Kosinus, kein Ähnlichkeitsboden: ein Label, das 0 erzielt -- gar kein Signal, oder ein nicht-finiter Vektor, der als solcher behandelt wird --, übertrumpft ein früheres Label, das negativ erzielte, und k wirft zuerst die negativen Labels heraus.

Mit return_scores=True ist die Rückgabe das Paar (labels, scores), wobei scores den vorzeichenbehafteten Kosinus pro behaltenem Label in Rangfolge hält -- dieselben Werte, die predict_shortlist in seinen shortlist-Metadaten meldet. scores ist None, wenn nichts verworfen wurde, genau wie in diesen Metadaten.

predict_shortlist(
    agent: Any,
    state: Any,
    questions: Dict[str, Dict[str, Any]],
    embed_fn: Callable[[Sequence[str]], Any],
    k: int = DEFAULT_SHORTLIST_K,
    DEFAULT_SHORTLIST_K,
    predict_kwargs: Any,
) -> Dict[str, Any]

Erstellt eine Shortlist für jede choice-Frage und ruft dann einmal predict oder system_one auf.

Nicht-choice-Fragen werden unverändert weitergegeben. Eine choice, deren Label-Anzahl <= k ist, wird unverändert weitergegeben und ruft embed_fn nicht auf. Das questions-Dict des Aufrufers wird nicht verändert.

Das zurückgegebene Dict ist das Modellergebnis plus ein shortlist-Eintrag. Wahrscheinlichkeiten einer geshortlisteten choice gelten nur über die behaltenen Labels. shortlist[qid] enthält labels, scores, k, n und passthrough. labels ist die Rang- Reihenfolge, die eine Shortlist erzeugt hat, oder die criteria-Reihenfolge selbst, wenn passthrough gesetzt ist und keine Rangfolge lief; scores ist der vorzeichenbehaftete Kosinus jedes behaltenen Labels in dieser Reihenfolge -- negative eingeschlossen, nie auf 0 geklemmt -- oder None, wenn nichts verworfen wurde.

Zusätzliche Schlüsselwortargumente werden an predict / system_one weitergegeben (zum Beispiel model= auf einem Router).

embed_fn_from_agent(
    agent: Any,
    max_length: int = 512,
    batch_size: int = 32,
) -> Callable[[Sequence[str]], np.ndarray]

Mean-Poolt den Checkpoint-Encoder, der bereits auf agent geladen ist.

Das Callable embeddet eine Liste von Strings mit agent.tok und agent.model.encoder. Es führt den Entscheidungskopf nicht aus und lädt keine Gewichte herunter. Ein dedizierter Bi-Encoder, der als embed_fn übergeben wird, erstellt die Shortlist meist besser; dieser Helper ist für Aufrufer, die nur den Laya-Checkpoint im Speicher haben.

Padding-Positionen werden aus dem Mittel ausgeschlossen. Das Train/Eval-Flag des Encoders wird so belassen, wie der Aufrufer es gesetzt hat (ein geladener Agent ist bereits im eval). Jeder Aufruf nutzt das aktuelle agent.device, auch nach CPU-Fallback.

cached_embed_fn(
    embed_fn: Callable[[Sequence[str]], Any],
    maxsize: int = 4096,
) -> Callable[[Sequence[str]], np.ndarray]

Cached die Ausgabe von embed_fn pro Eingabe-String, unter einer LRU-Grenze.

predict_shortlist embeddet bei jedem Aufruf den Query plus jeden Options-Text. Wenn dasselbe Options-Set bei jeder Anfrage geshortlistet wird -- eine feste Intent- oder Label-Liste, wie im BANKING77-Beispiel des README --, ändern sich die Options-Zeilen zwischen Aufrufen nicht, werden aber jedes Mal neu embeddet. Den Embedder einmal zu umhüllen::

embed_fn = cached_embed_fn(embed_fn_from_agent(agent))

lässt den ersten Aufruf unverändert und reduziert jeden Wiederholungsaufruf darauf, nur den neuen Query zu embedden.

Lookups sind exakte String-Übereinstimmungen. Texte, die im Cache fehlen, werden dedupliziert und in einem einzigen embed_fn-Aufruf embeddet, ein kalter Cache kostet also dieselbe Anzahl gebatchter Aufrufe wie die ungeumhüllte Funktion. Zeilen werden als float32 gespeichert; der Cache hält höchstens maxsize Strings und verdrängt dann den am wenigsten zuletzt genutzten Eintrag, was den Speicher auf etwa maxsize * dim * 4 Bytes begrenzt. Nichts wird gecacht, wenn embed_fn einen Fehler auslöst oder eine schlechte Form zurückgibt.

Der Wrapper ist sicher zwischen Threads teilbar: das Lock deckt nur Cache-Lese- und -Schreibvorgänge ab, nie den Embedding-Aufruf. Das zurückgegebene Callable trägt cache_info() -- ein Dict mit size, maxsize, hits und misses -- und cache_clear(). Leere den Cache, wenn sich das Modell oder die Gewichte hinter embed_fn ändern.

check_min_confidence(v: Any)

Validiert die Opt-in-Enthaltungsschwelle min_confidence (#361, #394).

Entweder eine reelle Zahl in [0.0, 1.0] (eine Schwelle für jede Antwort; Booleans werden abgelehnt, obwohl isinstance(True, int)), oder ein Mapping pro Bucket (siehe :func:check_min_confidence_map), sodass die Schwelle sich nach Optionsanzahl unterscheiden kann. Gibt den Wert in validierter Form zurück -- einen float für den Skalarfall, ein dict[str, float] für den Mapping-Fall --, die beide von den Gate- Funktionen unten akzeptiert werden.

check_min_confidence_map(m: Dict[Any, Any]) -> Dict[str, float]

Validiert ein Mapping von Enthaltungsschwellen pro Bucket (#394).

Die Schlüssel sind Optionsanzahl-Bucket-Strings in der Schreibweise von common.temp_bucket -- "choice:2", "choice:3-5", "score:6-10", "noul:2" und so weiter --, plus ein optionales "default", das für jedes nicht genannte Bucket verwendet wird. Die Werte sind Floats in [0.0, 1.0]. Eine Konfidenz- schwelle überträgt sich nicht über Optionsanzahlen hinweg (#394); dies ermöglicht es dem Aufrufer, jedes Bucket auf dem Niveau zu gaten, das seine Kalibrierung tatsächlich erreicht. Passe eines mit :func:laya.calibrate.fit_abstention_thresholds an.

resolve_min_confidence(
    answer: Dict[str, Any],
    thresholds: Dict[str, float],
    default: float = 0.0,
) -> float

Die Schwelle, an der das Optionsanzahl-Bucket dieser Antwort gated wird, unter einem Mapping pro Bucket.

Fällt auf den "default"-Eintrag des Mappings zurück, dann auf default (0.0 -- nichts gaten), für ein Bucket, das das Mapping nicht nennt, damit ein unkonfiguriertes Bucket nie überraschend zu einer Enthaltung führt.

flag_low_confidence(results: List[Dict[str, Any]], min_confidence: float) -> None

Opt-in-Enthaltungsmarker (#361): markiert Antworten, deren Konfidenz unter min_confidence fällt.

Liest answer_confidence (max(p), die Größe, die die Kalibrierungswerte beschreiben und die nicht mit der Anzahl der Optionen driftet), mit Rückfall auf confidence, wenn answer_confidence fehlt. Die rohe Antwort und Konfidenz bleiben intakt; low_confidence: True wird hinzugefügt, wenn die Antwort unter die Schwelle fällt, und entfernt, wenn eine zuvor markierte Antwort sie nun überschreitet (z. B. wenn ein Ergebnis-Dict wiederverwendet oder mit einer anderen Schwelle neu bewertet wird).

min_confidence ist entweder ein Float (eine Schwelle für jede Antwort) oder ein Mapping pro Bucket (#394), wobei jede Antwort an der Schwelle ihres eigenen Optionsanzahl-Buckets über :func:resolve_min_confidence gegated wird.

apply_confidence_gate(
    results: List[Dict[str, Any]],
    min_confidence: Optional[float] = None,
) -> None

Berichtet den Zustand des Konfidenz-Gates, auf den Antworten, auf die tatsächlich ein Gate angewendet wurde.

Ein Gate ist eine Policy, und eine Policy, deren Anwendung nicht beobachtet werden kann, ist keine. Mit gesetztem min_confidence schreibt dies abstention -- einen der :data:GATE_STATES -- auf jede Antwort, plus abstention_threshold, damit ein Aufrufer drei Fragen beantworten kann, die er sonst nicht beantworten kann:

• welcher Anteil der Entscheidungen sich enthalten hat, statt es daraus abzuleiten, ob low_confidence zufällig gesetzt war;
• auf wie viele Antworten das Gate sich nicht entscheiden konnte, was ein Boolean gar nicht ausdrücken kann;
• welche Schwelle diese Ergebnisse hervorgebracht hat -- flag_low_confidence konsumiert die Schwelle und verwirft sie, sodass ohne dies ein Batch-Lauf mit Schwellen pro Klasse nicht neu aufgeteilt werden kann.

GATE_UNEVALUATED ist der Fall, den ein Boolean nicht ausdrücken kann: Das Gate lief und die Antwort trug keine nutzbare Konfidenz, also konnte das Gate sich nicht entscheiden. Das als Bestehen zu berichten ist dieselbe Lüge wie es als Flag zu berichten.

Mit ungesetztem min_confidence schreibt dies nichts. Kein abstention, kein abstention_threshold, kein Flag. Das ist der ganze Vertrag: Ein Aufruf ohne Gate gibt genau den Payload zurück, den er vorher zurückgab, und die Anwesenheit des Feldes -- nicht ein vierter Wert, der daraus gelesen wird -- ist es, was dem Aufrufer sagt, dass das Gate lief. Rufe es bedingungslos auf, einmal pro Aufruf, anstelle eines if min_confidence is not None:-Guards: Dieser Guard ist es, der einen Pfad gar nichts berichten lässt, was der Zustand ist, den diese Funktion unterscheiden soll.

Das Flag selbst bleibt das von :func:flag_low_confidence -- dies delegiert, statt die Regel neu zu implementieren, sodass der Boolean und der berichtete Zustand nicht auseinanderdriften können.

Ein min_confidence von genau 0.0 wurde gesetzt, also werden Zustände berichtet, und :func:flag_low_confidence behandelt 0.0 als No-op, weil nichts darunter fallen kann. Jede Antwort, die eine nutzbare Konfidenz trägt, liest sich daher als passed, und das Echo der Schwelle ist es, was das von einem echten Bestehen bei einer echten Schwelle unterscheidet.

GATE_STATES = (GATE_PASSED, GATE_ABSTAINED, GATE_UNEVALUATED)

answer_confidence(p: np.ndarray, k: int) -> float

Wahrscheinlichkeitsmasse auf der berichteten Antwort: max(p).

Das ist die Größe, die das Temperatur-Scaling anpasst, und die Größe, auf der jeder Kalibrierungswert in diesem Repository berechnet wird -- beide Benchmark-Harnesse nehmen conf = max(probs) vor dem Aufruf von ece_score. Der Gating-Abschnitt des README stützt sich auf die Eigenschaft, die damit einhergeht: Von den mit Konfidenz c zurückgegebenen Antworten sind etwa c richtig. Diese Eigenschaft ist bedingt, und die Bedingung ist standardmäßig nicht erfüllt -- sie gilt erst, nachdem die Temperaturen für diesen Checkpoint und diese Optionsanzahl auf zurückgehaltenen Daten angepasst und validiert wurden. Die mitgelieferten Checkpoints sind überkonfident: choice:11+ ist ein ~10x-Verschärfer, der eine Punktmasse bei 1.0 zurückgibt, eine darauf angewendete Schwelle wählt also unterhalb der Modellgenauigkeit aus (Issue #394).

confidence_from_probs unten berichtet eine andere Größe auf einer anderen Skala und trägt keine solche Garantie, die beiden dürfen also nicht gegen dieselbe Schwelle verglichen werden.

confidence_from_probs(p: np.ndarray, k: int) -> float

Normierte Shannon-Entropie-Konfidenz: 1 - H(p) / log(k).

Wie konzentriert die gesamte Verteilung ist. Nützlich, aber nicht kalibriert: Sie ist nicht das, was das Temperatur-Scaling anpasst, und nicht das, was der berichtete ECE misst. Siehe answer_confidence.

ece_score(conf: np.ndarray, correct: np.ndarray, bins: int = 15) -> float

Erwarteter Kalibrierungsfehler (ECE) über Konfidenz-Bins.

fit_temperatures = fit_temperature_map

fit_one_temperature(pairs: Sequence, min_n: Optional[int] = None) -> float

Passt einen skalaren T über NLL + LBFGS auf log T an.

Das Ergebnis ist clamp_temperature der optimierten Skala, liegt also in [TEMP_MIN, TEMP_MAX] (oder ist der neutrale Wert 1.0, wenn der Wert keine Zahl ist). Gibt 1.0 zurück, wenn weniger als min_n Paare gegeben sind. min_n ist standardmäßig MIN_BUCKET_N (die Untergrenze pro Bucket). Typpegel-Anpassungen übergeben MIN_TYPE_N, das niedriger ist, ein Datensatz, der keinen Bucket füllt, bekommt also trotzdem einen Skalar, statt bei 1.0 zu bleiben.

fit_temperature_map(
    records: Iterable,
    compute_ece: bool = False,
    seed: int = 0,
) -> Dict[str, Any]

Passt Skalare auf Typpegel und Temperaturen pro Bucket an.

MIN_BUCKET_N ist die Untergrenze pro Bucket: kleinere Buckets werden aus temperature_by_options weggelassen, und der Skalar auf Typpegel deckt sie ab. MIN_TYPE_N ist die separate, niedrigere Untergrenze nur für diesen Skalar.

compute_ece=False (der Standard und der Pfad, den Agent.fit_temperatures speichert) passt auf jedem Datensatz an und gibt keinen report-Schlüssel zurück. seed wird auf diesem Pfad ignoriert.

compute_ece=True hält ECE_HOLDOUT_FRAC jedes Buckets zurück, stratifiziert nach temp_bucket, unter Verwendung von seed, damit dieselben Datensätze immer gleich aufgeteilt werden. Die Temperaturen werden nur auf dem Rest angepasst und der ECE nur auf den zurückgehaltenen Datensätzen bewertet. report["n"] ist die Anzahl der übergebenen Datensätze; report["n_eval"] ist die zurückgehaltene Anzahl, auf der der ECE beruht. Ein Bucket, das nach dem Holdout unter MIN_BUCKET_N fallen würde, wird auf allen seinen Datensätzen angepasst, aus dem Eval-Set gelassen und in report["buckets_excluded_from_eval"] genannt, statt verworfen zu werden. n_by_bucket zählt immer die vollständige Eingabe, auch wenn die Anpassung selbst eine Teilmenge nutzte.

fit_abstention_thresholds(
    records: Iterable,
    temperature: Sequence[float],
    temperature_by_options: Dict[str, float],
    binning_map: Optional[Dict[str, Dict[str, Any]]] = None,
    target_error: float = 0.10,
    min_bucket_n: int = MIN_ABSTAIN_BUCKET_N,
    MIN_ABSTAIN_BUCKET_N,
    conservative: bool = True,
) -> Dict[str, float]

Passt eine Enthaltungsschwelle pro temp_bucket an, damit ein Gate in jedem Bucket einen Ziel-Fehler einhält.

Eine einzelne min_confidence überträgt sich nicht über Optionsanzahlen hinweg (#394): Die kalibrierte Konfidenz einer Antwort mit 2 Optionen und einer mit 12 Optionen liegen auf verschiedenen Skalen, also führt ein Schnitt je nach Frage zu zu viel oder zu wenig Enthaltung. Dies passt stattdessen einen Schnitt pro Bucket an, genau wie temperature_by_options verschlüsselt (common.temp_bucket, z. B. "choice:3-5"), und das Ergebnis ist ein min_confidence-Mapping, das :func:laya.confidence.check_min_confidence / :func:laya.confidence.apply_confidence_gate direkt akzeptieren.

records sind dieselben (qtype, logits, target[, k])-Tupel, die fit_temperature_map konsumiert (records_from_labeled baut sie). Konfidenz ist das kalibrierte max(p) -- die Logits werden zuerst mit der angepassten temperature / temperature_by_options skaliert, sodass Schwellen und die Zahlen, die die Laufzeit berichtet, auf derselben Skala liegen. target_error ist der tolerierte Fehler unter den akzeptierten Antworten; min_bucket_n lässt zu kleine Buckets weg, und conservative fügt eine Ein-Stichproben-Marge hinzu. Die Schwellen sind empirische Schnitte auf dem Kalibriersatz, keine formale Abdeckungsgarantie -- validiere auf zurückgehaltenen Daten (fit_temperature_map(..., compute_ece=True) liefert einen Holdout-Split) für ein Produktions-Gate.

Übergib binning_map, wenn der Agent, der diese Schwellen bedienen wird, eines installiert hat -- durch Agent.fit_binning, oder durch einen Kalibrier-Payload, der binning_map trägt --, weil die Laufzeit answer_confidence durch dieses Mapping neu kalibriert, bevor irgendetwas es liest, sodass ein ohne es angepasster Schnitt ein Schnitt auf einer Skala ist, die das Gate nie sieht. Die Schwellen liegen dann auf der gebinnten Skala, und die Reihenfolge, in der die beiden angepasst wurden, spielt keine Rolle mehr. Gemessen an 1,200 synthetischen 12-Options-Datensätzen bei target_error=0.10: Der ohne Mapping angepasste Schnitt hält 9.8% Fehler über 50% Abdeckung bei un-gebinnten Konfidenzen und lässt 94.5% der Antworten bei 25.6% Fehler zu, sobald dieselbe Zahl gegen gebinnte verglichen wird.

fit_binning_map(
    records: Iterable,
    temperature: Sequence[float],
    temperature_by_options: Dict[str, float],
    bins: int = 15,
    min_bucket_n: int = MIN_BINNING_BUCKET_N,
    MIN_BINNING_BUCKET_N,
) -> Dict[str, Dict[str, Any]]

Passt ein Histogramm-Binning-Neukalibrierungs-Mapping pro temp_bucket für answer_confidence an.

Temperatur-Scaling wendet einen Skalar pro Bucket an; es kann ein Bucket nicht reparieren, dessen Zuverlässigkeits- kurve kein einfaches Schärfen/Abschwächen ist (das pathologische choice:11+, das der mitgelieferte englische Checkpoint trägt, ist eines). Histogramm-Binning ist die nicht-parametrische Alternative: Teile die kalibrierten Konfidenzen eines Buckets in bins gleich breite Bins über [0, 1] auf und ordne jede Konfidenz, die in ein Bin fällt, der empirischen Genauigkeit dieses Bins zu. Es braucht keine Monotonie- annahme und keine zusätzliche Abhängigkeit (nur NumPy; isotonische Regression würde scikit-learn hereinziehen).

records sind dieselben (qtype, logits, target[, k])-Tupel, die fit_temperature_map konsumiert; Konfidenz ist das kalibrierte max(p) (Logits zuerst mit der angepassten temperature / temperature_by_options skaliert), sodass ein Binning-Mapping auf einem Temperatur-Mapping aufsetzt, statt es zu ersetzen. Gibt {bucket: {"bins": N, "values": [recalibrated confidence per bin]}} zurück; Buckets unter min_bucket_n werden weggelassen. Wende es mit :func:apply_binning_map an. Ein leeres Bin (ein Konfidenzbereich, den der Kalibriersatz nie erzeugt hat) wird auf seinen eigenen Mittelpunkt abgebildet, d. h. lässt diesen Bereich unverändert, sodass ein ungesehener Wert nie auf eine erfundene 0 neu kalibriert wird.

apply_binning_map(
    confidence: float,
    bucket: str,
    binning_map: Dict[str, Dict[str, Any]],
) -> float

Kalibriert eine answer_confidence für ihr Optionsanzahl-bucket (common.temp_bucket) neu.

Gibt die Konfidenz unverändert zurück, wenn das Mapping keinen Eintrag für das Bucket hat, damit ein Bucket, für das das Mapping nicht angepasst wurde, durchgereicht wird, statt auf einen falschen Wert gezwungen zu werden.

fit_binning(
    records,
    min_bucket_n: int = MIN_BINNING_BUCKET_N,
    MIN_BINNING_BUCKET_N,
) -> Dict[str, Any]

Passt ein Histogramm-Binning-Mapping auf die angepassten Temperaturen dieses Agent an und speichert es.

records sind dieselben (qtype, logits, target[, k])-Tupel, die fit_temperatures konsumiert. Das Mapping ist genau wie temperature_by_options verschlüsselt, setzt auf den aktuellen Temperaturen auf und wird von save_calibration als binning_map geschrieben.

render_options(q: Dict) -> List[str]

Rendert Options-Texte in Label-Index-Reihenfolge. Die semantische Reihenfolge von Noul ist immer [false, true].

proper_reward(
    q: torch.Tensor,
    target: torch.Tensor,
    qtype: torch.Tensor,
    mask: torch.Tensor,
    w_sph: float = 0.5,
    w_rps: float = 1.0,
    log_floor: float = -9.21,
) -> torch.Tensor

Belohnung einer strikt properen Scoring-Regel: log score + spherical score + ranked probability score.

q: [..., N, K] berichtete Verteilungen target: [N, K] (One-Hot- oder weiche Zielverteilungen)

td_lambda_targets(p_true: torch.Tensor, batch: Dict, lam: float = 1.0) -> torch.Tensor

TD(lambda)-Ziele für mehrrundige Gesprächsverläufe.

QTYPES = {"choice": 0, "score": 1, "noul": 2}

QTYPE_NAMES = {v: k for k, v in QTYPES.items()}