warpvector 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,607 @@
+/**
+ * 渡されたベクトルのL2ノルム（ユークリッド距離）を計算し、
+ * 長さが1になるように正規化（normalize）した新しい Float32Array を返します。
+ * コサイン類似度の計算前などに使用します。
+ *
+ * @param {number[] | Float32Array} vector - 正規化するベクトル
+ * @returns {Float32Array} 正規化された新しい Float32Array ベクトル。ゼロベクトルの場合はゼロベクトルのまま返します。
+ */
+declare function normalize(vector: number[] | Float32Array): Float32Array;
+/**
+ * 球面線形補間 (Slerp)
+ * 高次元の埋め込み空間において、幾何学的な構造（コサイン類似度）を維持したまま
+ * 2つのベクトル間を滑らかに補間します。
+ *
+ * @param {number[] | Float32Array} v1 - 始点ベクトル
+ * @param {number[] | Float32Array} v2 - 終点ベクトル
+ * @param {number} t - 補間係数 (0.0 〜 1.0)
+ * @returns {Float32Array} 補間後の新しいベクトル
+ * @throws {Error} ベクトルの次元数が異なる場合、またはゼロベクトルが指定された場合にエラーをスローします。
+ */
+declare function slerp(v1: number[] | Float32Array, v2: number[] | Float32Array, t: number): Float32Array;
+/**
+ * 内積 (Inner Product)
+ * 2つのベクトルの内積を計算します。
+ *
+ * @param {number[] | Float32Array} v1 - 1つ目のベクトル
+ * @param {number[] | Float32Array} v2 - 2つ目のベクトル
+ * @returns {number} 2つのベクトルの内積
+ * @throws {Error} ベクトルの次元数が異なる場合にエラーをスローします。
+ */
+declare function innerProduct(v1: number[] | Float32Array, v2: number[] | Float32Array): number;
+/**
+ * コサイン類似度 (Cosine Similarity)
+ * 2つのベクトル間のコサイン類似度 (-1.0 〜 1.0) を計算します。
+ *
+ * @param {number[] | Float32Array} v1 - 1つ目のベクトル
+ * @param {number[] | Float32Array} v2 - 2つ目のベクトル
+ * @returns {number} コサイン類似度 (-1.0 〜 1.0)。ゼロベクトルを含む場合は 0 を返します。
+ * @throws {Error} ベクトルの次元数が異なる場合にエラーをスローします。
+ */
+declare function cosineSimilarity(v1: number[] | Float32Array, v2: number[] | Float32Array): number;
+/**
+ * 直交射影による成分除去 (Orthogonal Rejection / Negative Prompting)
+ * baseVector から negativeVector の方向成分を完全に除去した新しいベクトルを返します。
+ * 数式: v' = v - (v・u / u・u) * u
+ *
+ * @param {number[] | Float32Array} baseVector - 元のベクトル (v)
+ * @param {number[] | Float32Array} negativeVector - 除去したい成分を持つベクトル (u)
+ * @returns {Float32Array} 成分が除去された新しいベクトル (v')
+ * @throws {Error} ベクトルの次元数が異なる場合にエラーをスローします。
+ */
+declare function reject(baseVector: number[] | Float32Array, negativeVector: number[] | Float32Array): Float32Array;
+/**
+ * 活性化関数の種類を定義します。
+ * @typedef {"relu" | "sigmoid" | "tanh"} Activation
+ */
+type Activation = "relu" | "sigmoid" | "tanh";
+/**
+ * ベクトルに対して非線形活性化関数を適用します (In-place処理)。
+ *
+ * @param {Float32Array} vector - 活性化関数を適用する対象のベクトル（直接変更されます）
+ * @param {Activation} [activation] - 適用する活性化関数の種類（"relu", "sigmoid", "tanh"）
+ * @returns {void}
+ */
+declare function applyActivationToVector(vector: Float32Array, activation?: Activation): void;
+/**
+ * Softmax関数の計算
+ * 数値の配列からSoftmax確率分布を計算します（オーバーフロー防止対策済み）。
+ *
+ * @param {number[]} values - 入力となる数値の配列
+ * @returns {number[]} 確率の合計が1.0となるSoftmax関数適用後の配列
+ */
+declare function softmax(values: number[]): number[];
+/**
+ * 2次元配列（行列）を指定した次元数で1次元のFloat32Arrayにフラット化します。
+ *
+ * @param {number[][]} matrix - 2次元配列の行列
+ * @param {number} rows - 期待される行数
+ * @param {number} cols - 期待される列数
+ * @param {string} contextName - エラーメッセージ用のコンテキスト名
+ * @returns {Float32Array} フラット化された1次元配列
+ * @throws {Error} 次元数が一致しない場合にエラーをスローします。
+ */
+declare function flattenMatrix(matrix: number[][], rows: number, cols: number, contextName?: string): Float32Array;
+/**
+ * ベクトルの次元数を検証します。
+ *
+ * @param {number[] | Float32Array} vector - 検証するベクトル
+ * @param {number} expectedDimension - 期待される次元数
+ * @param {string} contextName - エラーメッセージ用のコンテキスト名
+ * @throws {Error} 次元数が一致しない場合にエラーをスローします。
+ */
+declare function assertDimension(vector: number[] | Float32Array, expectedDimension: number, contextName?: string): void;
+
+/**
+ * 意図（コンテキスト）ごとの変換情報を定義するインターフェース
+ * @interface IntentWeights
+ */
+interface IntentWeights {
+    /**
+     * 空間を歪めるための変換行列 (W)
+     * 内部処理と互換性のため、number[][] と 1次元にフラット化された Float32Array の両方をサポートします。
+     * @type {number[][] | Float32Array}
+     */
+    matrix: number[][] | Float32Array;
+    /**
+     * 空間を特定の方向へシフトさせるバイアスベクトル (b)
+     * @type {number[] | Float32Array}
+     */
+    bias: number[] | Float32Array;
+    /**
+     * 自己アテンション型ブレンド（自動ルーティング）用の代表ベクトル (オプション)
+     * @type {number[] | Float32Array | undefined}
+     */
+    routingVector?: number[] | Float32Array;
+}
+/**
+ * 意図に応じたベクトル空間の動的変形（アフィン変換）を行うアダプタークラス。
+ * パフォーマンスのために内部ではすべての配列を Float32Array として扱い、
+ * 大規模なバッチ処理には自動的にWASM/SIMDによる最適化を利用します。
+ */
+declare class IntentAdapter {
+    private readonly dimension;
+    private readonly matrices;
+    private readonly biases;
+    private readonly routingVectors;
+    /**
+     * IntentAdapter を初期化します。
+     * 行列とバイアスを Float32Array にコンパイルし、キャッシュ局所性と計算速度を最適化します。
+     *
+     * @constructor
+     * @param {Record<string, IntentWeights> | number} intentsOrDimension - 各インテント名と IntentWeights のマッピング、または次元数（空から始める場合）
+     * @throws {Error} インテントが一つも提供されておらず、次元数も不明な場合にエラーをスローします。
+     */
+    constructor(intentsOrDimension: Record<string, IntentWeights> | number);
+    /**
+     * 実行時に新しい意図を動的に追加または更新します。
+     *
+     * @param {string} intentName - 追加する意図の名前
+     * @param {IntentWeights} weights - 意図の重み（行列とバイアス、任意でルーティングベクトル）
+     * @throws {Error} 行列やバイアスの次元数が現在の次元数と一致しない場合にエラーをスローします。
+     * @returns {void}
+     */
+    addIntent(intentName: string, weights: IntentWeights): void;
+    /**
+     * 指定した意図を削除します。
+     *
+     * @param {string} intentName - 削除する意図の名前
+     * @returns {void}
+     */
+    removeIntent(intentName: string): void;
+    /**
+     * 行列とバイアスを用いてベクトルにアフィン変換を適用する内部関数 (x' = W * x + b)
+     *
+     * @param {Float32Array} matrix - フラット化された変換行列
+     * @param {Float32Array} bias - バイアスベクトル
+     * @param {number[] | Float32Array} vector - 変換元の入力ベクトル
+     * @param {Float32Array} result - 計算結果を格納する配列 (出力先)
+     * @returns {void}
+     */
+    private applyAffine;
+    /**
+     * 複数の意図を指定された重みでブレンドした一時的な行列とバイアスを計算します。
+     * W_blend = Σ(w_i * W_i), b_blend = Σ(w_i * b_i)
+     *
+     * @param {Record<string, number>} blendWeights - ブレンドする各意図の重みマップ
+     * @returns {{matrix: Float32Array, bias: Float32Array}} ブレンドされた合成行列とバイアス
+     * @throws {Error} 指定された意図が見つからない場合にエラーをスローします。
+     */
+    private computeBlendedWeights;
+    /**
+     * 指定された意図（intent）に基づいて、ベースベクトルにアフィン変換を適用します。
+     * 数式: x' = W_I * x + b_I
+     *
+     * @param {number[] | Float32Array} baseVector - 変換元のベクトル
+     * @param {string} intent - 適用する意図（intent）の名前
+     * @param {Activation} [activation] - （オプション）変換後に適用する非線形活性化関数
+     * @returns {Float32Array} 変換後のベクトル
+     * @throws {Error} ベクトルの次元数が一致しない場合、または指定された意図が存在しない場合にエラーをスローします。
+     */
+    tune(baseVector: number[] | Float32Array, intent: string, activation?: Activation): Float32Array;
+    /**
+     * 複数のベースベクトルに対して、指定された意図のアフィン変換をバッチ処理で適用します。
+     * メモリと条件が許せば、自動的にWASM/SIMDエンジンにオフロードして超高速処理を行います。
+     *
+     * @param {(number[] | Float32Array)[]} baseVectors - 変換元のベクトルの配列 (2次元配列)
+     * @param {string} intent - 適用する意図（intent）の名前
+     * @param {Activation} [activation] - （オプション）非線形活性化関数
+     * @returns {Float32Array[]} 変換後のベクトルの配列
+     * @throws {Error} 指定された意図が存在しない場合や入力ベクトルの次元が不正な場合にエラーをスローします。
+     */
+    tuneBatch(baseVectors: (number[] | Float32Array)[], intent: string, activation?: Activation): Float32Array[];
+    /**
+     * 複数の意図を指定された重みでブレンドし、ベクトルにアフィン変換を適用します。
+     *
+     * @param {number[] | Float32Array} baseVector - 変換元のベクトル
+     * @param {Record<string, number>} blendWeights - 意図の名前と重みのマッピング (例: { riskAnalysis: 0.7, economicImpact: 0.3 })
+     * @param {Activation} [activation] - （オプション）非線形活性化関数
+     * @returns {Float32Array} 変換後のベクトル
+     * @throws {Error} 入力ベクトルの次元が不正な場合、または指定された意図が存在しない場合にエラーをスローします。
+     */
+    tuneBlended(baseVector: number[] | Float32Array, blendWeights: Record<string, number>, activation?: Activation): Float32Array;
+    /**
+     * 複数の意図を指定された重みでブレンドし、複数のベクトルに一括で適用します。
+     * これもバッチ処理と同様に自動的にWASM最適化が有効になります。
+     *
+     * @param {(number[] | Float32Array)[]} baseVectors - 変換元のベクトルの配列
+     * @param {Record<string, number>} blendWeights - 意図の名前と重みのマッピング
+     * @param {Activation} [activation] - （オプション）非線形活性化関数
+     * @returns {Float32Array[]} 変換後のベクトルの配列
+     * @throws {Error} ベクトルの次元数が一致しない場合、または指定された意図が存在しない場合にエラーをスローします。
+     */
+    tuneBatchBlended(baseVectors: (number[] | Float32Array)[], blendWeights: Record<string, number>, activation?: Activation): Float32Array[];
+    /**
+     * 自己アテンション型動的ブレンド (Auto-blending / Routing)
+     *
+     * クエリとして入力されたベースベクトル自体と、各意図の `routingVector`（代表ベクトル）の
+     * 類似度を比較し、Softmax関数により最適なブレンド比率を自動で算出・適用します。
+     *
+     * @param {number[] | Float32Array} baseVector - ユーザーからのクエリベクトルなど
+     * @param {Activation} [activation] - （オプション）非線形活性化関数
+     * @returns {Float32Array} 動的ブレンドによって変換されたベクトル
+     * @throws {Error} ベースベクトルの次元が異なる場合、またはルーティングベクトルが一つも存在しない場合にエラーをスローします。
+     */
+    tuneAutoBlended(baseVector: number[] | Float32Array, activation?: Activation): Float32Array;
+    /**
+     * 学習済みの意図（IntentWeights）を軽量なバイナリ（Uint8Array）としてシリアライズします。
+     * これにより、JSONに比べてファイルサイズが劇的に小さくなり、ロードも高速になります。
+     *
+     * @param {string} intentName - エクスポートする意図の名前
+     * @returns {Uint8Array} シリアライズされたバイナリデータ
+     */
+    exportIntentBinary(intentName: string): Uint8Array;
+    /**
+     * バイナリデータ（Uint8Array）から IntentWeights を復元し、
+     * そのままアダプターに新しい意図として追加します。
+     *
+     * @param {string} intentName - 追加する意図の名前
+     * @param {Uint8Array} binary - exportIntentBinary で生成されたバイナリデータ
+     */
+    importIntentBinary(intentName: string, binary: Uint8Array): void;
+}
+
+/**
+ * 低ランク適応（LoRA）の重みを定義するインターフェース
+ * @interface LoraIntentWeights
+ */
+interface LoraIntentWeights {
+    /**
+     * 行列A: 次元数を rank から dimension に拡張する行列
+     * @type {number[][]}
+     */
+    matrixA: number[][];
+    /**
+     * 行列B: 次元数を dimension から rank に圧縮する行列
+     * @type {number[][]}
+     */
+    matrixB: number[][];
+    /**
+     * バイアスベクトル
+     * @type {number[]}
+     */
+    bias: number[];
+}
+/**
+ * LoraIntentAdapter クラス
+ * 低ランク行列（A, B）を使用して高次元ベクトルのアフィン変換をメモリ効率良く行います。
+ */
+declare class LoraIntentAdapter {
+    private readonly dimension;
+    private readonly rank;
+    private readonly matricesA;
+    private readonly matricesB;
+    private readonly biases;
+    /**
+     * LoraIntentAdapter を初期化します。
+     * 非常に高い次元（例：1536次元など）の埋め込みベクトルに対して、
+     * フルマトリックスの代わりに低ランク行列（A, B）を使用することで
+     * メモリ使用量と計算量を劇的に削減します。
+     *
+     * @constructor
+     * @param {number} dimension - ベクトル空間の元の次元数（D）
+     * @param {number} rank - 低ランク適応における中間ランク数（r）
+     * @param {Record<string, LoraIntentWeights>} [intents] - 初期化時に追加するインテントのマップ
+     */
+    constructor(dimension: number, rank: number, intents?: Record<string, LoraIntentWeights>);
+    /**
+     * 実行時に新しいLoRA意図を動的に追加または更新します。
+     *
+     * @param {string} intentName - 追加または更新する意図の名前
+     * @param {LoraIntentWeights} weights - LoRA意図の重み（行列A、行列B、バイアス）
+     * @throws {Error} 行列またはバイアスの次元数が一致しない場合にエラーをスローします。
+     * @returns {void}
+     */
+    addIntent(intentName: string, weights: LoraIntentWeights): void;
+    /**
+     * 指定したLoRA意図を削除します。
+     *
+     * @param {string} intentName - 削除する意図の名前
+     * @returns {void}
+     */
+    removeIntent(intentName: string): void;
+    /**
+     * LoRAアプローチを用いてベクトルにアフィン変換を適用します。
+     * 数式: x' = x + A(Bx) + b
+     *
+     * @param {number[] | Float32Array} baseVector - 変換元のベクトル
+     * @param {string} intent - 適用する意図の名前
+     * @returns {Float32Array} LoRA変換と残差結合が適用された新しいベクトル
+     * @throws {Error} ベクトルの次元数が一致しない、または指定された意図が存在しない場合にエラーをスローします。
+     */
+    tune(baseVector: number[] | Float32Array, intent: string): Float32Array;
+}
+
+/**
+ * 次元削減/拡張のための射影行列の重みを定義するインターフェース
+ * @interface ProjectionWeights
+ */
+interface ProjectionWeights {
+    /**
+     * 射影変換行列
+     * 行数が outDimension、列数が inDimension となります。
+     * @type {number[][]}
+     */
+    matrix: number[][];
+    /**
+     * オプションのバイアスベクトル
+     * @type {number[] | Float32Array}
+     */
+    bias?: number[] | Float32Array;
+}
+/**
+ * ProjectionAdapter クラス
+ * PCAやSVDなどで事前計算された射影行列を用いて、ベクトルの次元削減（または拡張）を行います。
+ */
+declare class ProjectionAdapter {
+    private readonly inDimension;
+    private readonly outDimension;
+    private readonly matrices;
+    private readonly biases;
+    /**
+     * ProjectionAdapter を初期化します。
+     *
+     * @constructor
+     * @param {number} inDimension - 変換前の入力ベクトルの次元数
+     * @param {number} outDimension - 変換後の出力ベクトルの次元数
+     * @param {Record<string, ProjectionWeights>} [projections] - 初期化時に追加する射影設定のマップ
+     */
+    constructor(inDimension: number, outDimension: number, projections?: Record<string, ProjectionWeights>);
+    /**
+     * 実行時に新しい射影設定を動的に追加または更新します。
+     *
+     * @param {string} name - 追加または更新する射影設定の名前
+     * @param {ProjectionWeights} weights - 射影変換行列のデータ
+     * @throws {Error} 行列のサイズが指定された次元数と一致しない場合にエラーをスローします。
+     * @returns {void}
+     */
+    addProjection(name: string, weights: ProjectionWeights): void;
+    /**
+     * 指定した射影設定を削除します。
+     *
+     * @param {string} name - 削除する射影設定の名前
+     * @returns {void}
+     */
+    removeProjection(name: string): void;
+    /**
+     * ベクトルに射影変換を適用し、次元を変更した新しいベクトルを返します。
+     * 数式: y = W * x
+     *
+     * @param {number[] | Float32Array} baseVector - 変換元の入力ベクトル
+     * @param {string} projectionName - 適用する射影設定の名前
+     * @returns {Float32Array} 射影変換適用後の新しいベクトル
+     * @throws {Error} ベクトルの次元数が inDimension と一致しない場合、または射影設定が存在しない場合にエラーをスローします。
+     */
+    project(baseVector: number[] | Float32Array, projectionName: string): Float32Array;
+}
+
+/**
+ * 基本的な学習オプションを定義するインターフェース。
+ * 勾配降下法における各種ハイパーパラメータを設定します。
+ */
+interface BaseTrainingOptions {
+    /** 学習率 (Learning Rate)。1ステップで重みをどれだけ更新するか。デフォルト: 0.01 */
+    learningRate?: number;
+    /** 学習のエポック数 (データセット全体を何回繰り返して学習するか)。デフォルト: 100 */
+    epochs?: number;
+    /** L2正則化の強さ。過学習を防ぐために使用します。デフォルト: 0.001 */
+    regularization?: number;
+    /** モーメンタム (Momentum)。前回の更新量をどれだけ引き継ぐか。デフォルト: 0.9 */
+    momentum?: number;
+    /** trueの場合、事前に数エポックのテストランを行い、最適な学習率を自動探索します。デフォルト: false */
+    autoTune?: boolean;
+}
+/**
+ * 確率的勾配降下法 (SGD + Momentum) を用いた学習のための共通基底クラス。
+ *
+ * @template TExample 学習に用いるデータペアの型 (入力と理想の出力のペアなど)
+ * @template TResult 最終的に学習結果として出力される重み (行列やバイアス) の型
+ */
+declare abstract class BaseTrainer<TExample, TResult> {
+    /** 学習用サンプルの配列 */
+    protected examples: TExample[];
+    /** 入力ベクトル（ソース）の次元数 */
+    protected abstract get sourceDimension(): number;
+    /** 出力ベクトル（ターゲット）の次元数 */
+    protected abstract get targetDimension(): number;
+    /**
+     * サンプルデータから、学習アルゴリズムに渡すソースベクトルとターゲットベクトルを抽出します。
+     * @param {TExample} example 学習サンプルのデータ
+     * @returns {{ source: number[] | Float32Array; target: number[] | Float32Array }}
+     */
+    protected abstract getInputs(example: TExample): {
+        source: number[] | Float32Array;
+        target: number[] | Float32Array;
+    };
+    /**
+     * 学習済みの1次元行列とバイアスを、最終的な結果の型 (TResult) に変換します。
+     * @param {Float32Array} flatMatrix 学習済みのフラット化された行列
+     * @param {Float32Array} bias 学習済みのバイアスベクトル
+     * @returns {TResult} 変換された重みデータ
+     */
+    protected abstract toWeights(flatMatrix: Float32Array, bias: Float32Array): TResult;
+    /**
+     * 学習用のサンプルデータを追加します。
+     * 次元数がソース/ターゲットと一致しない場合はエラーとなります。
+     *
+     * @param {TExample} example 追加するサンプルデータ
+     * @throws {Error} 次元数が一致しない場合にスローされます。
+     */
+    addExample(example: TExample): void;
+    /**
+     * 追加されたサンプルデータを用いて学習を実行します。
+     * 指定されたエポック数だけ SGD + Momentum によるパラメータ更新を行います。
+     * パフォーマンスのため、可能であれば内部で WebAssembly (WASM) を使用します。
+     *
+     * @param {BaseTrainingOptions} [options={}] 学習のハイパーパラメータオプション
+     * @returns {Promise<TResult>} 学習済みの重みを返します。
+     * @throws {Error} サンプルデータが追加されていない場合にスローされます。
+     */
+    train(options?: BaseTrainingOptions): Promise<TResult>;
+    /**
+     * サンプルデータに対する短時間のテストランを行い、最も損失(Loss)が小さくなる最適な学習率を自動探索します。
+     * `options.autoTune` が true の場合に `train` メソッド内で自動的に呼び出されます。
+     *
+     * @param {BaseTrainingOptions} options 現在の学習オプション
+     * @returns {number} 探索された最適な学習率
+     */
+    protected findBestLearningRate(options: BaseTrainingOptions): number;
+    /**
+     * SGD + Momentum アルゴリズムによる1ステップのパラメータ更新を実行します。
+     * In-place (破壊的) に `matrix` と `bias` を更新します。
+     *
+     * @param {Float32Array} matrix 現在の変換行列 (1次元フラット配列)
+     * @param {Float32Array} bias 現在のバイアスベクトル
+     * @param {Float32Array} vMatrix 行列のモメンタム (速度)
+     * @param {Float32Array} vBias バイアスのモメンタム (速度)
+     * @param {number[] | Float32Array} x 入力ベクトル (ソース)
+     * @param {number[] | Float32Array} y 理想の出力ベクトル (ターゲット)
+     * @param {number} lr 学習率
+     * @param {number} reg L2正則化係数
+     * @param {number} momentum モメンタム係数
+     */
+    protected sgdMomentumStep(matrix: Float32Array, bias: Float32Array, vMatrix: Float32Array, vBias: Float32Array, x: number[] | Float32Array, y: number[] | Float32Array, lr: number, reg: number, momentum: number): void;
+}
+
+/**
+ * 学習データのペア（ベースのクエリベクトルと、目標となる結果ベクトル）
+ * @interface TrainingExample
+ */
+interface TrainingExample {
+    /** 入力ベクトル（元の検索クエリなどの埋め込み表現） */
+    input: number[] | Float32Array;
+    /** 目標ベクトル（ユーザーが理想とする結果の埋め込み表現） */
+    target: number[] | Float32Array;
+}
+/**
+ * 学習時の最適化オプション
+ */
+interface TrainingOptions extends BaseTrainingOptions {
+}
+/**
+ * サンプルデータから最適な `IntentWeights` (行列Wとバイアスb) を
+ * 確率的勾配降下法 (SGD + Momentum) により自動学習するトレーナークラス。
+ * 内部で Float32Array のフラット化を行い、極限のパフォーマンスを引き出します。
+ *
+ * @example
+ * const trainer = new IntentTrainer(1536);
+ * trainer.addExample({ input: [...], target: [...] });
+ * const weights = await trainer.train({ autoTune: true });
+ */
+declare class IntentTrainer extends BaseTrainer<TrainingExample, IntentWeights> {
+    private dimension;
+    /**
+     * IntentTrainer のインスタンスを作成します。
+     * @param {number} dimension ベクトルの次元数（入力・出力ともに同じ次元数となります）
+     */
+    constructor(dimension: number);
+    protected get sourceDimension(): number;
+    protected get targetDimension(): number;
+    protected getInputs(example: TrainingExample): {
+        source: number[] | Float32Array;
+        target: number[] | Float32Array;
+    };
+    protected toWeights(flatMatrix: Float32Array, bias: Float32Array): IntentWeights;
+    /**
+     * オンライン学習 (フィードバックループ) 用のメソッド。
+     * ユーザーのクリックなどの 1 回のフィードバックからリアルタイムに重みを微調整します。
+     *
+     * @param {IntentWeights} currentWeights - 現在の重み
+     * @param {number[] | Float32Array} input - 検索されたクエリベクトル
+     * @param {number[] | Float32Array} target - クリックされた(理想の)ドキュメントのベクトル
+     * @param {number} learningRate - 1ステップの学習率 (デフォルト: 0.01)
+     * @param {number} regularization - L2正則化の強さ (デフォルト: 0.001)
+     * @returns {IntentWeights} 微調整された新しい重み
+     */
+    updateOnline(currentWeights: IntentWeights, input: number[] | Float32Array, target: number[] | Float32Array, learningRate?: number, regularization?: number): Promise<IntentWeights>;
+}
+
+/**
+ * 移行用の学習データペア（旧モデルのベクトル -> 新モデルのベクトル）
+ * @interface MigrationExample
+ */
+interface MigrationExample {
+    /** 移行元のベクトル (例: ada-002の出力) */
+    source: number[] | Float32Array;
+    /** 移行先のベクトル (例: text-embedding-3-smallの出力) */
+    target: number[] | Float32Array;
+}
+/**
+ * 学習時の最適化オプション
+ */
+interface MigrationOptions extends BaseTrainingOptions {
+}
+/**
+ * 異なる埋め込みモデル間（例：1536次元から512次元へ）の
+ * ベクトル空間を翻訳する行列 (ProjectionWeights) を自動学習するトレーナークラス。
+ *
+ * 次元数の異なるベクトル表現をマッピングするための射影行列を学習します。
+ *
+ * @example
+ * const trainer = new MigrationTrainer(1536, 512);
+ * trainer.addExample({ source: [...], target: [...] });
+ * const projectionWeights = await trainer.train({ epochs: 200 });
+ */
+declare class MigrationTrainer extends BaseTrainer<MigrationExample, ProjectionWeights> {
+    private _sourceDimension;
+    private _targetDimension;
+    /**
+     * @param {number} sourceDimension 移行元の次元数 (例: ada-002なら1536)
+     * @param {number} targetDimension 移行先の次元数 (例: text-embedding-3-smallなら512)
+     */
+    constructor(sourceDimension: number, targetDimension: number);
+    protected get sourceDimension(): number;
+    protected get targetDimension(): number;
+    protected getInputs(example: MigrationExample): {
+        source: number[] | Float32Array;
+        target: number[] | Float32Array;
+    };
+    protected toWeights(flatMatrix: Float32Array, bias: Float32Array): ProjectionWeights;
+}
+
+/**
+ * 外部のベクトルデータベース（pgvector, Pinecone, Redisなど）へ
+ * ワープ変換後のベクトルを保存・検索するためのアダプター/ユーティリティクラス
+ */
+declare class VectorDBAdapter {
+    /**
+     * PostgreSQL (pgvector) 用のクエリ文字列表現を生成します。
+     * INSERT や SELECT の際に使用できる形式です。
+     *
+     * @example
+     * const sql = `SELECT * FROM items ORDER BY embedding <-> '${VectorDBAdapter.toPgvector(warpedVector)}' LIMIT 5`;
+     *
+     * @param {number[] | Float32Array} vector ワープ変換後のベクトル
+     * @returns {string} `'[0.1, 0.2, 0.3]'` のような文字列表現
+     */
+    static toPgvector(vector: number[] | Float32Array): string;
+    /**
+     * Pinecone 用のクエリオブジェクトを生成します。
+     * Pinecone クライアントに直接渡せる形式のオブジェクトを返します。
+     *
+     * @example
+     * const query = VectorDBAdapter.toPineconeQuery(warpedVector, 10, { genre: "comedy" });
+     * await index.query(query);
+     *
+     * @param {number[] | Float32Array} vector 検索クエリベクトル
+     * @param {number} topK 取得する件数 (デフォルト: 10)
+     * @param {Record<string, any>} [filter] メタデータフィルタ（オプション）
+     * @returns {Record<string, any>} Pineconeのqueryメソッド用オブジェクト
+     */
+    static toPineconeQuery(vector: number[] | Float32Array, topK?: number, filter?: Record<string, any>): Record<string, any>;
+    /**
+     * Redis (RediSearch) のベクトルフィールド用に、
+     * Float32Array をバイナリ（Uint8Array）に変換します。
+     * Node.js環境では Buffer.from() を使って Buffer に変換して渡してください。
+     *
+     * @example
+     * const blob = Buffer.from(VectorDBAdapter.toRedis(warpedVector));
+     * await redis.call('FT.SEARCH', 'idx', '*=>[KNN 5 @embedding $BLOB]', 'PARAMS', '2', 'BLOB', blob, 'DIALECT', '2');
+     *
+     * @param {number[] | Float32Array} vector ワープ変換後のベクトル
+     * @returns {Uint8Array} バイナリデータ (Float32のバイト表現)
+     */
+    static toRedis(vector: number[] | Float32Array): Uint8Array;
+}
+
+export { type Activation, IntentAdapter, IntentTrainer, type IntentWeights, LoraIntentAdapter, type LoraIntentWeights, type MigrationExample, type MigrationOptions, MigrationTrainer, ProjectionAdapter, type ProjectionWeights, type TrainingExample, type TrainingOptions, VectorDBAdapter, applyActivationToVector, assertDimension, cosineSimilarity, flattenMatrix, innerProduct, normalize, reject, slerp, softmax };