doppler-gpu 0.4.11 → 0.4.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (73) hide show
  1. package/CHANGELOG.md +61 -0
  2. package/README.md +13 -1
  3. package/models/catalog.json +29 -29
  4. package/package.json +12 -3
  5. package/src/client/doppler-registry.json +9 -9
  6. package/src/client/runtime/lora.js +5 -0
  7. package/src/config/conversion/qwen3/qwen-3-5-0-8b-q4k-ehaf16.json +3 -2
  8. package/src/config/kernels/kernel-ref-digests.js +2 -1
  9. package/src/config/kernels/registry.json +21 -2
  10. package/src/config/schema/adapter.schema.d.ts +6 -1
  11. package/src/config/schema/adapter.schema.js +5 -0
  12. package/src/experimental/adapters/artifact-contract.d.ts +83 -0
  13. package/src/experimental/adapters/artifact-contract.js +254 -0
  14. package/src/experimental/adapters/index.d.ts +25 -0
  15. package/src/experimental/adapters/index.js +12 -0
  16. package/src/experimental/adapters/lora-loader.js +9 -4
  17. package/src/experimental/training/artifacts.d.ts +160 -0
  18. package/src/experimental/training/attention-backward.d.ts +64 -0
  19. package/src/experimental/training/attention-forward.d.ts +22 -0
  20. package/src/experimental/training/attention-forward.js +82 -0
  21. package/src/experimental/training/autograd.d.ts +76 -0
  22. package/src/experimental/training/checkpoint.d.ts +36 -0
  23. package/src/experimental/training/clip.d.ts +9 -0
  24. package/src/experimental/training/dataloader.d.ts +8 -0
  25. package/src/experimental/training/distillation/student-fixture.js +1 -0
  26. package/src/experimental/training/export.d.ts +41 -0
  27. package/src/experimental/training/lora-pipeline.d.ts +186 -0
  28. package/src/experimental/training/lora-pipeline.js +5 -0
  29. package/src/experimental/training/lora.d.ts +20 -0
  30. package/src/experimental/training/lora.js +4 -3
  31. package/src/experimental/training/loss-scaling.d.ts +21 -0
  32. package/src/experimental/training/loss.d.ts +10 -0
  33. package/src/experimental/training/native-qwen-lora.d.ts +106 -0
  34. package/src/experimental/training/native-qwen-lora.js +449 -0
  35. package/src/experimental/training/objectives/base.d.ts +58 -0
  36. package/src/experimental/training/optimizer.d.ts +22 -0
  37. package/src/experimental/training/optimizer.js +1 -0
  38. package/src/experimental/training/runner.d.ts +249 -0
  39. package/src/experimental/training/trainer.d.ts +89 -0
  40. package/src/experimental/training/workloads.d.ts +205 -0
  41. package/src/gpu/kernels/backward/adam.d.ts +1 -0
  42. package/src/gpu/kernels/backward/adam.js +6 -2
  43. package/src/gpu/kernels/backward/adam.wgsl +3 -2
  44. package/src/gpu/kernels/backward/matmul_backward_q4k.wgsl +90 -0
  45. package/src/gpu/kernels/backward/utils.js +18 -4
  46. package/src/inference/pipelines/text/ffn/dense.js +16 -0
  47. package/src/inference/pipelines/text/generator.d.ts +5 -1
  48. package/src/inference/pipelines/text/generator.js +106 -0
  49. package/src/inference/pipelines/text/linear-attention.d.ts +2 -0
  50. package/src/inference/pipelines/text/linear-attention.js +77 -6
  51. package/src/inference/pipelines/text/lora-types.d.ts +6 -1
  52. package/src/inference/pipelines/text/lora-types.js +5 -0
  53. package/src/inference/pipelines/text/ops.js +1 -0
  54. package/src/inference/pipelines/text/types.d.ts +28 -0
  55. package/src/inference/pipelines/text.d.ts +7 -2
  56. package/src/inference/pipelines/text.js +4 -0
  57. package/src/models/diffusiongemma.js +1 -1
  58. package/src/models/embeddinggemma.js +1 -1
  59. package/src/models/gemma3.js +1 -1
  60. package/src/models/gemma4.js +1 -1
  61. package/src/models/qwen3.js +1 -1
  62. package/src/tooling/hf-registry-utils.js +1 -1
  63. package/src/tooling/node-browser-command-runner.d.ts +16 -0
  64. package/src/tooling/node-browser-command-runner.js +1 -1
  65. package/src/training-browser.d.ts +19 -0
  66. package/src/training-browser.js +13 -0
  67. package/src/training.d.ts +137 -0
  68. package/src/training.js +219 -0
  69. package/src/version.js +1 -1
  70. package/tests/kernels/browser/kernel-suite.js +9 -1
  71. package/tests/kernels/browser/test-page.js +4 -2
  72. package/tests/kernels/reference/adam.js +4 -2
  73. package/NOTICE +0 -5
@@ -0,0 +1,76 @@
1
+ import type { Tensor } from '../../gpu/tensor.js';
2
+ import type { BackwardRegistrySchema } from '../../config/schema/backward-registry.schema.js';
3
+
4
+ export const OpType: {
5
+ EMBED: 'embed';
6
+ MATMUL: 'matmul';
7
+ RMSNORM: 'rmsnorm';
8
+ RESIDUAL_ADD: 'residual_add';
9
+ RESHAPE: 'reshape';
10
+ ROW_SLICE: 'row_slice';
11
+ LAYERNORM: 'layernorm';
12
+ ATTENTION: 'attention';
13
+ SOFTMAX: 'softmax';
14
+ ROPE: 'rope';
15
+ SILU: 'silu';
16
+ SILU_ROWSPLIT: 'silu_rowsplit';
17
+ SILU_GATED: 'silu_gated';
18
+ GELU: 'gelu';
19
+ SCALE: 'scale';
20
+ CROSS_ENTROPY: 'cross_entropy';
21
+ BIAS_ADD: 'bias_add';
22
+ UPSAMPLE2D: 'upsample2d';
23
+ PIXEL_SHUFFLE: 'pixel_shuffle';
24
+ GROUPNORM: 'groupnorm';
25
+ CONV2D: 'conv2d';
26
+ };
27
+
28
+ export declare function resolveMatmulBackwardOptions<T extends Record<string, unknown> = Record<string, unknown>>(
29
+ options?: T
30
+ ): T & {
31
+ computeGradInput: boolean;
32
+ computeGradWeight: boolean;
33
+ };
34
+
35
+ export declare function computeSiluGatedBackwardValues(
36
+ gate: ArrayLike<number>,
37
+ up: ArrayLike<number>,
38
+ gradOutput: ArrayLike<number>,
39
+ swigluLimit?: number
40
+ ): {
41
+ gradGate: Float32Array;
42
+ gradUp: Float32Array;
43
+ };
44
+
45
+ export interface AutogradRecord {
46
+ op: string;
47
+ inputs: Tensor[];
48
+ output: Tensor;
49
+ options?: Record<string, unknown>;
50
+ }
51
+
52
+ export interface BackwardSeed {
53
+ tensor: Tensor;
54
+ grad: Tensor;
55
+ }
56
+
57
+ export type BackwardSeedInput =
58
+ | Tensor
59
+ | Map<Tensor, Tensor>
60
+ | BackwardSeed[]
61
+ | { seeds: BackwardSeed[] };
62
+
63
+ export declare class AutogradTape {
64
+ constructor(registry: BackwardRegistrySchema);
65
+ registry: BackwardRegistrySchema;
66
+ records: AutogradRecord[];
67
+ watch<T extends Tensor>(tensor: T): T;
68
+ record(
69
+ op: string,
70
+ fn: (...args: Tensor[]) => Promise<Tensor>,
71
+ inputs: Tensor[],
72
+ options?: Record<string, unknown>
73
+ ): Promise<Tensor>;
74
+ backward(gradOutput: BackwardSeedInput): Promise<Map<Tensor, Tensor>>;
75
+ reset(): void;
76
+ }
@@ -0,0 +1,36 @@
1
+ export interface CheckpointStoreOptions {
2
+ dbName?: string;
3
+ storeName?: string;
4
+ version?: number;
5
+ nodeDir?: string;
6
+ configHash?: string;
7
+ datasetHash?: string;
8
+ tokenizerHash?: string;
9
+ optimizerHash?: string;
10
+ runtimeProfileId?: string;
11
+ kernelPathId?: string;
12
+ environmentMetadata?: unknown;
13
+ buildProvenance?: Record<string, unknown> | null;
14
+ priorCheckpointHash?: string;
15
+ expectedMetadata?: Record<string, unknown>;
16
+ forceResume?: boolean;
17
+ forceResumeReason?: string;
18
+ forceResumeSource?: string;
19
+ forceResumeOperator?: string | null;
20
+ }
21
+
22
+ export declare function saveCheckpoint(
23
+ key: string,
24
+ data: unknown,
25
+ options?: CheckpointStoreOptions
26
+ ): Promise<{
27
+ key: string;
28
+ path: string | null;
29
+ metadata: Record<string, unknown>;
30
+ data: unknown;
31
+ }>;
32
+
33
+ export declare function loadCheckpoint(
34
+ key: string,
35
+ options?: CheckpointStoreOptions
36
+ ): Promise<unknown | null>;
@@ -0,0 +1,9 @@
1
+ import type { TrainingConfigSchema } from '../../config/training-defaults.d.ts';
2
+ import type { Tensor } from '../../gpu/tensor.js';
3
+
4
+ import type { ClipMetrics } from './trainer.d.ts';
5
+
6
+ export declare function clipGradients(
7
+ grads: Map<Tensor, Tensor>,
8
+ config: TrainingConfigSchema
9
+ ): Promise<ClipMetrics>;
@@ -0,0 +1,8 @@
1
+ export declare class DataLoader<T> {
2
+ constructor(dataset: T[], batchSize: number, shuffle?: boolean);
3
+ dataset: T[];
4
+ batchSize: number;
5
+ shuffle: boolean;
6
+ collate(batch: T[]): T[] | unknown;
7
+ batches(): AsyncGenerator<T[] | unknown, void, void>;
8
+ }
@@ -186,6 +186,7 @@ function createTransformerLoraAdapters(config, dims) {
186
186
  outDim: shape.outDim,
187
187
  rank: config.rank,
188
188
  alpha: config.alpha,
189
+ dtype: 'f32',
189
190
  });
190
191
  }
191
192
  return adapters;
@@ -0,0 +1,41 @@
1
+ import type { AdapterManifest } from '../adapters/adapter-manifest.js';
2
+ import type { LoRAModuleName } from '../../inference/pipelines/text/lora-types.js';
3
+ import type { Tensor } from '../../gpu/tensor.js';
4
+
5
+ export interface LoRAExportTensor {
6
+ name: string;
7
+ tensor: Tensor | Float32Array | GPUBuffer;
8
+ shape?: [number, number];
9
+ dtype?: 'f16' | 'f32';
10
+ }
11
+
12
+ export interface LoRAExportOptions {
13
+ id: string;
14
+ name: string;
15
+ baseModel: string;
16
+ rank: number;
17
+ alpha: number;
18
+ targetModules: LoRAModuleName[];
19
+ version?: string;
20
+ description?: string;
21
+ metadata?: Record<string, unknown>;
22
+ tensors: LoRAExportTensor[];
23
+ format?: 'base64' | 'array';
24
+ weightsFormat?: 'json' | 'safetensors';
25
+ weightsPath?: string;
26
+ pretty?: boolean;
27
+ }
28
+
29
+ export interface LoRAExportResult {
30
+ manifest: AdapterManifest;
31
+ json: string;
32
+ weights?: ArrayBuffer;
33
+ weightsSha256?: string;
34
+ weightsPath?: string;
35
+ }
36
+
37
+ export declare function serializeLoRASafetensors(
38
+ tensors: Array<{ name: string; shape: [number, number]; data: Float32Array | number[] }>
39
+ ): ArrayBuffer;
40
+
41
+ export declare function exportLoRAAdapter(options: LoRAExportOptions): Promise<LoRAExportResult>;
@@ -0,0 +1,186 @@
1
+ import type { LoadedTrainingWorkload } from './workloads.js';
2
+
3
+ export declare const LORA_RUNNER_SUPPORT_CONTRACT: Readonly<{
4
+ supportedBaseModelId: string;
5
+ supportedDatasetFormat: string;
6
+ registeredBaseModelIds: readonly string[];
7
+ registeredDatasetFormats: readonly string[];
8
+ implementedRunnerKeys: readonly string[];
9
+ }>;
10
+
11
+ export declare const LORA_RUNNER_BASE_MODEL_REGISTRY: Readonly<Record<string, Readonly<{
12
+ baseModelId: string;
13
+ modelRef?: string;
14
+ family: string;
15
+ runnerKind: string;
16
+ requiresExternalTrainer?: boolean;
17
+ nativeLoraTargets?: readonly Readonly<{ module: 'down_proj'; layer: 'last' }>[];
18
+ }>>>;
19
+
20
+ export declare const LORA_RUNNER_DATASET_FORMAT_REGISTRY: Readonly<Record<string, Readonly<{
21
+ datasetFormat: string;
22
+ datasetKind: string;
23
+ }>>>;
24
+
25
+ export declare function getLoraRunnerCompatibility(workload: unknown): {
26
+ schemaVersion: 1;
27
+ supported: boolean;
28
+ runnerContract: typeof LORA_RUNNER_SUPPORT_CONTRACT;
29
+ observed: {
30
+ baseModelId: string;
31
+ datasetFormat: string;
32
+ taskType: string;
33
+ runnerKey: string;
34
+ baseModelFamily: string | null;
35
+ baseModelRunnerKind: string | null;
36
+ requiresExternalTrainer: boolean;
37
+ nativeLoraTargets: readonly Readonly<{ module: 'down_proj'; layer: 'last' }>[];
38
+ datasetKind: string | null;
39
+ registeredBaseModel: boolean;
40
+ registeredDatasetFormat: boolean;
41
+ };
42
+ blockedReasons: string[];
43
+ };
44
+
45
+ export declare function assertLoraRunnerCompatibility(workload: unknown): {
46
+ schemaVersion: 1;
47
+ supported: true;
48
+ runnerContract: typeof LORA_RUNNER_SUPPORT_CONTRACT;
49
+ observed: {
50
+ baseModelId: string;
51
+ datasetFormat: string;
52
+ taskType: string;
53
+ runnerKey: string;
54
+ baseModelFamily: string | null;
55
+ baseModelRunnerKind: string | null;
56
+ requiresExternalTrainer: boolean;
57
+ nativeLoraTargets: readonly Readonly<{ module: 'down_proj'; layer: 'last' }>[];
58
+ datasetKind: string | null;
59
+ registeredBaseModel: boolean;
60
+ registeredDatasetFormat: boolean;
61
+ };
62
+ blockedReasons: [];
63
+ };
64
+
65
+ export declare function preflightCausalLmLoraWorkload(
66
+ workload: unknown,
67
+ options?: {
68
+ datasetPath?: string;
69
+ fetch?: (url: string) => Promise<string>;
70
+ readFile?: (path: string) => Promise<string>;
71
+ }
72
+ ): Promise<{
73
+ schemaVersion: 1;
74
+ supported: boolean;
75
+ runnerKey: string;
76
+ baseModelId: string;
77
+ baseModelFamily: string | null;
78
+ datasetPath: string;
79
+ datasetFormat: string;
80
+ taskType: string;
81
+ rowCount: number;
82
+ firstRowId: string | null;
83
+ lastRowId: string | null;
84
+ textPairFields: {
85
+ prompt: string | null;
86
+ completion: string | null;
87
+ };
88
+ textPairLengths: {
89
+ minPromptChars: number;
90
+ maxPromptChars: number;
91
+ minCompletionChars: number;
92
+ maxCompletionChars: number;
93
+ };
94
+ adapter: {
95
+ rank: number;
96
+ alpha: number;
97
+ targetModules: string[];
98
+ };
99
+ blockedReasons: string[];
100
+ }>;
101
+
102
+ export interface CausalLmLoraTrainerTensor {
103
+ name: string;
104
+ shape: [number, number];
105
+ tensor?: Float32Array | GPUBuffer | { buffer?: GPUBuffer; shape?: [number, number]; dtype?: string };
106
+ data?: Float32Array | number[];
107
+ values?: Float32Array | number[];
108
+ dtype?: 'f16' | 'f32';
109
+ }
110
+
111
+ export interface CausalLmLoraTrainerResult {
112
+ checkpointId?: string | null;
113
+ checkpointStep?: number | null;
114
+ adapterId?: string | null;
115
+ adapterName?: string | null;
116
+ trainerId?: string | null;
117
+ runnerId?: string | null;
118
+ metrics?: Record<string, unknown>;
119
+ receipts?: unknown[];
120
+ evalReports?: Array<Record<string, unknown>>;
121
+ tensors?: CausalLmLoraTrainerTensor[];
122
+ weights?: CausalLmLoraTrainerTensor[];
123
+ }
124
+
125
+ export interface CausalLmLoraTrainerInput {
126
+ schemaVersion: 1;
127
+ runnerKind: 'causal_lm_lora';
128
+ workload: LoadedTrainingWorkload['workload'];
129
+ loadedWorkload: LoadedTrainingWorkload;
130
+ compatibility: ReturnType<typeof getLoraRunnerCompatibility>;
131
+ preflight: Awaited<ReturnType<typeof preflightCausalLmLoraWorkload>>;
132
+ dataset: {
133
+ absolutePath: string;
134
+ rowCount: number;
135
+ rows: Array<Record<string, unknown>>;
136
+ datasetHash: string;
137
+ };
138
+ adapter: Record<string, unknown>;
139
+ training: Record<string, unknown>;
140
+ export: Record<string, unknown> | null;
141
+ layout: Record<string, string>;
142
+ }
143
+
144
+ export type CausalLmLoraTrainer = (input: CausalLmLoraTrainerInput) => Promise<CausalLmLoraTrainerResult> | CausalLmLoraTrainerResult;
145
+
146
+ export declare function runLoraPipeline(options: {
147
+ loadedWorkload: LoadedTrainingWorkload;
148
+ runRoot?: string | null;
149
+ timestamp?: string | Date | null;
150
+ causalLmTrainer?: CausalLmLoraTrainer;
151
+ fetch?: (url: string) => Promise<string>;
152
+ readFile?: (path: string) => Promise<string>;
153
+ }): Promise<Record<string, unknown>>;
154
+
155
+ export declare function evaluateLoraCheckpoint(options: {
156
+ loadedWorkload: LoadedTrainingWorkload;
157
+ checkpointPath: string;
158
+ checkpointId?: string | null;
159
+ checkpointStep?: number | null;
160
+ layout?: Record<string, string> | null;
161
+ }): Promise<Record<string, unknown>[]>;
162
+
163
+ export declare function exportLoraCheckpoint(options: {
164
+ loadedWorkload: LoadedTrainingWorkload;
165
+ checkpointPath: string;
166
+ checkpointId?: string | null;
167
+ checkpointStep?: number | null;
168
+ layout?: Record<string, string> | null;
169
+ exportsDir?: string | null;
170
+ datasetHash?: string | null;
171
+ }): Promise<Record<string, unknown>>;
172
+
173
+ export declare function watchLoraCheckpoints(options: {
174
+ loadedWorkload: LoadedTrainingWorkload;
175
+ runRoot: string;
176
+ pollIntervalMs?: number | null;
177
+ stopWhenIdle?: boolean;
178
+ }): Promise<{ ok: true; processedCount: number; manifestPath: string }>;
179
+
180
+ export declare function compareLoraRun(options: {
181
+ runRoot: string;
182
+ }): Promise<Record<string, unknown>>;
183
+
184
+ export declare function qualityGateLoraRun(options: {
185
+ runRoot: string;
186
+ }): Promise<Record<string, unknown>>;
@@ -122,6 +122,9 @@ export const LORA_RUNNER_BASE_MODEL_REGISTRY = Object.freeze({
122
122
  family: 'qwen3',
123
123
  runnerKind: 'causal_lm_text_generation',
124
124
  requiresExternalTrainer: true,
125
+ nativeLoraTargets: Object.freeze([
126
+ Object.freeze({ module: 'down_proj', layer: 'last' }),
127
+ ]),
125
128
  }),
126
129
  'qwen-3-5-2b-q4k-ehaf16': Object.freeze({
127
130
  baseModelId: 'qwen-3-5-2b-q4k-ehaf16',
@@ -238,6 +241,7 @@ export function getLoraRunnerCompatibility(workload) {
238
241
  baseModelFamily: baseModel?.family || null,
239
242
  baseModelRunnerKind: baseModel?.runnerKind || null,
240
243
  requiresExternalTrainer: baseModel?.requiresExternalTrainer === true,
244
+ nativeLoraTargets: baseModel?.nativeLoraTargets || Object.freeze([]),
241
245
  datasetKind: dataset?.datasetKind || null,
242
246
  registeredBaseModel: Boolean(baseModel),
243
247
  registeredDatasetFormat: Boolean(dataset),
@@ -401,6 +405,7 @@ function createToyLoraModel(workload) {
401
405
  outDim: 2,
402
406
  rank: workload.pipeline.adapter.rank,
403
407
  alpha: workload.pipeline.adapter.alpha,
408
+ dtype: 'f32',
404
409
  });
405
410
  const model = {
406
411
  adapter,
@@ -0,0 +1,20 @@
1
+ import type { Tensor } from '../../gpu/tensor.js';
2
+ import type { AutogradTape } from './autograd.js';
3
+
4
+ export interface LoraAdapterConfig {
5
+ inDim: number;
6
+ outDim: number;
7
+ rank: number;
8
+ alpha: number;
9
+ dtype: 'f16' | 'f32';
10
+ }
11
+
12
+ export declare class LoraAdapter {
13
+ constructor(config: LoraAdapterConfig);
14
+ A: Tensor;
15
+ B: Tensor;
16
+ alpha: number;
17
+ rank: number;
18
+ forward(input: Tensor, tape: AutogradTape): Promise<Tensor>;
19
+ dispose(): void;
20
+ }
@@ -1,6 +1,5 @@
1
1
  import { acquireBuffer, releaseBuffer, uploadData, BufferUsage } from '../../memory/buffer-pool.js';
2
2
  import { createTensor, tensorBytes } from '../../gpu/tensor.js';
3
- import { getTrainingConfig } from '../../config/training-defaults.js';
4
3
  import { runMatmul, runScale } from '../../gpu/kernels/index.js';
5
4
  import { OpType } from './autograd.js';
6
5
  import { f32ToF16Array } from '../../inference/kv-cache/types.js';
@@ -25,8 +24,10 @@ function uploadLoraInit(buffer, dtype, values) {
25
24
 
26
25
  export class LoraAdapter {
27
26
  constructor(config) {
28
- const { inDim, outDim, rank, alpha } = config;
29
- const { loraParams: dtype } = getTrainingConfig().training.precision;
27
+ const { inDim, outDim, rank, alpha, dtype } = config;
28
+ if (dtype !== 'f16' && dtype !== 'f32') {
29
+ throw new Error(`LoraAdapter dtype must be f16 or f32; got ${String(dtype)}.`);
30
+ }
30
31
 
31
32
  const aBytes = tensorBytes([inDim, rank], dtype);
32
33
  const bBytes = tensorBytes([rank, outDim], dtype);
@@ -0,0 +1,21 @@
1
+ import type { TrainingLossScalingConfigSchema } from '../../config/schema/training.schema.js';
2
+ import type { Tensor } from '../../gpu/tensor.js';
3
+
4
+ export declare function detectOverflow(grads: Map<Tensor, Tensor>): Promise<boolean>;
5
+
6
+ export declare class DynamicLossScaler {
7
+ enabled: boolean;
8
+ scale: number;
9
+ minScale: number;
10
+ maxScale: number;
11
+ scaleFactor: number;
12
+ backoffFactor: number;
13
+ growthInterval: number;
14
+ overflowCheck: boolean;
15
+
16
+ constructor(config?: TrainingLossScalingConfigSchema);
17
+ shouldScale(): boolean;
18
+ scaleLoss(loss: Tensor): Promise<Tensor>;
19
+ unscaleGradients(grads: Map<Tensor, Tensor>): Promise<Map<Tensor, Tensor>>;
20
+ update(hasOverflow: boolean): void;
21
+ }
@@ -0,0 +1,10 @@
1
+ import type { TrainingConfigSchema } from '../../config/training-defaults.d.ts';
2
+ import type { Tensor } from '../../gpu/tensor.js';
3
+ import type { AutogradTape } from './autograd.js';
4
+
5
+ export declare function crossEntropyLoss(
6
+ logits: Tensor,
7
+ targets: Tensor,
8
+ config: TrainingConfigSchema,
9
+ tape: AutogradTape
10
+ ): Promise<Tensor>;
@@ -0,0 +1,106 @@
1
+ import type { InferencePipeline } from '../../inference/pipelines/text.js';
2
+ import type { LoRAExportResult } from './export.js';
3
+ import type { Tensor } from '../../gpu/tensor.js';
4
+
5
+ export interface NativeQwenLoRATrainerOptions {
6
+ pipeline: InferencePipeline;
7
+ baseModelId: string;
8
+ layerIdx: number;
9
+ module: 'down_proj';
10
+ rank: number;
11
+ alpha: number;
12
+ optimizer: {
13
+ type?: string;
14
+ lr: number;
15
+ beta1?: number;
16
+ beta2?: number;
17
+ eps?: number;
18
+ weightDecay?: number;
19
+ };
20
+ gradient?: { maxNorm?: number };
21
+ precision?: { activations?: 'f16' | 'f32'; gradients?: 'f32'; loraParams?: 'f16' | 'f32' };
22
+ }
23
+
24
+ export interface NativeQwenLoRAStepResult {
25
+ loss: number;
26
+ gradientNorm: number | null;
27
+ optimizer: Record<string, unknown> | null;
28
+ }
29
+
30
+ export interface NativeQwenLoRACheckpointTensor {
31
+ dtype: 'f16' | 'f32';
32
+ shape: number[];
33
+ bytes: string;
34
+ }
35
+
36
+ export interface NativeQwenLoRACheckpoint {
37
+ schemaVersion: 1;
38
+ backend: 'webgpu_native';
39
+ baseModelId: string;
40
+ target: { layerIdx: number; module: 'down_proj' };
41
+ rank: number;
42
+ alpha: number;
43
+ stepCount: number;
44
+ adapter: { A: NativeQwenLoRACheckpointTensor; B: NativeQwenLoRACheckpointTensor };
45
+ optimizer: Array<{ m: NativeQwenLoRACheckpointTensor; v: NativeQwenLoRACheckpointTensor }>;
46
+ }
47
+
48
+ export declare class NativeQwenLoRATrainer {
49
+ constructor(options: NativeQwenLoRATrainerOptions);
50
+ readonly pipeline: InferencePipeline;
51
+ readonly layerIdx: number;
52
+ readonly module: 'down_proj';
53
+ readonly baseModelId: string;
54
+ readonly adapter: { A: Tensor; B: Tensor; rank: number; alpha: number };
55
+ paramGroups(): { base: Tensor[]; lora: Tensor[] };
56
+ trainStep(
57
+ inputIds: readonly number[],
58
+ targetIds: readonly number[],
59
+ supervisedTokenCount: number
60
+ ): Promise<NativeQwenLoRAStepResult>;
61
+ exportAdapter(options: {
62
+ id: string;
63
+ name: string;
64
+ weightsPath: string;
65
+ }): Promise<LoRAExportResult>;
66
+ createCheckpoint(): Promise<NativeQwenLoRACheckpoint>;
67
+ restoreCheckpoint(checkpoint: NativeQwenLoRACheckpoint): void;
68
+ dispose(): void;
69
+ }
70
+
71
+ export declare function createNativeQwenLoRATrainer(
72
+ options: NativeQwenLoRATrainerOptions
73
+ ): NativeQwenLoRATrainer;
74
+
75
+ export declare function loadNativeQwenTrainingPipeline(
76
+ modelUrl: string,
77
+ options?: {
78
+ log?: (message: string) => void;
79
+ onProgress?: (stage: string, progress: number, message: string) => void;
80
+ runtime?: Record<string, unknown>;
81
+ }
82
+ ): Promise<{
83
+ pipeline: InferencePipeline;
84
+ manifest: Record<string, unknown> & { modelId: 'qwen-3-5-0-8b-q4k-ehaf16' };
85
+ capabilities: Record<string, unknown>;
86
+ configSnapshot: Record<string, unknown>;
87
+ }>;
88
+
89
+ export interface NativeQwenSftLoRAOptions extends NativeQwenLoRATrainerOptions {
90
+ samples: Array<{
91
+ inputIds: readonly number[];
92
+ targetIds: readonly number[];
93
+ supervisedTokenCount: number;
94
+ }>;
95
+ maxSteps?: number;
96
+ export?: { id: string; name: string; weightsPath: string } | null;
97
+ }
98
+
99
+ export declare function trainNativeQwenSftLoRA(options: NativeQwenSftLoRAOptions): Promise<{
100
+ backend: 'webgpu_native';
101
+ surfaces: ['browser', 'node', 'bun'];
102
+ baseModelId: string;
103
+ target: { layerIdx: number; module: 'down_proj' };
104
+ metrics: NativeQwenLoRAStepResult[];
105
+ adapter: LoRAExportResult | null;
106
+ }>;