Agent

laya.Agent は 1 つのチェックポイントを読み込み、state についての型付きの質問に答えます。laya.load は Agent(...) のショートカットで、laya.RLAgent は Agent の別名です。ONNXAgent はエクスポート済みの ONNX モデルを CPU で実行し、laya.onnx_agent からインポートします。

名前・型・既定値・コードは英語のまま、それ以外は翻訳です（未翻訳の項目は英語原文のまま表示されます）。

Agent

Agent(
    model_id_or_path: str = "convaiinnovations/laya",
    device: Optional[str] = None,
    token: Optional[str] = None,
    subfolder: Optional[str] = None,
    fast: bool = False,
    compile: bool = False,
    revision: Optional[str] = None,
    expected_sha256: Optional[Dict[str, str]] = None,
    lang_temperatures: Optional[Dict[str, Dict[str, Any]]] = None,
    hooks=None,
    on_predict_start=None,
    on_predict_end=None,
    hooks_raise: bool = True,
    hooks_concurrent: bool = True,
    hooks_timeout: Optional[float] = None,
    calibration: Optional[str] = None,
)

基底クラス: HookRegistry

System 1 意思決定モデルのランタイム。高速で、非自己回帰で、較正された意思決定を行います。

dtype は自動キャストの目標であって、すべての呼び出しの精度ではありません。MPS では行数が mps_amp_min_rows 以上のときだけ呼び出しが自動キャストするので、dtype が float16 でも、ある呼び出しは float32 で動きます。dtype_for(rows) は行数 rows の呼び出しの精度を返します。

Laya のチェックポイントを読み込みます。

revision は Hub からのダウンロードを明示的なコミット SHA／ブランチ／タグに固定します（任意）。省略した場合は huggingface_hub の通常の既定値と既存のオフラインキャッシュが使われます。expected_sha256（{checkpoint ディレクトリからの相対パス: 16 進ダイジェスト}）は、重みが解析または実行される前に成果物の完全性を検証します。オプトインで、ローカルディレクトリにも適用されます。成果物が見つからなければ FileNotFoundError、ダイジェストが一致しなければ ValueError を送出し、どちらの場合も読み込みを拒否します。

fast=True はエンコーダー／ヘッドのフォワードを TileLang の高速パスに差し替えます（CUDA のみ。pip install laya[fast] が必要）。Agent.accelerate を参照してください。

compile=True はモデルを torch.compile の下で動かし、ModernBERT エンコーダーの reference_compile を有効にします。torch.compile は入力形状ごとに特化しますが、Laya はほぼすべてのリクエストで新しい形状に出会うため、それらのグラフはたいてい元が取れません。トラフィックが反復的なときに使ってください。fast=True が優先されます。TileLang のパスは、コンパイルされるはずだったフォワードを置き換えるからです。

subfolder は、複数を同梱するリポジトリから 1 つのチェックポイントを選びます（例：Agent("convaiinnovations/laya", subfolder="multilingual")）。そのサブフォルダだけがダウンロードされるので、同梱によってすべての利用者が一族全体のコストを払うことはありません。

calibration は temperature と temperature_by_options を含む任意の JSON パスです。チェックポイントの設定のあとに適用されるので、当てはめたマップが model.safetensors を書き換えずに同梱のスカラーを上書きできます。

hooks / on_predict_start / on_predict_end はすべての予測を観察または形成します。laya.hooks を参照してください。hooks_raise=False ではフックが失敗しても警告して続行し、hooks_concurrent=False は並列実行が安全でないフックを直列化し、hooks_timeout はフック呼び出し 1 回あたりを秒で制限します（None は無制限）。

引数

model_id_or_pathstr= "convaiinnovations/laya"
deviceOptional[str]= None
tokenOptional[str]= None
subfolderOptional[str]= None
fastbool= False
compilebool= False
revisionOptional[str]= None
expected_sha256Optional[Dict[str, str]]= None
lang_temperaturesOptional[Dict[str, Dict[str, Any]]]= None
hooks= None
on_predict_start= None
on_predict_end= None
hooks_raisebool= True
hooks_concurrentbool= True
hooks_timeoutOptional[float]= None
calibrationOptional[str]= None

accelerate

accelerate(use_graphs: bool = True, strict: bool = False)

モデルのフォワードを TileLang の高速パスに差し替えます（融合された GEMM/GEGLU/LayerNorm/RoPE カーネル、スライディングウィンドウの flash attention、16 ビットの常駐重み、形状バケットごとの CUDA グラフ）。

高速パスは、呼び出し時点でのエージェントの自動キャスト dtype（bf16 または fp16）で動くので、置き換える元のフォワードと丸め誤差の範囲で一致します（benchmarks/parity_fast.py を参照）。agent.dtype を変更したあとは、deaccelerate() を呼んでから accelerate() を呼び、再構築してください。有効化できれば True を返します。strict=False のときは、どのような失敗（CUDA がない、tilelang がない）でも元のパスがそのまま残ります。

引数

use_graphsbool= True
strictbool= False

warmup

warmup(shapes=None) -> float

各形状の合成入力で今すぐフォワードを実行し、かかった秒数を返します。

compile=True はグラフを必要とする最初のリクエストでトレースとコンパイルを行い（GPU では数十秒）、fast=True は初回使用時に形状バケットごとのカーネルと CUDA グラフを構築します。読み込み後、サービング前にこれを呼んでおくと、そのコストを最初のいくつかのリクエストから外へ移せます。元のフォワードでは、これは普通のフォワードパス数回分です。shapes は (rows, tokens, markers) のリストです。tokens はエージェントの max_len で上限が掛かります。呼び出し側に何かが返されたり記録されたりすることはなく、フックも走りません。

引数

shapes= None

deaccelerate

deaccelerate()

元のフォワードに戻します。

dtype_for

dtype_for(rows: int) -> torch.dtype

rows 個の質問行を持つフォワードパスが動く精度です。

dtype は読み込み時に 1 度だけ設定される自動キャストの目標です。フォワードが自動キャストするかどうかは呼び出しごとに決まります。MPS では行数が mps_amp_min_rows 以上のときだけです。行数 rows のフォワードが自動キャストするときは dtype を返し、そうでなければ torch.float32 を返します。predict 呼び出しは質問ごとに 1 行を実行します。

引数

rowsint

predict_batch

predict_batch(
    states: List[Union[str, dict, list]],
    questions: Dict[str, Dict[str, Any]],
    batch_size: Optional[int] = None,
    lang: Optional[str] = None,
    hooks=None,
    on_predict_start=None,
    on_predict_end=None,
    hooks_raise: Optional[bool] = None,
    hooks_timeout: Optional[float] = None,
    max_len: Optional[int] = None,
    head_max_len: Optional[int] = None,
    sort_by_length: bool = False,
    min_confidence: Optional[float] = None,
) -> List[Dict[str, Any]]

同じ質問を多数の状態に対して評価し、それらを共有のフォワードパスにまとめます。

これがスループットの経路です。system_one/predict は 1 回のフォワードパスで 1 つの状態を扱うので、GPU ではバッチ次元のほとんどが遊びます。predict_batch は複数の状態の質問行を 1 つのテンソルにまとめるため、N 回の逐次フォワードパスが要った呼び出しが 1 回（または ceil(len(states) / batch_size) 回）で済み、GPU では決定あたり数倍速くなります。

引数

statesList[Union[str, dict, list]]: 状態のリスト（各要素はテキスト文字列、JSON 辞書、または会話ターンのリスト）。同じ questions がすべての状態に対して評価されます。
questionsDict[str, Dict[str, Any]]: 質問定義。system_one が受け付けるものとまったく同じです。
batch_sizeOptional[int]= None: フォワードパスあたりの状態数の任意の上限。None はすべてを 1 回で送ります。多数または長い状態をまとめるときは、これを設定してピークメモリを抑えてください。
langOptional[str]= None
hooksHookArg= None: 呼び出しごとのフック。Agent にインストール済みのフックの後ろに追加されます。laya.hooks を参照してください。
on_predict_startPredictHookArg= None: 呼び出しごとの開始フック。状態／質問を書き換えたり、ctx.skip(...) を呼んで推論を短絡したりできます。
on_predict_endPredictHookArg= None: 呼び出しごとの終了フック。結果を書き換えられます。
hooks_raiseOptional[bool]= None: この呼び出しにおける Agent の hooks_raise を上書きします。
hooks_timeoutOptional[float]= None: この呼び出しにおける Agent の hooks_timeout を上書きします。
max_lenOptional[int]= None: この呼び出しにおけるエージェント設定の max_len を上書きします。開始フックが ctx.max_len を設定してトークン予算を形作ることもできます。
head_max_lenOptional[int]= None: この呼び出しにおけるエージェント設定の head_max_len を上書きします。開始フックが ctx.head_max_len を設定することもできます。
sort_by_lengthbool= False: エンコード後の長さが近い状態を 8 バッチ分の窓にまとめ、padding を減らします。1 より大きく、状態数より小さい batch_size を明示する必要があります。そうでなければ効果はありません。結果は入力順を保ちます。これはトークン化済みの状態を 1 バッチ分ではなく最大 8 バッチ分バッファします。バッチの形状が変わると、浮動小数点の予測がわずかに変わることがあります。
min_confidenceOptional[float]= None

戻り値

状態ごとの結果辞書のリスト。それぞれの形は system_one の出力と同一で、states と添字で対応します。

predict_long

predict_long(
    state: Union[str, dict, list],
    questions: Dict[str, Dict[str, Any]],
    window: Optional[int] = None,
    stride: Optional[int] = None,
    aggregate: str = "auto",
    batch_size: Optional[int] = None,
    lang: Optional[str] = None,
    hooks=None,
    on_predict_start=None,
    on_predict_end=None,
    hooks_raise: Optional[bool] = None,
    hooks_timeout: Optional[float] = None,
) -> Dict[str, Any]

文脈長を超える状態に対して質問を評価します。重なり合うウィンドウで走査し、質問ごとに集約します。

system_one/predict は max_len を超える状態を 1 つのウィンドウ（最初、会話リストでは最後）に切り詰め、残りを黙って捨てます。predict_long は状態を 1 回だけトークン化し、重なり合うトークンウィンドウに分け、共有のフォワードパス（predict_batch 経由）で各ウィンドウを採点し、ウィンドウごとの答えを統合します。

noul -> P(true) は各ウィンドウの最大値です（どのウィンドウかが支えればその言明は成り立ちます）
choice-> 最も自信のある単一のウィンドウの答えです。局所的な信号が、長い文書の大半を占める多くの中性的なウィンドウに投票で負けないようにするためです（平均すると埋もれます —— 中性的な多数が支配します）
score -> 同じく最も自信のあるウィンドウのレベルです

返される確率／信頼度は決定したウィンドウのもので、文書全体に対して較正された数値ではありません。信号がなくても noul の多ウィンドウ最大値はウィンドウ数とともに上がりますし、文書に決定的な内容が何もなければ choice が自信を持って中性的なウィンドウに着地することがあります。そこで各答えは answer["window"] を持ちます —— 決定したウィンドウの index、トークン化後の状態における token_start/token_end、そしてウィンドウの count です —— 呼び出し側は生の数値を信じるのではなく、答えがどの範囲から来たのかを調べられます。

すでに 1 つのウィンドウに収まる状態は system_one にそのまま渡されます（出力は同一）。

フックが包むのは、その状態に答える推論です。複数のウィンドウを要する文書では、それがウィンドウ全体にわたる 1 回の共有 predict_batch になります。on_predict_start は 1 回だけ発火し、ctx.states には走査順にデコード済みのウィンドウテキストが入ります —— 呼び出し側の state ではありません。あれはこれらを作るためにトークン化されたものです。この連鎖が何を残すかによって 3 つの結果があります。

ctx.skip([result]) が文書に答えます：ペイロードはウィンドウの帰属情報なしで返り、usage["windows"] は 0 です。何も採点されていないからです
このメソッドが組んだままの走査：すべてのウィンドウが採点され、各答えが answer["window"] を持ち、usage["windows"] はウィンドウ数です
書き換えられた走査（ctx.states が何らかの形で差し替えられた）：答えは採点された状態の上で集約されますが、どの答えも answer["window"] を持ちません —— 上記のオフセットはこのメソッドのウィンドウを記述したもので、モデルが読んだテキストではありません

引数

stateUnion[str, dict, list]
questionsDict[str, Dict[str, Any]]
windowOptional[int]= None: ウィンドウあたりの状態トークン数。既定は質問ごとの状態予算（max_len - head_max_len - 8）で、すべての質問が収まる最大値です。ウィンドウを小さくすると局所的な信号をよく分離できます（短い決定的範囲はウィンドウに占める割合が大きくなるので、そのウィンドウは明瞭に分類できます）が、ウィンドウ数が増えます。既定の大きいウィンドウは文脈とスループットを優先します。noul はこれに強く、決定的な範囲が長くほぼ中性的な文書のごく一部である場合、choice/score は小さいウィンドウのほうが有利です。
strideOptional[int]= None: ウィンドウ間のトークン刻み。既定は window // 2（50% の重なり）なので、境界の近くにある範囲もどこかのウィンドウに丸ごと収まります。
aggregatestr= "auto": "auto"（上記の型ごとの規則）が現時点で唯一のモードです。
batch_sizeOptional[int]= None: フォワードパスあたりのウィンドウ数の上限。非常に長い状態でメモリを抑えるためです。
langOptional[str]= None: 言語ごとの温度選択。system_one と同じです。
hooksHookArg= None: 呼び出しごとのフック。Agent にインストール済みのフックの後ろに追加されます。laya.hooks を参照してください。
on_predict_startPredictHookArg= None: 呼び出しごとの開始フック。system_one と同じです。
on_predict_endPredictHookArg= None: 呼び出しごとの終了フック。system_one と同じです。
hooks_raiseOptional[bool]= None: この呼び出しにおける Agent の hooks_raise を上書きします。
hooks_timeoutOptional[float]= None: この呼び出しにおける Agent の hooks_timeout を上書きします。

単一の結果辞書を返します。形は system_one と同じで、usage["windows"] が加わります。このキーは常に存在し、モデルが答えを出すために採点したウィンドウ数を数えます。1 つのウィンドウに収まる状態では 1、N 個の重なり合うウィンドウで走査した文書では N（開始フックが書き換えた場合はその N）、開始フックが文書に答えたり、どのウィンドウも読まれる前に採点する状態を残さなかった場合は 0 です —— どちらの経路でも同じなので、キャッシュされた答えがモデルの読んだウィンドウとして読まれることはありません。

複数のウィンドウにまたがる場合、切り詰めに関するキーは他の usage フィールドと同じように統合されます。truncated、state_tokens、state_tokens_dropped は合計され（したがって truncated は切り詰められたウィンドウ数で、トークン数には重なりが含まれます）、truncated_questions は最後のウィンドウのリストです。両者は食い違うことがあります。先のウィンドウだけが切り詰められた場合、truncated は 0 より大きく、truncated_questions は空です。ウィンドウが、ある質問のヘッドが残す余地より大きいときに切り詰められます。既定より大きい window か、max_len / head_max_len を狭める開始フックによるものです。ここでは is True ではなく usage["truncated"] > 0 を判定してください。

system_one

system_one(
    state: Union[str, dict, list],
    questions: Dict[str, Dict[str, Any]],
    lang: Optional[str] = None,
    hooks=None,
    on_predict_start=None,
    on_predict_end=None,
    hooks_raise: Optional[bool] = None,
    hooks_timeout: Optional[float] = None,
    max_len: Optional[int] = None,
    head_max_len: Optional[int] = None,
    min_confidence: Optional[float] = None,
) -> Dict[str, Any]

1 回の並列フォワードパスで、状態に対して型付きの質問を評価します。

引数

stateUnion[str, dict, list]

テキスト文字列、JSON 辞書、または会話ターンのリスト。

questionsDict[str, Dict[str, Any]]

question_id を質問定義に写す辞書。

choice: {"type": "choice", "instructions": "...", "criteria": {"optA": "...", ...}}
score: {"type": "score", "instructions": "...", "criteria": ["lvl0", "lvl1", ...]}
noul: {"type": "noul", "instructions": "...", "criteria": {"false": "...", "true": "..."}, "labels": {"false": "B", "true": "A"}}

Noul の criteria と labels は任意です。labels はモデルに見せるテキストだけを制御し、そのキーは false/true の意味を保ち、返される noul の値は常に P(true) です。互換性のため、labels の既定値は false/true です。

langOptional[str]= None

hooks= None

on_predict_start= None

on_predict_end= None

hooks_raiseOptional[bool]= None

hooks_timeoutOptional[float]= None

max_lenOptional[int]= None

head_max_lenOptional[int]= None

min_confidenceOptional[float]= None

戻り値

答え、確率、較正された信頼度、トークン使用量を含む辞書。質問が空のときは、トークン化もモデルのフォワードパスも行わず、空の答えとゼロのトークン使用量を返します。

ヘッドの予算によっていくつかの選択肢が同じトークン範囲に収まるとき、usage はそうなった各質問について options エントリを運びます —— total、distinct、tokens_per_option です。58 の区別できる範囲のうち 42 個から選ぶ答えの天井は、モデルではなく予算によるものだからです。選択肢がすべて残った質問は含まれないので、何も潰れなかったリクエストは変わりません。

usage は状態が収まったかどうかも報告します。truncated、state_tokens、state_tokens_dropped、そして truncated_questions（ヘッドが残した余地が小さすぎた質問）です。答えが状態全体を見たかどうかを気にする呼び出し側は、送った内容の長さから推測するのではなく usage["truncated"] を読むべきです。

多数の状態をまとめて採点するには predict_batch を参照してください。状態をまたいでフォワードパスを共有します。

decide

decide(
    state: Union[str, dict, list],
    schema: Any = None,
    questions: Optional[Dict[str, Any]] = None,
    return_details: bool = False,
    min_confidence: Optional[float] = None,
    predict_kwargs,
) -> Any

state をスキーマ（JSON schema または pydantic モデル）に照らして答え、型付きの値を返します。

laya.structured を参照してください。schema か questions のどちらか一方だけを渡します。追加のキーワード引数は predict / system_one に転送されます。

引数

stateUnion[str, dict, list]
schemaAny= None
questionsOptional[Dict[str, Any]]= None
return_detailsbool= False
min_confidenceOptional[float]= None
predict_kwargs

decide_batch

decide_batch(
    states: List[Union[str, dict, list]],
    schema: Any = None,
    questions: Optional[Dict[str, Any]] = None,
    return_details: bool = False,
    min_confidence: Optional[float] = None,
    predict_kwargs,
) -> List[Any]

複数の状態を 1 つのスキーマ（JSON schema または pydantic モデル）に照らして、1 回のバッチ呼び出しで答えます。

:meth:decide のスループット版です。スキーマは 1 回だけ計画され、その質問が :meth:predict_batch を通じてすべての状態に対して実行され（共有のフォワードパス、結果は入力順）、そのうえで各状態の答えが decide と同じように射影されます。追加のキーワード引数（batch_size=、lang=、hooks= など）は predict_batch に転送されます。laya.structured を参照してください。

引数

statesList[Union[str, dict, list]]
schemaAny= None
questionsOptional[Dict[str, Any]]= None
return_detailsbool= False
min_confidenceOptional[float]= None
predict_kwargs

fit_temperatures

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

CPU 上の記録からバケットごとの温度を当てはめ、このエージェントに保存します。

records は (qtype, logits, target, k) です。ラベル付きのフォワードがある場合は laya.calibrate.records_from_labeled で組み立ててください。このメソッドは重みをダウンロードせず、model.safetensors も書きません。seed は compute_ece が真のときのホールドアウト ECE 分割にだけ影響します。チェックポイントの cfg は読み込んだままにされます。

引数

records
compute_ecebool= False
seedint= 0

save_calibration

save_calibration(path: str) -> None

温度と、それをどのチェックポイント向けに当てはめたかを書き出します。重みは書きません。

引数

pathstr

load_calibration

load_calibration(path: str) -> None

save_calibration が書き出した JSON マップを、このエージェントに読み込みます。

version のないファイルはバージョン 1 とみなされ、そのまま読み込まれます。記録されたチェックポイントがこのエージェントと一致しない、より新しいファイルは警告を出しつつ読み込まれます。数値でない値や [TEMP_MIN, TEMP_MAX] の外にある値は、チェックポイントの読み込みと同じように clamp_temperature で丸められます。

引数

pathstr

load

load(
    model_id_or_path: str = "convaiinnovations/laya",
    device: Optional[str] = None,
    token: Optional[str] = None,
    subfolder: Optional[str] = None,
    fast: bool = False,
    compile: bool = False,
    revision: Optional[str] = None,
    expected_sha256: Optional[Dict[str, str]] = None,
    lang_temperatures: Optional[Dict[str, Dict[str, Any]]] = None,
    hooks=None,
    on_predict_start=None,
    on_predict_end=None,
    hooks_raise: bool = True,
    hooks_concurrent: bool = True,
    hooks_timeout: Optional[float] = None,
    calibration: Optional[str] = None,
) -> Agent

Laya のエージェントを読み込みます。

subfolder は、複数を同梱するリポジトリから 1 つのチェックポイントを選びます。

laya.load("convaiinnovations/laya")                           # English (repo root)
laya.load("convaiinnovations/laya", subfolder="multilingual")
laya.load("convaiinnovations/laya", fast=True)                # TileLang GPU fast path
laya.load("convaiinnovations/laya", compile=True)              # torch.compile the model

revision/expected_sha256 はダウンロードした成果物を固定して検証します。Agent を参照してください。hooks / on_predict_start / on_predict_end はすべての予測を観察または形成します。laya.hooks を参照してください。calibration は Agent が受け付けるのと同じ任意の JSON パスです。

引数

model_id_or_pathstr= "convaiinnovations/laya"
deviceOptional[str]= None
tokenOptional[str]= None
subfolderOptional[str]= None
fastbool= False
compilebool= False
revisionOptional[str]= None
expected_sha256Optional[Dict[str, str]]= None
lang_temperaturesOptional[Dict[str, Dict[str, Any]]]= None
hooks= None
on_predict_start= None
on_predict_end= None
hooks_raisebool= True
hooks_concurrentbool= True
hooks_timeoutOptional[float]= None
calibrationOptional[str]= None

ONNXAgent

ONNXAgent(
    model_id_or_path: str,
    onnx_path: str = "laya.onnx",
    token: Optional[str] = None,
    subfolder: Optional[str] = None,
    revision: Optional[str] = None,
    expected_sha256: Optional[Dict[str, str]] = None,
    hooks=None,
    on_predict_start=None,
    on_predict_end=None,
    hooks_raise: bool = True,
    hooks_concurrent: bool = True,
    hooks_timeout: Optional[float] = None,
    lang_temperatures: Optional[Dict[str, Dict[str, Any]]] = None,
    calibration: Optional[str] = None,
)

基底クラス: HookRegistry

ONNX 経由の System 1 意思決定モデルのランタイム。CPU 向けに最適化された高速な意思決定を行います。

ONNX Runtime をバックエンドとする Laya エージェントを読み込みます。

引数

model_id_or_pathstr: HuggingFace Hub の ID、または元の PyTorch チェックポイントへのローカルパス（トークナイザーと設定の読み込みに使います）。
onnx_pathstr= "laya.onnx": エクスポートした .onnx ファイルへのパス。
tokenOptional[str]= None: プライベートまたはゲート付きチェックポイント用の任意の HuggingFace トークン。省略時は Agent とまったく同じく $HF_TOKEN にフォールバックします。取得するのはトークナイザーと設定だけです —— グラフ自体はローカルの onnx_path です。
subfolderOptional[str]= None: 同梱リポジトリからダウンロードする場合の任意のサブフォルダ。
revisionOptional[str]= None: 任意の Hub リビジョン（コミット SHA／ブランチ／タグ）。省略した場合は huggingface_hub の通常の既定値と既存のオフラインキャッシュが使われます。
expected_sha256Optional[Dict[str, str]]= None: 任意の {checkpoint ディレクトリからの相対パス: 16 進ダイジェスト}。チェックポイントのファイルが解析される前に検証します。オプトインで、ローカルディレクトリにも適用されます。成果物が見つからなければ FileNotFoundError、ダイジェストが一致しなければ ValueError を送出し、どちらの場合も読み込みを拒否します。
hooksHookArg= None: オプトインの予測フック。laya.hooks を参照してください。
on_predict_startPredictHookArg= None: オプトインの開始フック。推論の前に実行されます。
on_predict_endPredictHookArg= None: オプトインの終了フック。推論のあとに実行されます。
hooks_raisebool= True: False のとき、フックが失敗しても警告して推論は続行します。
hooks_concurrentbool= True: False のとき、フックはロックで直列化されます。
hooks_timeoutOptional[float]= None: フック呼び出し 1 回あたりを秒で制限します。None は無制限です。
lang_temperaturesOptional[Dict[str, Dict[str, Any]]]= None: 言語コードをキーにした、任意の言語ごとの温度上書き。各項目は {"temperature": [3 floats], "temperature_by_options": {}} です。system_one/predict に lang= が渡されたときに適用され、PyTorch の Agent に対応します。そうでなければバックエンドをまたぐ差し替えで較正が失われます。
calibrationOptional[str]= None

load_calibration

load_calibration(path: str) -> None

save_calibration が書き出した JSON マップを、このエージェントに読み込みます。

引数

pathstr

system_one

system_one(
    state: Union[str, dict, list],
    questions: Dict[str, Dict[str, Any]],
    lang: Optional[str] = None,
    hooks=None,
    on_predict_start=None,
    on_predict_end=None,
    hooks_raise: Optional[bool] = None,
    hooks_timeout: Optional[float] = None,
    max_len: Optional[int] = None,
    head_max_len: Optional[int] = None,
    min_confidence: Optional[float] = None,
) -> Dict[str, Any]

1 回の ONNX Runtime セッション実行で、状態に対して型付きの質問を評価します。

lang は言語ごとの温度上書きを選びます（lang_temperatures を参照）。PyTorch の Agent.system_one とシグネチャが一致するので、どちらのバックエンドも他方の drop-in になります。

PyTorch の Agent.system_one とまったく同じく predict_batch を基礎として定義されているので、単一状態の経路とバッチの経路がずれることはありません。

引数

stateUnion[str, dict, list]: テキスト文字列、JSON 辞書、または会話ターンのリスト。
questionsDict[str, Dict[str, Any]]: 質問定義。Agent.system_one が受け付けるのと同じ形です。
langOptional[str]= None: 言語ごとの温度上書き（lang_temperatures を参照）。
hooksHookArg= None: 呼び出しごとのフック。エージェントにインストール済みのフックの後ろに追加されます。
on_predict_startPredictHookArg= None: 呼び出しごとの開始フック。状態／質問を書き換えたり、ctx.skip(...) を呼んで推論を短絡したりできます。
on_predict_endPredictHookArg= None: 呼び出しごとの終了フック。結果を書き換えられます。
hooks_raiseOptional[bool]= None: この呼び出しにおけるエージェントの hooks_raise を上書きします。
hooks_timeoutOptional[float]= None: この呼び出しにおけるエージェントの hooks_timeout を上書きします。
max_lenOptional[int]= None: この呼び出しにおける設定の max_len を上書きします。
head_max_lenOptional[int]= None: この呼び出しにおける設定の head_max_len を上書きします。
min_confidenceOptional[float]= None: answer_confidence に対するオプトインの棄権しきい値（#361）。これを下回る答えは low_confidence: True の印を付けて返されます。

戻り値

答え、確率、較正された信頼度、トークン使用量を含む辞書。

多数の状態をまとめて採点するには predict_batch を参照してください。状態をまたいでセッション実行を共有します。

predict_batch

predict_batch(
    states: List[Union[str, dict, list]],
    questions: Dict[str, Dict[str, Any]],
    batch_size: Optional[int] = None,
    lang: Optional[str] = None,
    hooks=None,
    on_predict_start=None,
    on_predict_end=None,
    hooks_raise: Optional[bool] = None,
    hooks_timeout: Optional[float] = None,
    max_len: Optional[int] = None,
    head_max_len: Optional[int] = None,
    sort_by_length: bool = False,
    min_confidence: Optional[float] = None,
) -> List[Dict[str, Any]]

同じ質問を多数の状態に対して評価し、ONNX Runtime のセッション実行を共有します。

laya.agent.Agent.predict_batch に対応するスループットの経路です。system_one はセッション実行 1 回につき 1 つの状態の質問行しかまとめないので、N 個の状態には N 回の実行がかかります。predict_batch は複数の状態の行を 1 回の実行に —— あるいは ceil(len(states) / batch_size) 回に —— まとめます。ONNX Runtime 自身の並列性が CPU で効いてくるのはここです。

引数

statesList[Union[str, dict, list]]: 状態のリスト（各要素はテキスト文字列、JSON 辞書、または会話ターンのリスト）。同じ questions がすべての状態に対して評価されます。
questionsDict[str, Dict[str, Any]]: 質問定義。system_one が受け付けるものとまったく同じです。
batch_sizeOptional[int]= None: セッション実行あたりの状態数の任意の上限。None はすべてを 1 回で送ります。多数または長い状態をまとめるときは、これを設定してピークメモリを抑えてください。
langOptional[str]= None: すべての状態に適用される言語ごとの温度上書き。lang_temperatures を参照してください。
hooksHookArg= None: 呼び出しごとのフック。エージェントにインストール済みのフックの後ろに追加されます。
on_predict_startPredictHookArg= None: 呼び出しごとの開始フック。状態／質問を書き換えたり、ctx.skip(...) を呼んで推論を短絡したりできます。
on_predict_endPredictHookArg= None: 呼び出しごとの終了フック。結果を書き換えられます。
hooks_raiseOptional[bool]= None: この呼び出しにおけるエージェントの hooks_raise を上書きします。
hooks_timeoutOptional[float]= None: この呼び出しにおけるエージェントの hooks_timeout を上書きします。
max_lenOptional[int]= None: この呼び出しにおける設定の max_len を上書きします。
head_max_lenOptional[int]= None: この呼び出しにおける設定の head_max_len を上書きします。
sort_by_lengthbool= False: エンコード後の長さが近い状態を 8 バッチ分の窓にまとめ、padding を減らします。Agent.predict_batch とまったく同じです。1 より大きく、状態数より小さい batch_size を明示する必要があります。そうでなければ効果はありません。結果は入力順を保ちます。バッチの形状が変わると、決定しきい値の近くで浮動小数点の予測がわずかに変わることがあります。
min_confidenceOptional[float]= None: answer_confidence に対するオプトインの棄権しきい値（#361）。これを下回る答えは low_confidence: True の印を付けて返されます。

戻り値

状態ごとの結果辞書のリスト。それぞれの形は system_one の出力と同一で、states と添字で対応します。

predict_long

predict_long(
    state: Union[str, dict, list],
    questions: Dict[str, Dict[str, Any]],
    window: Optional[int] = None,
    stride: Optional[int] = None,
    aggregate: str = "auto",
    batch_size: Optional[int] = None,
    lang: Optional[str] = None,
    hooks=None,
    on_predict_start=None,
    on_predict_end=None,
    hooks_raise: Optional[bool] = None,
    hooks_timeout: Optional[float] = None,
) -> Dict[str, Any]

文脈長を超える状態に対して質問を評価します。重なり合うウィンドウで走査し、質問ごとに集約します。

laya.agent.Agent.predict_long の ONNX 版で、集約の規則も同じです。system_one は max_len を超える状態を 1 つのウィンドウに切り詰め、残りを黙って捨てます。predict_long は状態を 1 回だけトークン化し、重なり合うトークンウィンドウに分け、predict_batch を通じて各ウィンドウを採点し（これにより、ウィンドウは 1 つずつコストを払うのではなく ONNX Runtime のセッション実行を共有します）、ウィンドウごとの答えを統合します。

noul -> P(true) は各ウィンドウの最大値です（どのウィンドウかが支えればその言明は成り立ちます）
choice-> 最も自信のある単一のウィンドウの答えです。局所的な信号が、長い文書の大半を占める多くの中性的なウィンドウに投票で負けないようにするためです
score -> 同じく最も自信のあるウィンドウのレベルです

返される確率／信頼度は決定したウィンドウのもので、文書全体に対して較正された数値ではありません。理由は PyTorch 側の説明と同じです。各答えは answer["window"] を持ちます —— 決定したウィンドウの index、トークン化後の状態における token_start/token_end、そしてウィンドウの count です。

すでに 1 つのウィンドウに収まる状態は system_one にそのまま渡されます（出力は同一）。

引数

stateUnion[str, dict, list]: テキスト文字列、JSON 辞書、または会話ターンのリスト。
questionsDict[str, Dict[str, Any]]: 質問定義。system_one が受け付けるものとまったく同じです。
windowOptional[int]= None: ウィンドウあたりの状態トークン数。既定は質問ごとの状態予算（max_len - head_max_len - 8）です。Agent.predict_long と同じく、ウィンドウを小さくすると局所的な信号をよく分離できますが、ウィンドウ数が増えます。
strideOptional[int]= None: ウィンドウ間のトークン刻み。既定は window // 2（50% の重なり）です。
aggregatestr= "auto": "auto"（上記の型ごとの規則）が現時点で唯一のモードです。
batch_sizeOptional[int]= None: セッション実行あたりのウィンドウ数の上限。非常に長い状態でメモリを抑えるためです。
langOptional[str]= None: 言語ごとの温度選択。system_one と同じです。
hooksHookArg= None: 呼び出しごとのフック。エージェントにインストール済みのフックの後ろに追加されます。Agent.predict_long の契約に従います。状態に答える推論を包み、ctx.skip(...) で答える開始フックは usage["windows"] == 0 とウィンドウ帰属情報なしを受け取り、書き換えられた走査は answer["window"] なしで集約されます。
on_predict_startPredictHookArg= None: 呼び出しごとの開始フック。system_one と同じです。
on_predict_endPredictHookArg= None: 呼び出しごとの終了フック。system_one と同じです。
hooks_raiseOptional[bool]= None: この呼び出しにおけるエージェントの hooks_raise を上書きします。
hooks_timeoutOptional[float]= None: この呼び出しにおけるエージェントの hooks_timeout を上書きします。

単一の結果辞書を返します。形は system_one と同じで、usage["windows"] が加わります。複数のウィンドウにまたがる場合、切り詰めに関するキーは Agent.predict_long と同じように統合されます。truncated はウィンドウ数で、truncated_questions は最後のウィンドウのリストなので、truncated が 0 より大きいのにリストが空、ということが起こりえます。

decide

decide(
    state: Union[str, dict, list],
    schema: Any = None,
    questions: Optional[Dict[str, Dict[str, Any]]] = None,
    return_details: bool = False,
    min_confidence: Optional[float] = None,
    predict_kwargs,
) -> Any

state をスキーマ（JSON schema または pydantic モデル）に照らして答え、型付きの値を返します。

引数

stateUnion[str, dict, list]
schemaAny= None
questionsOptional[Dict[str, Dict[str, Any]]]= None
return_detailsbool= False
min_confidenceOptional[float]= None
predict_kwargs

decide_batch

decide_batch(
    states: List[Union[str, dict, list]],
    schema: Any = None,
    questions: Optional[Dict[str, Dict[str, Any]]] = None,
    return_details: bool = False,
    min_confidence: Optional[float] = None,
    predict_kwargs,
) -> List[Any]

predict_batch を通じて、複数の状態を 1 つのスキーマに照らして答えます。laya.structured を参照してください。

引数

statesList[Union[str, dict, list]]
schemaAny= None
questionsOptional[Dict[str, Dict[str, Any]]]= None
return_detailsbool= False
min_confidenceOptional[float]= None
predict_kwargs

量子化エクスポート

scripts/export_onnx.py --quantize は、fp32 エクスポートの隣に INT8 の重みのみ量子化したコピーを書き出します（laya.onnx は laya.int8.onnx も生成します）。動的なチャネル単位量子化が MatMul の重みを int8 に変換し、活性値は fp32 のまま残すので、キャリブレーション用データセットは不要です。ONNXAgent は onnx_path をそこに向けるだけで結果を読み込みます。英語チェックポイント、CPU（M シリーズ、サポートチケットの state 20 件 × choice/noul/score）での実測：モデルファイルは 1.6 GB → 581 MB、state あたりの p50 レイテンシは約 340 ms → 約 250 ms（約 1.35 倍）、fp32 との意思決定の差はゼロ（単一確率の最大ドリフトは 0.09）でした。チャネル単位ではなくテンソル単位のスケールにすると、20 件のうち 3 件の state が反転し、ドリフトは最大 0.29 に達しました。これがエクスポータがチャネル単位を使う理由です。int8 のグラフは CPU 専用です。ONNX Runtime には CUDAExecutionProvider 上の INT8 MatMul カーネルがなく、GPU プロバイダはノード単位で黙ってフォールバックします。

python scripts/export_onnx.py --model convaiinnovations/laya --output laya.onnx --quantize