@mlx-node/trl 0.0.2 → 0.0.4

package/dist/trainers/grpo-trainer.d.ts

@@ -0,0 +1,621 @@
+/**
+ * GRPO Training Engine - Rust-Native Training
+ *
+ * This module provides a Rust-native GRPO training engine that minimizes
+ * FFI overhead by keeping the training loop entirely in Rust.
+ *
+ * ## Key Features
+ * - Training loop runs in Rust (eliminates FFI overhead)
+ * - Built-in reward functions (tool use, XML format, length, JSON schema)
+ * - Custom JS rewards via callback pattern
+ * - Gradient accumulation and memory management in Rust
+ * - High-level train() method for full training runs
+ * - Low-level trainStep() for custom training loops
+ *
+ * ## High-Level Usage (train with dataset)
+ * ```typescript
+ * const trainer = await GRPOTrainer.create({
+ *   modelPath: './model',
+ *   modelName: 'qwen3-0.6b',
+ *   rewardFunction: (prompts, completions) => [...scores],
+ * });
+ * await trainer.train(dataset);
+ * ```
+ *
+ * ## Low-Level Usage (step-by-step)
+ * ```typescript
+ * const model = await Qwen3Model.load(modelPath);
+ * const trainer = new GRPOTrainer(model, config);
+ *
+ * trainer.registerBuiltinReward({
+ *   rewardType: 'ToolUse',
+ *   allowedTools: ['search', 'calculate'],
+ * });
+ *
+ * for (const batch of dataset) {
+ *   const completions = await trainer.generateBatch(batch.prompts);
+ *   const rewards = await myRewardFunction(batch.prompts, completions);
+ *   const metrics = await trainer.trainStep(batch.prompts, rewards);
+ * }
+ * ```
+ */
+import { GrpoTrainingEngine, NativeRewardRegistry, OutputStore, type EngineEpochMetrics, type BuiltinRewardConfig, type GenerateBatchResult as NativeGenerateBatchResult, type ToolDefinition } from '@mlx-node/core';
+import { type TrainableModel } from '@mlx-node/lm';
+import type { ChatMessage, DatasetExample, RewardFunction } from '../types.js';
+import { type TrainingLogger } from './training-logger.js';
+export { GrpoTrainingEngine, NativeRewardRegistry, OutputStore } from '@mlx-node/core';
+export type { GrpoEngineConfig, EngineStepMetrics, EngineEpochMetrics, BuiltinRewardConfig, TrainStepResult, TrainStepResultWithOutputs, RewardOutput, OutputStoreConfig, } from '@mlx-node/core';
+/**
+ * Configuration for GRPOTrainer
+ */
+export interface GRPOTrainerConfig<T = unknown> {
+    modelPath?: string;
+    modelName?: string;
+    learningRate?: number;
+    gradientAccumulationSteps?: number;
+    gradientClipNorm?: number;
+    weightDecay?: number;
+    numEpochs?: number;
+    batchSize?: number;
+    groupSize?: number;
+    clipEpsilon?: number;
+    klCoef?: number;
+    lossType?: 'grpo' | 'dapo' | 'dr_grpo' | 'bnpo';
+    advantageNormalization?: boolean;
+    /** Maximum completion length for both generation and training (default: 256).
+     * Matches Python TRL's max_completion_length config. */
+    maxCompletionLength?: number;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    repetitionPenalty?: number;
+    /**
+     * Tool definitions for function calling.
+     * When provided, tools are included in the chat template so the model
+     * can generate tool calls. Essential for tool-use training.
+     *
+     * @example
+     * ```typescript
+     * import { createToolDefinition } from '@mlx-node/lm';
+     *
+     * const config: GRPOTrainerConfig = {
+     *   tools: [
+     *     createToolDefinition('lsp', 'Query API docs', { method: { type: 'string' } }, ['method']),
+     *     createToolDefinition('run_js', 'Execute code', { code: { type: 'string' } }, ['code']),
+     *   ],
+     * };
+     * ```
+     */
+    tools?: ToolDefinition[];
+    /** Enable thinking mode for Qwen3 models (default: true).
+     * When false, adds empty <think></think> tags to disable model thinking.
+     * This is useful for tool-use training where you want direct outputs. */
+    enableThinking?: boolean;
+    rewardType?: 'function' | 'builtin' | 'model';
+    rewardFunction?: RewardFunction<T>;
+    rewardModelPath?: string;
+    gradientClipValue?: number;
+    logInterval?: number;
+    saveInterval?: number;
+    evalInterval?: number;
+    outputDir?: string;
+    logConsole?: boolean;
+    logJsonl?: boolean;
+    runName?: string;
+    /** Maximum number of checkpoints to keep (default: 3). Set to 0 for unlimited. */
+    maxCheckpoints?: number;
+    device?: string;
+    /** Resume training from a checkpoint directory, or 'latest' to auto-find */
+    resumeFromCheckpoint?: 'latest' | string;
+    /** Enable TUI mode - outputs structured JSONL to stdout and listens for commands on stdin */
+    tuiMode?: boolean;
+    /**
+     * Timeout for the reward function callback in milliseconds.
+     *
+     * If your reward function calls external APIs or performs expensive
+     * computations, you may need to increase this value.
+     *
+     * Set to 0 to disable timeout (not recommended for production).
+     *
+     * @default 60000 (60 seconds)
+     */
+    rewardTimeout?: number;
+    /**
+     * Batch chunk size for LM head computation (memory optimization).
+     * When set, the LM head (hidden_states -> logits) is computed in chunks
+     * of this size to reduce peak memory usage.
+     * Default: undefined (no chunking, full batch at once)
+     * Recommended: 2 for batch_size >= 4 with large vocabularies (e.g., Qwen3 with 151936 vocab)
+     * This reduces peak memory from ~1.2GB to ~300MB for Qwen3.
+     */
+    lmHeadChunkSize?: number;
+    /**
+     * Batch chunk size for transformer forward pass (memory optimization).
+     * When set, the transformer layers process the batch in chunks of this size,
+     * reducing peak memory from O(batch × heads × seq²) for attention.
+     * Default: undefined (no chunking, full batch at once)
+     * Recommended: 4 for batch_size >= 4 with groupSize >= 4
+     * Memory savings: ~70-80% for batch=4, groupSize=4 (16 sequences → 4 at a time)
+     */
+    forwardChunkSize?: number;
+    /**
+     * Enable true parallel batch generation (default: false).
+     * When true, all N*G sequences are processed in parallel using batched FFI
+     * with per-sequence RoPE offsets. This provides 2-4x speedup for GRPO training.
+     * When false, uses sequential generation (process one prompt at a time,
+     * then expand KV cache for G completions).
+     */
+    useParallelBatchGeneration?: boolean;
+    /**
+     * Enable gradient checkpointing (default: true).
+     * Discards intermediate activations during forward pass and recomputes during backward,
+     * reducing peak memory from O(num_layers) to O(1) for intermediate states.
+     * For Qwen3.5 0.8B, this reduces autograd peak from ~105GB to ~11GB.
+     * Trade-off: ~30% more compute (one extra forward pass per layer during backward).
+     */
+    gradientCheckpointing?: boolean;
+    /** Optimizer type: 'sgd' or 'adamw' (default: 'adamw') */
+    optimizerType?: 'sgd' | 'adamw';
+    /** AdamW beta1 (default: 0.9) */
+    adamwBeta1?: number;
+    /** AdamW beta2 (default: 0.999) */
+    adamwBeta2?: number;
+    /** AdamW epsilon (default: 1e-8) */
+    adamwEps?: number;
+    /**
+     * Chunk size for vocabulary dimension in cross-entropy computation.
+     * When computing logsumexp over large vocabularies (e.g., Qwen3's 151,936 tokens),
+     * the computation is split into chunks of this size to reduce peak memory usage.
+     *
+     * Default: 65536 (2^16)
+     *
+     * Memory impact for Qwen3 (vocab=151936):
+     * - Standard: Full [B, T, 151936] intermediate tensor
+     * - Chunked (65536): 3 chunks, ~2.3x lower peak memory
+     *
+     * Set to a larger value (e.g., 262144) to reduce chunking overhead,
+     * or smaller value (e.g., 32768) for tighter memory constraints.
+     */
+    vocabChunkSize?: number;
+    /** Output recording configuration (records all generations for debugging/research) */
+    outputStore?: {
+        /** Enable output recording (default: false) */
+        enabled: boolean;
+        /** Local database path (default: "{outputDir}/outputs.db") */
+        localPath?: string;
+        /** Remote Turso URL for cloud sync (optional) */
+        remoteUrl?: string;
+        /** Turso auth token (required if remoteUrl is set) */
+        authToken?: string;
+        /** Sync interval in seconds (default: 60, only for embedded replica mode) */
+        syncInterval?: number;
+    };
+}
+/**
+ * Dataset metadata for resume validation
+ *
+ * Stored in checkpoints to validate that the same dataset is used on resume.
+ * Prevents issues where batch indices don't align due to dataset changes.
+ */
+export interface DatasetMetadata {
+    /** Total number of examples in the dataset */
+    size: number;
+    /** Hash of first N example prompts for identity check */
+    contentHash: string;
+    /** Shuffle seed if deterministic shuffling was used */
+    shuffleSeed?: number;
+    /** Indices of batches already processed in current epoch */
+    processedBatchIndices?: number[];
+}
+/**
+ * Training state saved with checkpoints for resumption
+ */
+export interface TrainingState {
+    step: number;
+    epoch: number;
+    timestamp: string;
+    /** Dataset information for resume validation */
+    dataset?: DatasetMetadata;
+    /** Whether optimizer state was saved alongside this checkpoint */
+    hasOptimizerState?: boolean;
+}
+/**
+ * Result from generateBatch with detailed information
+ */
+export interface GenerateBatchResult {
+    /** Generated completion texts */
+    completionTexts: string[];
+    /** Native generation result for passing to trainStepWithGenerations */
+    nativeResult: NativeGenerateBatchResult;
+    /** Completion token counts (derived from nativeResult) */
+    tokenCounts: number[];
+    /** Finish reasons for each completion ("stop", "length", or "repetition") */
+    finishReasons: string[];
+}
+/**
+ * Default configuration
+ */
+export declare const DEFAULT_GRPO_CONFIG: GRPOTrainerConfig;
+/**
+ * Training step metrics (compatible with both old and new APIs)
+ */
+export interface TrainStepMetrics {
+    /** Current step number */
+    step: number;
+    /** GRPO loss value */
+    loss: number;
+    /** Mean reward across completions */
+    meanReward: number;
+    /** Standard deviation of rewards */
+    stdReward: number;
+    /** Mean advantage value */
+    meanAdvantage: number;
+    /** Std of advantages - indicates reward variance within groups */
+    stdAdvantage: number;
+    /** Total tokens generated this step */
+    totalTokens: number;
+    /** Whether gradients were applied */
+    gradientsApplied?: boolean;
+    /** Time for generation (ms) */
+    generationTimeMs?: number;
+    /** Time for training (ms) */
+    trainingTimeMs?: number;
+    /** Current epoch (for high-level API) */
+    epoch?: number;
+}
+/**
+ * Legacy type alias for backward compatibility
+ */
+export type TrainingMetrics = TrainStepMetrics;
+/**
+ * Compute a hash of dataset content for identity checking on resume.
+ *
+ * Hashes the first N examples to create a fingerprint that can detect
+ * if the dataset has been modified between training runs.
+ *
+ * @param dataset - Array of dataset examples
+ * @param sampleSize - Number of examples to hash (default: 10)
+ * @returns 16-character hex hash string
+ */
+export declare function computeDatasetHash(dataset: DatasetExample[], sampleSize?: number): string;
+/**
+ * Error thrown when a reward function times out.
+ */
+export declare class RewardTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(message: string, timeoutMs: number);
+}
+/**
+ * GRPO Trainer - Rust-Native Training Engine
+ *
+ * Provides a TypeScript-friendly interface to the Rust training engine.
+ * Supports both high-level training (train()) and low-level step-by-step (trainStep()).
+ */
+export declare class GRPOTrainer<T = unknown> {
+    private engine;
+    private model;
+    private config;
+    private rewardFn?;
+    private currentEpoch;
+    private currentStep;
+    /** Original model path (for tokenizer files when saving checkpoints) */
+    private originalModelPath?;
+    private paused;
+    private stopRequested;
+    private stdinInterface?;
+    private logger;
+    private sampleDisplayMode;
+    private outputStore?;
+    private outputStoreInitPromise?;
+    private outputStoreRunId?;
+    private outputStorePath?;
+    private lastCheckpointStep;
+    private signalHandlersInstalled;
+    private lastGoodCheckpointPath;
+    private lastGoodCheckpointStep;
+    private datasetMetadata?;
+    private processedBatchIndices;
+    /**
+     * Create a new GRPO trainer from a model
+     *
+     * @param model - Pre-loaded Qwen3 model
+     * @param config - Training configuration
+     */
+    constructor(model: TrainableModel, config?: Partial<GRPOTrainerConfig<T>>, logger?: TrainingLogger);
+    /**
+     * Setup stdin handler for TUI control commands
+     */
+    private setupStdinHandler;
+    /**
+     * Setup OS signal handlers for graceful shutdown on crash/interrupt
+     *
+     * Catches SIGTERM, SIGINT, and uncaught exceptions to:
+     * - Save emergency checkpoint (if > 10 steps since last)
+     * - Finalize OutputStore with 'crashed' status
+     * - Exit cleanly
+     */
+    private setupSignalHandlers;
+    /**
+     * Initialize the output store for recording training outputs
+     */
+    private initOutputStore;
+    /**
+     * Send minimal resume state to TUI for UI display only (no historical data)
+     *
+     * Used when resuming from checkpoint without a matching database run.
+     * Ensures TUI shows correct epoch/batch progress.
+     */
+    private sendResumeStateUiOnly;
+    /**
+     * Send resume state to TUI for restoring sparklines and aggregates
+     *
+     * Queries the database for historical metrics and aggregates, then sends
+     * to TUI via the resumeState message.
+     *
+     * @param runId - Database run ID
+     * @param actualStepsPerEpoch - Actual steps per epoch from dataset (if known)
+     */
+    private sendResumeState;
+    /**
+     * Ensure output store is initialized (lazy initialization for low-level API users)
+     * Uses promise mutex to prevent race conditions from concurrent calls.
+     *
+     * Call this method from custom training loops before starting training
+     * to enable database recording and TUI database tab.
+     */
+    ensureOutputStoreInitialized(): Promise<void>;
+    /**
+     * Get the output store (for querying recorded data)
+     */
+    getOutputStore(): OutputStore | undefined;
+    /**
+     * Handle a command received from stdin
+     */
+    private handleStdinCommand;
+    /**
+     * Wait for resume if paused, with polling
+     */
+    private waitForResume;
+    /**
+     * Create a trainer by loading a model from disk
+     *
+     * This is the recommended way to create a trainer for training runs.
+     * If resumeFromCheckpoint is set, loads from checkpoint instead of modelPath.
+     *
+     * @param config - Configuration including modelPath
+     * @returns Promise<GRPOTrainer>
+     */
+    static create<U>(config: GRPOTrainerConfig<U>): Promise<GRPOTrainer<U>>;
+    /**
+     * Find the latest checkpoint in the output directory
+     */
+    static findLatestCheckpoint(outputDir?: string): string | null;
+    /**
+     * Register a built-in reward function
+     *
+     * Built-in rewards run entirely in Rust with no FFI overhead.
+     *
+     * @example
+     * ```typescript
+     * // Tool use validation
+     * trainer.registerBuiltinReward({
+     *   rewardType: 'ToolUse',
+     *   allowedTools: ['search', 'calculate'],
+     *   required: true,
+     *   weight: 1.0,
+     * });
+     *
+     * // XML format validation
+     * trainer.registerBuiltinReward({
+     *   rewardType: 'XmlFormat',
+     *   requiredTags: ['thinking', 'answer'],
+     *   weight: 0.5,
+     * });
+     *
+     * // Length-based reward
+     * trainer.registerBuiltinReward({
+     *   rewardType: 'Length',
+     *   minLength: 100,
+     *   maxLength: 500,
+     *   useChars: true,
+     * });
+     * ```
+     */
+    registerBuiltinReward(config: BuiltinRewardConfig): void;
+    /**
+     * Set a custom JavaScript reward function
+     *
+     * The function will be called after generation to compute rewards.
+     *
+     * @param fn - Reward function that takes prompts and completions
+     */
+    setRewardFunction(fn: RewardFunction<T>): void;
+    /**
+     * Generate completions for prompts
+     *
+     * Generates `groupSize` completions per prompt.
+     * Returns all data needed for training, including tokens and log probabilities.
+     *
+     * @param prompts - Array of chat conversations
+     * @returns GenerateBatchResult with completion texts and native generation data
+     */
+    generateBatch(prompts: ChatMessage[][]): Promise<GenerateBatchResult>;
+    /**
+     * Score completions using built-in rewards
+     *
+     * @param prompts - Prompt texts (one per completion)
+     * @param completions - Completion texts
+     * @returns Array of reward scores
+     */
+    scoreCompletions(prompts: string[], completions: string[]): number[];
+    /**
+     * Score generations using the configured reward function.
+     *
+     * Builds RewardOutput array with structured completion data and passes to reward function.
+     *
+     * @param prompts - Array of chat conversations
+     * @param completions - Generated completion texts
+     * @param context - Context for the reward function
+     * @param groupSize - Number of completions per prompt (optional, defaults to config.groupSize)
+     * @param tokenCounts - Token counts for each completion (optional, defaults to 0s)
+     * @param finishReasons - Finish reasons from generation (optional, e.g. "stop", "length", "repetition")
+     * @returns Promise<Float32Array> of reward scores
+     */
+    scoreGenerations(prompts: ChatMessage[][], completions: string[], context: T, groupSize?: number, tokenCounts?: number[], finishReasons?: string[]): Promise<Float32Array>;
+    /**
+     * Run a training step
+     *
+     * This method:
+     * 1. Generates completions with tokens and log probabilities
+     * 2. Computes rewards using the configured reward function
+     * 3. Trains using the SAME completions that were scored (no double-generation)
+     *
+     * @param prompts - Array of chat conversations
+     * @returns Training step metrics
+     */
+    trainStep(prompts: ChatMessage[][], context?: T): Promise<TrainStepMetrics>;
+    /**
+     * Run a complete training step with automatic reward computation
+     *
+     * This method combines generation, reward scoring, and training into a single
+     * Rust call, eliminating FFI overhead by keeping token data in Rust memory.
+     *
+     * 1. Generates completions with full token/logprob data (stays in Rust)
+     * 2. Calls JS reward function with RewardOutput[]
+     * 3. Performs training update using the in-memory data
+     *
+     * @param prompts - Array of chat conversations
+     * @param context - Context for the reward function
+     * @returns Training metrics and generated completions
+     */
+    trainStepAuto(prompts: ChatMessage[][], context?: T): Promise<{
+        metrics: TrainStepMetrics;
+        completions: string[];
+        rewards: number[];
+        completionLengths: number[];
+    }>;
+    /**
+     * Increment the step counter (for custom training loops)
+     *
+     * Call this after each training step when using low-level APIs like
+     * engine.trainStepWithGenerations() instead of trainer.trainStepAuto().
+     */
+    incrementStep(): void;
+    /**
+     * Get the current step number
+     */
+    getStep(): number;
+    /**
+     * Get the current epoch number
+     */
+    getEpoch(): number;
+    /**
+     * Record a training step to the output store database (for custom training loops)
+     *
+     * Use this when building custom training loops with engine.trainStepWithGenerations().
+     * The step number should be the value after incrementStep() was called.
+     *
+     * @param step - Step number
+     * @param metrics - Step metrics from the engine
+     * @param completions - Generated completion texts
+     * @param rewards - Reward values for each completion
+     * @param prompts - Prompt messages for each completion
+     */
+    recordStepToDatabase(step: number, metrics: {
+        loss: number;
+        meanReward: number;
+        stdReward: number;
+        meanAdvantage: number;
+        stdAdvantage: number;
+        totalTokens: number;
+    }, completions: string[], rewards: number[], prompts: string[]): Promise<void>;
+    /**
+     * Run a full training loop over a dataset
+     *
+     * This is the high-level training API that handles:
+     * - Epoch iteration
+     * - Batching
+     * - Generation and reward computation
+     * - Logging (if configured)
+     * - Checkpoint saving and resumption
+     * - TUI mode support (pause/resume, sample reporting)
+     *
+     * @param dataset - Array of DatasetExample items
+     */
+    train(dataset: DatasetExample[]): Promise<void>;
+    /**
+     * Save a checkpoint with model weights and training state
+     *
+     * Regular checkpoints (non-emergency) are tracked as "last known good" checkpoints.
+     * When NaN gradients occur, the emergency save logic can restore from the last good checkpoint.
+     *
+     * @param name - Checkpoint name (default: "checkpoint-{step}")
+     * @param options - Optional settings for checkpoint save behavior
+     * @param options.isEmergency - If true, this is an emergency checkpoint (debug state, not "good")
+     * @returns Path to saved checkpoint, or empty string if save was skipped due to corruption
+     */
+    saveCheckpoint(name?: string, options?: {
+        isEmergency?: boolean;
+    }): Promise<string>;
+    /**
+     * Remove old checkpoints, keeping only the most recent ones
+     * Preserves 'final' and 'emergency-*' checkpoints
+     */
+    private cleanupOldCheckpoints;
+    /**
+     * Start a new training epoch
+     */
+    startEpoch(): void;
+    /**
+     * End the current epoch and get metrics
+     *
+     * @param epochTimeSecs - Duration of the epoch in seconds
+     */
+    endEpoch(epochTimeSecs: number): EngineEpochMetrics;
+    /**
+     * Reset the trainer for a new training run
+     */
+    reset(): void;
+    /**
+     * Get current training step
+     */
+    get step(): number;
+    /**
+     * Get current epoch
+     */
+    get epoch(): number;
+    /**
+     * Get current micro-step within gradient accumulation
+     */
+    get microStep(): number;
+    /**
+     * Check if built-in rewards are configured
+     */
+    get hasBuiltinRewards(): boolean;
+    /**
+     * Get names of registered reward functions
+     */
+    get rewardNames(): string[];
+    /**
+     * Get the underlying native engine
+     *
+     * For advanced use cases that need direct access.
+     */
+    getNativeEngine(): GrpoTrainingEngine;
+}
+/**
+ * Create a standalone reward registry for testing rewards
+ *
+ * @example
+ * ```typescript
+ * const registry = createRewardRegistry();
+ * registry.register({
+ *   rewardType: 'ToolUse',
+ *   allowedTools: ['search'],
+ * });
+ *
+ * const score = registry.score('prompt', 'completion with <tool_call>...</tool_call>');
+ * ```
+ */
+export declare function createRewardRegistry(): NativeRewardRegistry;
+//# sourceMappingURL=grpo-trainer.d.ts.map

package/dist/trainers/grpo-trainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grpo-trainer.d.ts","sourceRoot":"","sources":["../../src/trainers/grpo-trainer.ts"],"names":[],"mappings":"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"}