openpond-sdk 0.12.22 → 0.12.24
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.
- package/TRAINING_WORKFLOWS.md +17 -0
- package/dist/{chunk-LEVXD73U.js → chunk-KEG5QS7W.js} +8 -1
- package/dist/chunk-KEG5QS7W.js.map +1 -0
- package/dist/training-bundle.js +1 -1
- package/dist/training.js +113 -18
- package/dist/training.js.map +1 -1
- package/dist/types/packages/sdk/src/experiment-draft-storage.d.ts +102 -8
- package/dist/types/packages/sdk/src/experiment-draft-storage.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/managed-neuron-training-executions.d.ts +242 -21
- package/dist/types/packages/sdk/src/managed-neuron-training-executions.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/neuron-training-artifact.d.ts +42 -3
- package/dist/types/packages/sdk/src/neuron-training-artifact.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/neuron-training-experiment-draft.d.ts +16 -1
- package/dist/types/packages/sdk/src/neuron-training-experiment-draft.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/neuron-training-model-serving.d.ts +168 -16
- package/dist/types/packages/sdk/src/neuron-training-model-serving.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/neuron-training-result.d.ts +42 -3
- package/dist/types/packages/sdk/src/neuron-training-result.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/neuron-training.d.ts +23 -2
- package/dist/types/packages/sdk/src/neuron-training.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/steering-model-serving.d.ts +42 -4
- package/dist/types/packages/sdk/src/steering-model-serving.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/steering-profile-publication.d.ts +84 -8
- package/dist/types/packages/sdk/src/steering-profile-publication.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/training-experiment-setup.d.ts +45 -2
- package/dist/types/packages/sdk/src/training-experiment-setup.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/training-preparations.d.ts +1770 -485
- package/dist/types/packages/sdk/src/training-preparations.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/training-usage-funding.d.ts +23 -0
- package/dist/types/packages/sdk/src/training-usage-funding.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/training.d.ts +792 -74
- package/dist/types/packages/sdk/src/training.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/weight-experiment-authoring.d.ts +5 -2
- package/dist/types/packages/sdk/src/weight-experiment-authoring.d.ts.map +1 -1
- package/dist/types/packages/sdk/src/weight-model-versions.d.ts +168 -16
- package/dist/types/packages/sdk/src/weight-model-versions.d.ts.map +1 -1
- package/fixtures/python-foundation/schemas.json +8701 -8344
- package/package.json +1 -1
- package/dist/chunk-LEVXD73U.js.map +0 -1
|
@@ -359,7 +359,13 @@ export declare const NeuronTrainingModelServingContentSchema: z.ZodObject<{
|
|
|
359
359
|
maxCheckpointBytes: z.ZodNumber;
|
|
360
360
|
maximumForwardTokenWork: z.ZodNumber;
|
|
361
361
|
}, z.core.$strict>;
|
|
362
|
-
parentArtifact: z.
|
|
362
|
+
parentArtifact: z.ZodNullable<z.ZodObject<{
|
|
363
|
+
id: z.ZodString;
|
|
364
|
+
contentHash: z.ZodString;
|
|
365
|
+
selectionHash: z.ZodString;
|
|
366
|
+
payloadSha256: z.ZodString;
|
|
367
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
368
|
+
}, z.core.$strict>>;
|
|
363
369
|
}, z.core.$strict>;
|
|
364
370
|
artifact: z.ZodObject<{
|
|
365
371
|
id: z.ZodString;
|
|
@@ -442,7 +448,7 @@ export declare const NeuronTrainingModelServingContentSchema: z.ZodObject<{
|
|
|
442
448
|
selectionConfigHash: z.ZodString;
|
|
443
449
|
trainingConfigHash: z.ZodString;
|
|
444
450
|
runtimeHash: z.ZodString;
|
|
445
|
-
parentArtifactHash: z.
|
|
451
|
+
parentArtifactHash: z.ZodNullable<z.ZodString>;
|
|
446
452
|
}, z.core.$strict>;
|
|
447
453
|
selection: z.ZodObject<{
|
|
448
454
|
schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
|
|
@@ -472,6 +478,19 @@ export declare const NeuronTrainingModelServingContentSchema: z.ZodObject<{
|
|
|
472
478
|
}, z.core.$strict>>;
|
|
473
479
|
contentHash: z.ZodString;
|
|
474
480
|
}, z.core.$strict>;
|
|
481
|
+
continuation: z.ZodOptional<z.ZodObject<{
|
|
482
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
483
|
+
selectionProvenance: z.ZodLiteral<"inherited_parent_observations">;
|
|
484
|
+
parameterAnchor: z.ZodLiteral<"original_dense_base_columns_v1">;
|
|
485
|
+
parentArtifactHash: z.ZodString;
|
|
486
|
+
parentSelectionHash: z.ZodString;
|
|
487
|
+
parentPayloadSha256: z.ZodString;
|
|
488
|
+
parentPatchStateSha256: z.ZodString;
|
|
489
|
+
initialPatchStateSha256: z.ZodString;
|
|
490
|
+
finalPatchStateSha256: z.ZodString;
|
|
491
|
+
installedBeforeOptimizer: z.ZodLiteral<true>;
|
|
492
|
+
optimizerState: z.ZodLiteral<"fresh">;
|
|
493
|
+
}, z.core.$strict>>;
|
|
475
494
|
payload: z.ZodObject<{
|
|
476
495
|
path: z.ZodLiteral<"patch.safetensors">;
|
|
477
496
|
sha256: z.ZodString;
|
|
@@ -940,7 +959,13 @@ export declare const NeuronTrainingModelServingSchema: z.ZodObject<{
|
|
|
940
959
|
maxCheckpointBytes: z.ZodNumber;
|
|
941
960
|
maximumForwardTokenWork: z.ZodNumber;
|
|
942
961
|
}, z.core.$strict>;
|
|
943
|
-
parentArtifact: z.
|
|
962
|
+
parentArtifact: z.ZodNullable<z.ZodObject<{
|
|
963
|
+
id: z.ZodString;
|
|
964
|
+
contentHash: z.ZodString;
|
|
965
|
+
selectionHash: z.ZodString;
|
|
966
|
+
payloadSha256: z.ZodString;
|
|
967
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
968
|
+
}, z.core.$strict>>;
|
|
944
969
|
}, z.core.$strict>;
|
|
945
970
|
artifact: z.ZodObject<{
|
|
946
971
|
id: z.ZodString;
|
|
@@ -1023,7 +1048,7 @@ export declare const NeuronTrainingModelServingSchema: z.ZodObject<{
|
|
|
1023
1048
|
selectionConfigHash: z.ZodString;
|
|
1024
1049
|
trainingConfigHash: z.ZodString;
|
|
1025
1050
|
runtimeHash: z.ZodString;
|
|
1026
|
-
parentArtifactHash: z.
|
|
1051
|
+
parentArtifactHash: z.ZodNullable<z.ZodString>;
|
|
1027
1052
|
}, z.core.$strict>;
|
|
1028
1053
|
selection: z.ZodObject<{
|
|
1029
1054
|
schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
|
|
@@ -1053,6 +1078,19 @@ export declare const NeuronTrainingModelServingSchema: z.ZodObject<{
|
|
|
1053
1078
|
}, z.core.$strict>>;
|
|
1054
1079
|
contentHash: z.ZodString;
|
|
1055
1080
|
}, z.core.$strict>;
|
|
1081
|
+
continuation: z.ZodOptional<z.ZodObject<{
|
|
1082
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
1083
|
+
selectionProvenance: z.ZodLiteral<"inherited_parent_observations">;
|
|
1084
|
+
parameterAnchor: z.ZodLiteral<"original_dense_base_columns_v1">;
|
|
1085
|
+
parentArtifactHash: z.ZodString;
|
|
1086
|
+
parentSelectionHash: z.ZodString;
|
|
1087
|
+
parentPayloadSha256: z.ZodString;
|
|
1088
|
+
parentPatchStateSha256: z.ZodString;
|
|
1089
|
+
initialPatchStateSha256: z.ZodString;
|
|
1090
|
+
finalPatchStateSha256: z.ZodString;
|
|
1091
|
+
installedBeforeOptimizer: z.ZodLiteral<true>;
|
|
1092
|
+
optimizerState: z.ZodLiteral<"fresh">;
|
|
1093
|
+
}, z.core.$strict>>;
|
|
1056
1094
|
payload: z.ZodObject<{
|
|
1057
1095
|
path: z.ZodLiteral<"patch.safetensors">;
|
|
1058
1096
|
sha256: z.ZodString;
|
|
@@ -1448,7 +1486,13 @@ export declare const NeuronTrainingModelServingControlReceiptContentSchema: z.Zo
|
|
|
1448
1486
|
maxCheckpointBytes: z.ZodNumber;
|
|
1449
1487
|
maximumForwardTokenWork: z.ZodNumber;
|
|
1450
1488
|
}, z.core.$strict>;
|
|
1451
|
-
parentArtifact: z.
|
|
1489
|
+
parentArtifact: z.ZodNullable<z.ZodObject<{
|
|
1490
|
+
id: z.ZodString;
|
|
1491
|
+
contentHash: z.ZodString;
|
|
1492
|
+
selectionHash: z.ZodString;
|
|
1493
|
+
payloadSha256: z.ZodString;
|
|
1494
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
1495
|
+
}, z.core.$strict>>;
|
|
1452
1496
|
}, z.core.$strict>;
|
|
1453
1497
|
artifact: z.ZodObject<{
|
|
1454
1498
|
id: z.ZodString;
|
|
@@ -1531,7 +1575,7 @@ export declare const NeuronTrainingModelServingControlReceiptContentSchema: z.Zo
|
|
|
1531
1575
|
selectionConfigHash: z.ZodString;
|
|
1532
1576
|
trainingConfigHash: z.ZodString;
|
|
1533
1577
|
runtimeHash: z.ZodString;
|
|
1534
|
-
parentArtifactHash: z.
|
|
1578
|
+
parentArtifactHash: z.ZodNullable<z.ZodString>;
|
|
1535
1579
|
}, z.core.$strict>;
|
|
1536
1580
|
selection: z.ZodObject<{
|
|
1537
1581
|
schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
|
|
@@ -1561,6 +1605,19 @@ export declare const NeuronTrainingModelServingControlReceiptContentSchema: z.Zo
|
|
|
1561
1605
|
}, z.core.$strict>>;
|
|
1562
1606
|
contentHash: z.ZodString;
|
|
1563
1607
|
}, z.core.$strict>;
|
|
1608
|
+
continuation: z.ZodOptional<z.ZodObject<{
|
|
1609
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
1610
|
+
selectionProvenance: z.ZodLiteral<"inherited_parent_observations">;
|
|
1611
|
+
parameterAnchor: z.ZodLiteral<"original_dense_base_columns_v1">;
|
|
1612
|
+
parentArtifactHash: z.ZodString;
|
|
1613
|
+
parentSelectionHash: z.ZodString;
|
|
1614
|
+
parentPayloadSha256: z.ZodString;
|
|
1615
|
+
parentPatchStateSha256: z.ZodString;
|
|
1616
|
+
initialPatchStateSha256: z.ZodString;
|
|
1617
|
+
finalPatchStateSha256: z.ZodString;
|
|
1618
|
+
installedBeforeOptimizer: z.ZodLiteral<true>;
|
|
1619
|
+
optimizerState: z.ZodLiteral<"fresh">;
|
|
1620
|
+
}, z.core.$strict>>;
|
|
1564
1621
|
payload: z.ZodObject<{
|
|
1565
1622
|
path: z.ZodLiteral<"patch.safetensors">;
|
|
1566
1623
|
sha256: z.ZodString;
|
|
@@ -1794,7 +1851,13 @@ export declare const NeuronTrainingModelServingControlReceiptSchema: z.ZodObject
|
|
|
1794
1851
|
maxCheckpointBytes: z.ZodNumber;
|
|
1795
1852
|
maximumForwardTokenWork: z.ZodNumber;
|
|
1796
1853
|
}, z.core.$strict>;
|
|
1797
|
-
parentArtifact: z.
|
|
1854
|
+
parentArtifact: z.ZodNullable<z.ZodObject<{
|
|
1855
|
+
id: z.ZodString;
|
|
1856
|
+
contentHash: z.ZodString;
|
|
1857
|
+
selectionHash: z.ZodString;
|
|
1858
|
+
payloadSha256: z.ZodString;
|
|
1859
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
1860
|
+
}, z.core.$strict>>;
|
|
1798
1861
|
}, z.core.$strict>;
|
|
1799
1862
|
artifact: z.ZodObject<{
|
|
1800
1863
|
id: z.ZodString;
|
|
@@ -1877,7 +1940,7 @@ export declare const NeuronTrainingModelServingControlReceiptSchema: z.ZodObject
|
|
|
1877
1940
|
selectionConfigHash: z.ZodString;
|
|
1878
1941
|
trainingConfigHash: z.ZodString;
|
|
1879
1942
|
runtimeHash: z.ZodString;
|
|
1880
|
-
parentArtifactHash: z.
|
|
1943
|
+
parentArtifactHash: z.ZodNullable<z.ZodString>;
|
|
1881
1944
|
}, z.core.$strict>;
|
|
1882
1945
|
selection: z.ZodObject<{
|
|
1883
1946
|
schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
|
|
@@ -1907,6 +1970,19 @@ export declare const NeuronTrainingModelServingControlReceiptSchema: z.ZodObject
|
|
|
1907
1970
|
}, z.core.$strict>>;
|
|
1908
1971
|
contentHash: z.ZodString;
|
|
1909
1972
|
}, z.core.$strict>;
|
|
1973
|
+
continuation: z.ZodOptional<z.ZodObject<{
|
|
1974
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
1975
|
+
selectionProvenance: z.ZodLiteral<"inherited_parent_observations">;
|
|
1976
|
+
parameterAnchor: z.ZodLiteral<"original_dense_base_columns_v1">;
|
|
1977
|
+
parentArtifactHash: z.ZodString;
|
|
1978
|
+
parentSelectionHash: z.ZodString;
|
|
1979
|
+
parentPayloadSha256: z.ZodString;
|
|
1980
|
+
parentPatchStateSha256: z.ZodString;
|
|
1981
|
+
initialPatchStateSha256: z.ZodString;
|
|
1982
|
+
finalPatchStateSha256: z.ZodString;
|
|
1983
|
+
installedBeforeOptimizer: z.ZodLiteral<true>;
|
|
1984
|
+
optimizerState: z.ZodLiteral<"fresh">;
|
|
1985
|
+
}, z.core.$strict>>;
|
|
1910
1986
|
payload: z.ZodObject<{
|
|
1911
1987
|
path: z.ZodLiteral<"patch.safetensors">;
|
|
1912
1988
|
sha256: z.ZodString;
|
|
@@ -2131,7 +2207,13 @@ export declare function parseAndVerifyNeuronTrainingModelServingControl(raw: unk
|
|
|
2131
2207
|
maxCheckpointBytes: number;
|
|
2132
2208
|
maximumForwardTokenWork: number;
|
|
2133
2209
|
};
|
|
2134
|
-
parentArtifact:
|
|
2210
|
+
parentArtifact: {
|
|
2211
|
+
id: string;
|
|
2212
|
+
contentHash: string;
|
|
2213
|
+
selectionHash: string;
|
|
2214
|
+
payloadSha256: string;
|
|
2215
|
+
mode: "frozen_parent_fresh_residual_adam_v1";
|
|
2216
|
+
} | null;
|
|
2135
2217
|
};
|
|
2136
2218
|
artifact: {
|
|
2137
2219
|
id: string;
|
|
@@ -2210,7 +2292,7 @@ export declare function parseAndVerifyNeuronTrainingModelServingControl(raw: unk
|
|
|
2210
2292
|
selectionConfigHash: string;
|
|
2211
2293
|
trainingConfigHash: string;
|
|
2212
2294
|
runtimeHash: string;
|
|
2213
|
-
parentArtifactHash: null;
|
|
2295
|
+
parentArtifactHash: string | null;
|
|
2214
2296
|
};
|
|
2215
2297
|
selection: {
|
|
2216
2298
|
schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
|
|
@@ -2237,6 +2319,19 @@ export declare function parseAndVerifyNeuronTrainingModelServingControl(raw: unk
|
|
|
2237
2319
|
}[];
|
|
2238
2320
|
contentHash: string;
|
|
2239
2321
|
};
|
|
2322
|
+
continuation?: {
|
|
2323
|
+
mode: "frozen_parent_fresh_residual_adam_v1";
|
|
2324
|
+
selectionProvenance: "inherited_parent_observations";
|
|
2325
|
+
parameterAnchor: "original_dense_base_columns_v1";
|
|
2326
|
+
parentArtifactHash: string;
|
|
2327
|
+
parentSelectionHash: string;
|
|
2328
|
+
parentPayloadSha256: string;
|
|
2329
|
+
parentPatchStateSha256: string;
|
|
2330
|
+
initialPatchStateSha256: string;
|
|
2331
|
+
finalPatchStateSha256: string;
|
|
2332
|
+
installedBeforeOptimizer: true;
|
|
2333
|
+
optimizerState: "fresh";
|
|
2334
|
+
} | undefined;
|
|
2240
2335
|
payload: {
|
|
2241
2336
|
path: "patch.safetensors";
|
|
2242
2337
|
sha256: string;
|
|
@@ -2476,7 +2571,13 @@ export declare function parseAndVerifyNeuronTrainingModelServing(raw: unknown, e
|
|
|
2476
2571
|
maxCheckpointBytes: number;
|
|
2477
2572
|
maximumForwardTokenWork: number;
|
|
2478
2573
|
};
|
|
2479
|
-
parentArtifact:
|
|
2574
|
+
parentArtifact: {
|
|
2575
|
+
id: string;
|
|
2576
|
+
contentHash: string;
|
|
2577
|
+
selectionHash: string;
|
|
2578
|
+
payloadSha256: string;
|
|
2579
|
+
mode: "frozen_parent_fresh_residual_adam_v1";
|
|
2580
|
+
} | null;
|
|
2480
2581
|
};
|
|
2481
2582
|
artifact: {
|
|
2482
2583
|
id: string;
|
|
@@ -2555,7 +2656,7 @@ export declare function parseAndVerifyNeuronTrainingModelServing(raw: unknown, e
|
|
|
2555
2656
|
selectionConfigHash: string;
|
|
2556
2657
|
trainingConfigHash: string;
|
|
2557
2658
|
runtimeHash: string;
|
|
2558
|
-
parentArtifactHash: null;
|
|
2659
|
+
parentArtifactHash: string | null;
|
|
2559
2660
|
};
|
|
2560
2661
|
selection: {
|
|
2561
2662
|
schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
|
|
@@ -2582,6 +2683,19 @@ export declare function parseAndVerifyNeuronTrainingModelServing(raw: unknown, e
|
|
|
2582
2683
|
}[];
|
|
2583
2684
|
contentHash: string;
|
|
2584
2685
|
};
|
|
2686
|
+
continuation?: {
|
|
2687
|
+
mode: "frozen_parent_fresh_residual_adam_v1";
|
|
2688
|
+
selectionProvenance: "inherited_parent_observations";
|
|
2689
|
+
parameterAnchor: "original_dense_base_columns_v1";
|
|
2690
|
+
parentArtifactHash: string;
|
|
2691
|
+
parentSelectionHash: string;
|
|
2692
|
+
parentPayloadSha256: string;
|
|
2693
|
+
parentPatchStateSha256: string;
|
|
2694
|
+
initialPatchStateSha256: string;
|
|
2695
|
+
finalPatchStateSha256: string;
|
|
2696
|
+
installedBeforeOptimizer: true;
|
|
2697
|
+
optimizerState: "fresh";
|
|
2698
|
+
} | undefined;
|
|
2585
2699
|
payload: {
|
|
2586
2700
|
path: "patch.safetensors";
|
|
2587
2701
|
sha256: string;
|
|
@@ -2926,7 +3040,13 @@ export declare function createNeuronTrainingModelServingClient(request: (path: s
|
|
|
2926
3040
|
maxCheckpointBytes: number;
|
|
2927
3041
|
maximumForwardTokenWork: number;
|
|
2928
3042
|
};
|
|
2929
|
-
parentArtifact:
|
|
3043
|
+
parentArtifact: {
|
|
3044
|
+
id: string;
|
|
3045
|
+
contentHash: string;
|
|
3046
|
+
selectionHash: string;
|
|
3047
|
+
payloadSha256: string;
|
|
3048
|
+
mode: "frozen_parent_fresh_residual_adam_v1";
|
|
3049
|
+
} | null;
|
|
2930
3050
|
};
|
|
2931
3051
|
artifact: {
|
|
2932
3052
|
id: string;
|
|
@@ -3005,7 +3125,7 @@ export declare function createNeuronTrainingModelServingClient(request: (path: s
|
|
|
3005
3125
|
selectionConfigHash: string;
|
|
3006
3126
|
trainingConfigHash: string;
|
|
3007
3127
|
runtimeHash: string;
|
|
3008
|
-
parentArtifactHash: null;
|
|
3128
|
+
parentArtifactHash: string | null;
|
|
3009
3129
|
};
|
|
3010
3130
|
selection: {
|
|
3011
3131
|
schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
|
|
@@ -3032,6 +3152,19 @@ export declare function createNeuronTrainingModelServingClient(request: (path: s
|
|
|
3032
3152
|
}[];
|
|
3033
3153
|
contentHash: string;
|
|
3034
3154
|
};
|
|
3155
|
+
continuation?: {
|
|
3156
|
+
mode: "frozen_parent_fresh_residual_adam_v1";
|
|
3157
|
+
selectionProvenance: "inherited_parent_observations";
|
|
3158
|
+
parameterAnchor: "original_dense_base_columns_v1";
|
|
3159
|
+
parentArtifactHash: string;
|
|
3160
|
+
parentSelectionHash: string;
|
|
3161
|
+
parentPayloadSha256: string;
|
|
3162
|
+
parentPatchStateSha256: string;
|
|
3163
|
+
initialPatchStateSha256: string;
|
|
3164
|
+
finalPatchStateSha256: string;
|
|
3165
|
+
installedBeforeOptimizer: true;
|
|
3166
|
+
optimizerState: "fresh";
|
|
3167
|
+
} | undefined;
|
|
3035
3168
|
payload: {
|
|
3036
3169
|
path: "patch.safetensors";
|
|
3037
3170
|
sha256: string;
|
|
@@ -3322,7 +3455,13 @@ export declare function createNeuronTrainingModelServingClient(request: (path: s
|
|
|
3322
3455
|
maxCheckpointBytes: number;
|
|
3323
3456
|
maximumForwardTokenWork: number;
|
|
3324
3457
|
};
|
|
3325
|
-
parentArtifact:
|
|
3458
|
+
parentArtifact: {
|
|
3459
|
+
id: string;
|
|
3460
|
+
contentHash: string;
|
|
3461
|
+
selectionHash: string;
|
|
3462
|
+
payloadSha256: string;
|
|
3463
|
+
mode: "frozen_parent_fresh_residual_adam_v1";
|
|
3464
|
+
} | null;
|
|
3326
3465
|
};
|
|
3327
3466
|
artifact: {
|
|
3328
3467
|
id: string;
|
|
@@ -3401,7 +3540,7 @@ export declare function createNeuronTrainingModelServingClient(request: (path: s
|
|
|
3401
3540
|
selectionConfigHash: string;
|
|
3402
3541
|
trainingConfigHash: string;
|
|
3403
3542
|
runtimeHash: string;
|
|
3404
|
-
parentArtifactHash: null;
|
|
3543
|
+
parentArtifactHash: string | null;
|
|
3405
3544
|
};
|
|
3406
3545
|
selection: {
|
|
3407
3546
|
schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
|
|
@@ -3428,6 +3567,19 @@ export declare function createNeuronTrainingModelServingClient(request: (path: s
|
|
|
3428
3567
|
}[];
|
|
3429
3568
|
contentHash: string;
|
|
3430
3569
|
};
|
|
3570
|
+
continuation?: {
|
|
3571
|
+
mode: "frozen_parent_fresh_residual_adam_v1";
|
|
3572
|
+
selectionProvenance: "inherited_parent_observations";
|
|
3573
|
+
parameterAnchor: "original_dense_base_columns_v1";
|
|
3574
|
+
parentArtifactHash: string;
|
|
3575
|
+
parentSelectionHash: string;
|
|
3576
|
+
parentPayloadSha256: string;
|
|
3577
|
+
parentPatchStateSha256: string;
|
|
3578
|
+
initialPatchStateSha256: string;
|
|
3579
|
+
finalPatchStateSha256: string;
|
|
3580
|
+
installedBeforeOptimizer: true;
|
|
3581
|
+
optimizerState: "fresh";
|
|
3582
|
+
} | undefined;
|
|
3431
3583
|
payload: {
|
|
3432
3584
|
path: "patch.safetensors";
|
|
3433
3585
|
sha256: string;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"neuron-training-model-serving.d.ts","sourceRoot":"","sources":["../../../../../src/neuron-training-model-serving.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,qCAAqC;;;kBAAuD,CAAC;AAC1G,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;kBAMhD,CAAC;AACZ,MAAM,MAAM,wCAAwC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8CAA8C,CAAC,CAAC;AACtH,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;kBAAqH,CAAC;AAChL,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;;;;;;;kBAAqG,CAAC;AACjK,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAUzC,CAAC;AACZ,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,CAAC;AACxG,eAAO,MAAM,kCAAkC;;;;;;kBAEpC,CAAC;AACZ,eAAO,MAAM,uCAAuC;;;;;;;;;;;;kBAIzC,CAAC;AACZ,eAAO,MAAM,uCAAuC
|
|
1
|
+
{"version":3,"file":"neuron-training-model-serving.d.ts","sourceRoot":"","sources":["../../../../../src/neuron-training-model-serving.ts"],"names":[],"mappings":"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"}
|
|
@@ -149,7 +149,7 @@ export declare const NeuronTrainingResultContentSchema: z.ZodObject<{
|
|
|
149
149
|
selectionConfigHash: z.ZodString;
|
|
150
150
|
trainingConfigHash: z.ZodString;
|
|
151
151
|
runtimeHash: z.ZodString;
|
|
152
|
-
parentArtifactHash: z.
|
|
152
|
+
parentArtifactHash: z.ZodNullable<z.ZodString>;
|
|
153
153
|
}, z.core.$strict>;
|
|
154
154
|
selection: z.ZodObject<{
|
|
155
155
|
schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
|
|
@@ -179,6 +179,19 @@ export declare const NeuronTrainingResultContentSchema: z.ZodObject<{
|
|
|
179
179
|
}, z.core.$strict>>;
|
|
180
180
|
contentHash: z.ZodString;
|
|
181
181
|
}, z.core.$strict>;
|
|
182
|
+
continuation: z.ZodOptional<z.ZodObject<{
|
|
183
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
184
|
+
selectionProvenance: z.ZodLiteral<"inherited_parent_observations">;
|
|
185
|
+
parameterAnchor: z.ZodLiteral<"original_dense_base_columns_v1">;
|
|
186
|
+
parentArtifactHash: z.ZodString;
|
|
187
|
+
parentSelectionHash: z.ZodString;
|
|
188
|
+
parentPayloadSha256: z.ZodString;
|
|
189
|
+
parentPatchStateSha256: z.ZodString;
|
|
190
|
+
initialPatchStateSha256: z.ZodString;
|
|
191
|
+
finalPatchStateSha256: z.ZodString;
|
|
192
|
+
installedBeforeOptimizer: z.ZodLiteral<true>;
|
|
193
|
+
optimizerState: z.ZodLiteral<"fresh">;
|
|
194
|
+
}, z.core.$strict>>;
|
|
182
195
|
payload: z.ZodObject<{
|
|
183
196
|
path: z.ZodLiteral<"patch.safetensors">;
|
|
184
197
|
sha256: z.ZodString;
|
|
@@ -345,7 +358,7 @@ export declare const NeuronTrainingResultSchema: z.ZodObject<{
|
|
|
345
358
|
selectionConfigHash: z.ZodString;
|
|
346
359
|
trainingConfigHash: z.ZodString;
|
|
347
360
|
runtimeHash: z.ZodString;
|
|
348
|
-
parentArtifactHash: z.
|
|
361
|
+
parentArtifactHash: z.ZodNullable<z.ZodString>;
|
|
349
362
|
}, z.core.$strict>;
|
|
350
363
|
selection: z.ZodObject<{
|
|
351
364
|
schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
|
|
@@ -375,6 +388,19 @@ export declare const NeuronTrainingResultSchema: z.ZodObject<{
|
|
|
375
388
|
}, z.core.$strict>>;
|
|
376
389
|
contentHash: z.ZodString;
|
|
377
390
|
}, z.core.$strict>;
|
|
391
|
+
continuation: z.ZodOptional<z.ZodObject<{
|
|
392
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
393
|
+
selectionProvenance: z.ZodLiteral<"inherited_parent_observations">;
|
|
394
|
+
parameterAnchor: z.ZodLiteral<"original_dense_base_columns_v1">;
|
|
395
|
+
parentArtifactHash: z.ZodString;
|
|
396
|
+
parentSelectionHash: z.ZodString;
|
|
397
|
+
parentPayloadSha256: z.ZodString;
|
|
398
|
+
parentPatchStateSha256: z.ZodString;
|
|
399
|
+
initialPatchStateSha256: z.ZodString;
|
|
400
|
+
finalPatchStateSha256: z.ZodString;
|
|
401
|
+
installedBeforeOptimizer: z.ZodLiteral<true>;
|
|
402
|
+
optimizerState: z.ZodLiteral<"fresh">;
|
|
403
|
+
}, z.core.$strict>>;
|
|
378
404
|
payload: z.ZodObject<{
|
|
379
405
|
path: z.ZodLiteral<"patch.safetensors">;
|
|
380
406
|
sha256: z.ZodString;
|
|
@@ -539,7 +565,7 @@ export declare function parseAndVerifyNeuronTrainingResult(raw: unknown, expecte
|
|
|
539
565
|
selectionConfigHash: string;
|
|
540
566
|
trainingConfigHash: string;
|
|
541
567
|
runtimeHash: string;
|
|
542
|
-
parentArtifactHash: null;
|
|
568
|
+
parentArtifactHash: string | null;
|
|
543
569
|
};
|
|
544
570
|
selection: {
|
|
545
571
|
schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
|
|
@@ -566,6 +592,19 @@ export declare function parseAndVerifyNeuronTrainingResult(raw: unknown, expecte
|
|
|
566
592
|
}[];
|
|
567
593
|
contentHash: string;
|
|
568
594
|
};
|
|
595
|
+
continuation?: {
|
|
596
|
+
mode: "frozen_parent_fresh_residual_adam_v1";
|
|
597
|
+
selectionProvenance: "inherited_parent_observations";
|
|
598
|
+
parameterAnchor: "original_dense_base_columns_v1";
|
|
599
|
+
parentArtifactHash: string;
|
|
600
|
+
parentSelectionHash: string;
|
|
601
|
+
parentPayloadSha256: string;
|
|
602
|
+
parentPatchStateSha256: string;
|
|
603
|
+
initialPatchStateSha256: string;
|
|
604
|
+
finalPatchStateSha256: string;
|
|
605
|
+
installedBeforeOptimizer: true;
|
|
606
|
+
optimizerState: "fresh";
|
|
607
|
+
} | undefined;
|
|
569
608
|
payload: {
|
|
570
609
|
path: "patch.safetensors";
|
|
571
610
|
sha256: string;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"neuron-training-result.d.ts","sourceRoot":"","sources":["../../../../../src/neuron-training-result.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAkE,KAAK,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAMlI,eAAO,MAAM,wBAAwB;;;;;;;;kBACgE,CAAC;AACtG,eAAO,MAAM,iCAAiC
|
|
1
|
+
{"version":3,"file":"neuron-training-result.d.ts","sourceRoot":"","sources":["../../../../../src/neuron-training-result.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAkE,KAAK,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAMlI,eAAO,MAAM,wBAAwB;;;;;;;;kBACgE,CAAC;AACtG,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAcnC,CAAC;AACZ,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAgE,CAAC;AACxG,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,wBAAsB,kCAAkC,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE;IAAC,OAAO,EAAE,qBAAqB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BrI"}
|
|
@@ -2,6 +2,15 @@ import { z } from "zod";
|
|
|
2
2
|
import { NeuronSteeringModelSchema } from "./neuron-steering.js";
|
|
3
3
|
export declare const NEURON_TRAINING_MAX_BYTES = 16777216;
|
|
4
4
|
export declare const NEURON_TRAINING_UPSTREAM_REVISION = "8a55f3159f735eb0823d7a894f67f632bf568bb3";
|
|
5
|
+
/** Exact inference-state continuation. Optimizer/RNG state is never resumed;
|
|
6
|
+
* the parent remains frozen while fresh column parameters learn a residual. */
|
|
7
|
+
export declare const NeuronTrainingParentArtifactReferenceSchema: z.ZodObject<{
|
|
8
|
+
id: z.ZodString;
|
|
9
|
+
contentHash: z.ZodString;
|
|
10
|
+
selectionHash: z.ZodString;
|
|
11
|
+
payloadSha256: z.ZodString;
|
|
12
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
13
|
+
}, z.core.$strict>;
|
|
5
14
|
export declare const NeuronTrainingCoordinateSchema: z.ZodObject<{
|
|
6
15
|
layer: z.ZodNumber;
|
|
7
16
|
neuron: z.ZodNumber;
|
|
@@ -157,7 +166,13 @@ export declare const NeuronTrainingRequestSchema: z.ZodObject<{
|
|
|
157
166
|
maxCheckpointBytes: z.ZodNumber;
|
|
158
167
|
maximumForwardTokenWork: z.ZodNumber;
|
|
159
168
|
}, z.core.$strict>;
|
|
160
|
-
parentArtifact: z.
|
|
169
|
+
parentArtifact: z.ZodNullable<z.ZodObject<{
|
|
170
|
+
id: z.ZodString;
|
|
171
|
+
contentHash: z.ZodString;
|
|
172
|
+
selectionHash: z.ZodString;
|
|
173
|
+
payloadSha256: z.ZodString;
|
|
174
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
175
|
+
}, z.core.$strict>>;
|
|
161
176
|
}, z.core.$strict>;
|
|
162
177
|
export type NeuronTrainingRequest = z.infer<typeof NeuronTrainingRequestSchema>;
|
|
163
178
|
export type NeuronTrainingSelection = z.infer<typeof NeuronTrainingSelectionSchema>;
|
|
@@ -255,6 +270,12 @@ export declare function parseAndVerifyNeuronTrainingRequest(raw: unknown): Promi
|
|
|
255
270
|
maxCheckpointBytes: number;
|
|
256
271
|
maximumForwardTokenWork: number;
|
|
257
272
|
};
|
|
258
|
-
parentArtifact:
|
|
273
|
+
parentArtifact: {
|
|
274
|
+
id: string;
|
|
275
|
+
contentHash: string;
|
|
276
|
+
selectionHash: string;
|
|
277
|
+
payloadSha256: string;
|
|
278
|
+
mode: "frozen_parent_fresh_residual_adam_v1";
|
|
279
|
+
} | null;
|
|
259
280
|
}>;
|
|
260
281
|
//# sourceMappingURL=neuron-training.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"neuron-training.d.ts","sourceRoot":"","sources":["../../../../../src/neuron-training.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAIjE,eAAO,MAAM,yBAAyB,WAAa,CAAC;AACpD,eAAO,MAAM,iCAAiC,6CAA6C,CAAC;AAE5F,eAAO,MAAM,8BAA8B;;;kBAEhC,CAAC;AACZ,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;kBAWxC,CAAC;AACH,eAAO,MAAM,iCAAiC;;;;;;;;kBAEnC,CAAC;AACZ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAOnC,CAAC;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;kBAW9B,CAAC;AACZ,mFAAmF;AACnF,eAAO,MAAM,2BAA2B
|
|
1
|
+
{"version":3,"file":"neuron-training.d.ts","sourceRoot":"","sources":["../../../../../src/neuron-training.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAIjE,eAAO,MAAM,yBAAyB,WAAa,CAAC;AACpD,eAAO,MAAM,iCAAiC,6CAA6C,CAAC;AAE5F;+EAC+E;AAC/E,eAAO,MAAM,2CAA2C;;;;;;kBAI7C,CAAC;AACZ,eAAO,MAAM,8BAA8B;;;kBAEhC,CAAC;AACZ,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;kBAWxC,CAAC;AACH,eAAO,MAAM,iCAAiC;;;;;;;;kBAEnC,CAAC;AACZ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAOnC,CAAC;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;kBAW9B,CAAC;AACZ,mFAAmF;AACnF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAetC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,eAAO,MAAM,4BAA4B;;;;;;;;;;kBAO9B,CAAC;AACZ,wBAAsB,sBAAsB,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,EAAE,iBAAiB,EAAE,MAAM;;;;;;;;;;GAMvH;AACD,wBAAsB,mCAAmC,CAAC,GAAG,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQrE"}
|
|
@@ -4432,7 +4432,13 @@ export declare const SavedModelServingSchema: z.ZodDiscriminatedUnion<[z.ZodObje
|
|
|
4432
4432
|
maxCheckpointBytes: z.ZodNumber;
|
|
4433
4433
|
maximumForwardTokenWork: z.ZodNumber;
|
|
4434
4434
|
}, z.core.$strict>;
|
|
4435
|
-
parentArtifact: z.
|
|
4435
|
+
parentArtifact: z.ZodNullable<z.ZodObject<{
|
|
4436
|
+
id: z.ZodString;
|
|
4437
|
+
contentHash: z.ZodString;
|
|
4438
|
+
selectionHash: z.ZodString;
|
|
4439
|
+
payloadSha256: z.ZodString;
|
|
4440
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
4441
|
+
}, z.core.$strict>>;
|
|
4436
4442
|
}, z.core.$strict>;
|
|
4437
4443
|
artifact: z.ZodObject<{
|
|
4438
4444
|
id: z.ZodString;
|
|
@@ -4515,7 +4521,7 @@ export declare const SavedModelServingSchema: z.ZodDiscriminatedUnion<[z.ZodObje
|
|
|
4515
4521
|
selectionConfigHash: z.ZodString;
|
|
4516
4522
|
trainingConfigHash: z.ZodString;
|
|
4517
4523
|
runtimeHash: z.ZodString;
|
|
4518
|
-
parentArtifactHash: z.
|
|
4524
|
+
parentArtifactHash: z.ZodNullable<z.ZodString>;
|
|
4519
4525
|
}, z.core.$strict>;
|
|
4520
4526
|
selection: z.ZodObject<{
|
|
4521
4527
|
schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
|
|
@@ -4545,6 +4551,19 @@ export declare const SavedModelServingSchema: z.ZodDiscriminatedUnion<[z.ZodObje
|
|
|
4545
4551
|
}, z.core.$strict>>;
|
|
4546
4552
|
contentHash: z.ZodString;
|
|
4547
4553
|
}, z.core.$strict>;
|
|
4554
|
+
continuation: z.ZodOptional<z.ZodObject<{
|
|
4555
|
+
mode: z.ZodLiteral<"frozen_parent_fresh_residual_adam_v1">;
|
|
4556
|
+
selectionProvenance: z.ZodLiteral<"inherited_parent_observations">;
|
|
4557
|
+
parameterAnchor: z.ZodLiteral<"original_dense_base_columns_v1">;
|
|
4558
|
+
parentArtifactHash: z.ZodString;
|
|
4559
|
+
parentSelectionHash: z.ZodString;
|
|
4560
|
+
parentPayloadSha256: z.ZodString;
|
|
4561
|
+
parentPatchStateSha256: z.ZodString;
|
|
4562
|
+
initialPatchStateSha256: z.ZodString;
|
|
4563
|
+
finalPatchStateSha256: z.ZodString;
|
|
4564
|
+
installedBeforeOptimizer: z.ZodLiteral<true>;
|
|
4565
|
+
optimizerState: z.ZodLiteral<"fresh">;
|
|
4566
|
+
}, z.core.$strict>>;
|
|
4548
4567
|
payload: z.ZodObject<{
|
|
4549
4568
|
path: z.ZodLiteral<"patch.safetensors">;
|
|
4550
4569
|
sha256: z.ZodString;
|
|
@@ -8306,7 +8325,13 @@ export declare function createSavedModelServingClient(request: (path: string, in
|
|
|
8306
8325
|
maxCheckpointBytes: number;
|
|
8307
8326
|
maximumForwardTokenWork: number;
|
|
8308
8327
|
};
|
|
8309
|
-
parentArtifact:
|
|
8328
|
+
parentArtifact: {
|
|
8329
|
+
id: string;
|
|
8330
|
+
contentHash: string;
|
|
8331
|
+
selectionHash: string;
|
|
8332
|
+
payloadSha256: string;
|
|
8333
|
+
mode: "frozen_parent_fresh_residual_adam_v1";
|
|
8334
|
+
} | null;
|
|
8310
8335
|
};
|
|
8311
8336
|
artifact: {
|
|
8312
8337
|
id: string;
|
|
@@ -8385,7 +8410,7 @@ export declare function createSavedModelServingClient(request: (path: string, in
|
|
|
8385
8410
|
selectionConfigHash: string;
|
|
8386
8411
|
trainingConfigHash: string;
|
|
8387
8412
|
runtimeHash: string;
|
|
8388
|
-
parentArtifactHash: null;
|
|
8413
|
+
parentArtifactHash: string | null;
|
|
8389
8414
|
};
|
|
8390
8415
|
selection: {
|
|
8391
8416
|
schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
|
|
@@ -8412,6 +8437,19 @@ export declare function createSavedModelServingClient(request: (path: string, in
|
|
|
8412
8437
|
}[];
|
|
8413
8438
|
contentHash: string;
|
|
8414
8439
|
};
|
|
8440
|
+
continuation?: {
|
|
8441
|
+
mode: "frozen_parent_fresh_residual_adam_v1";
|
|
8442
|
+
selectionProvenance: "inherited_parent_observations";
|
|
8443
|
+
parameterAnchor: "original_dense_base_columns_v1";
|
|
8444
|
+
parentArtifactHash: string;
|
|
8445
|
+
parentSelectionHash: string;
|
|
8446
|
+
parentPayloadSha256: string;
|
|
8447
|
+
parentPatchStateSha256: string;
|
|
8448
|
+
initialPatchStateSha256: string;
|
|
8449
|
+
finalPatchStateSha256: string;
|
|
8450
|
+
installedBeforeOptimizer: true;
|
|
8451
|
+
optimizerState: "fresh";
|
|
8452
|
+
} | undefined;
|
|
8415
8453
|
payload: {
|
|
8416
8454
|
path: "patch.safetensors";
|
|
8417
8455
|
sha256: string;
|