openpond-sdk 0.12.13 → 0.12.15

package/dist/types/packages/sdk/src/neuron-training-artifact.d.ts

@@ -0,0 +1,517 @@
+import { z } from "zod";
+import { type NeuronTrainingRequest } from "./neuron-training.js";
+export declare const NeuronTrainingAlgorithmSchema: z.ZodObject<{
+    implementation: z.ZodLiteral<"openpond_qwen3_selective_columns_v1">;
+    upstream: z.ZodLiteral<"changjonathanc/neuron-tuning">;
+    revision: z.ZodLiteral<"8a55f3159f735eb0823d7a894f67f632bf568bb3">;
+    license: z.ZodLiteral<"Apache-2.0">;
+    hook: z.ZodLiteral<"mlp.down_proj">;
+    operation: z.ZodLiteral<"output_plus_selected_input_times_delta_v1">;
+    parameterization: z.ZodLiteral<"column_gain_rms_direction_v1">;
+    activityQuantile: z.ZodLiteral<0.9>;
+    backgroundFloor: z.ZodLiteral<0.000001>;
+    gradientSubsetSeed: z.ZodLiteral<0>;
+    optimizer: z.ZodLiteral<"Adam">;
+    betas: z.ZodTuple<[z.ZodLiteral<0.9>, z.ZodLiteral<0.999>], null>;
+    epsilon: z.ZodLiteral<1e-8>;
+    weightDecay: z.ZodLiteral<0>;
+    gradientClipNorm: z.ZodLiteral<1>;
+    batchSize: z.ZodLiteral<1>;
+    parameterDtype: z.ZodLiteral<"float32">;
+    resume: z.ZodLiteral<"unsupported">;
+}, z.core.$strict>;
+export declare function neuronTrainingAlgorithm(): {
+    implementation: "openpond_qwen3_selective_columns_v1";
+    upstream: "changjonathanc/neuron-tuning";
+    revision: "8a55f3159f735eb0823d7a894f67f632bf568bb3";
+    license: "Apache-2.0";
+    hook: "mlp.down_proj";
+    operation: "output_plus_selected_input_times_delta_v1";
+    parameterization: "column_gain_rms_direction_v1";
+    activityQuantile: 0.9;
+    backgroundFloor: 0.000001;
+    gradientSubsetSeed: 0;
+    optimizer: "Adam";
+    betas: [0.9, 0.999];
+    epsilon: 1e-8;
+    weightDecay: 0;
+    gradientClipNorm: 1;
+    batchSize: 1;
+    parameterDtype: "float32";
+    resume: "unsupported";
+};
+export declare const NeuronTrainingSelectionEntrySchema: z.ZodObject<{
+    layer: z.ZodNumber;
+    neuron: z.ZodNumber;
+    targetMeanAbsolute: z.ZodNumber;
+    backgroundMeanAbsolute: z.ZodNumber;
+    backgroundTargetRatio: z.ZodNumber;
+    gradientNorm: z.ZodNumber;
+    score: z.ZodNumber;
+    targetActivityThreshold: z.ZodNumber;
+    backgroundByDomain: z.ZodArray<z.ZodObject<{
+        domainIndex: z.ZodNumber;
+        meanAbsolute: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const NeuronTrainingSelectionResultContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
+    modelHash: z.ZodString;
+    dataHash: z.ZodString;
+    selectionConfigHash: z.ZodString;
+    preparedRowsHash: z.ZodString;
+    source: z.ZodEnum<{
+        automatic: "automatic";
+        explicit: "explicit";
+    }>;
+    targetExampleIds: z.ZodArray<z.ZodString>;
+    eligibleCount: z.ZodNumber;
+    entries: z.ZodArray<z.ZodObject<{
+        layer: z.ZodNumber;
+        neuron: z.ZodNumber;
+        targetMeanAbsolute: z.ZodNumber;
+        backgroundMeanAbsolute: z.ZodNumber;
+        backgroundTargetRatio: z.ZodNumber;
+        gradientNorm: z.ZodNumber;
+        score: z.ZodNumber;
+        targetActivityThreshold: z.ZodNumber;
+        backgroundByDomain: z.ZodArray<z.ZodObject<{
+            domainIndex: z.ZodNumber;
+            meanAbsolute: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const NeuronTrainingSelectionResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
+    modelHash: z.ZodString;
+    dataHash: z.ZodString;
+    selectionConfigHash: z.ZodString;
+    preparedRowsHash: z.ZodString;
+    source: z.ZodEnum<{
+        automatic: "automatic";
+        explicit: "explicit";
+    }>;
+    targetExampleIds: z.ZodArray<z.ZodString>;
+    eligibleCount: z.ZodNumber;
+    entries: z.ZodArray<z.ZodObject<{
+        layer: z.ZodNumber;
+        neuron: z.ZodNumber;
+        targetMeanAbsolute: z.ZodNumber;
+        backgroundMeanAbsolute: z.ZodNumber;
+        backgroundTargetRatio: z.ZodNumber;
+        gradientNorm: z.ZodNumber;
+        score: z.ZodNumber;
+        targetActivityThreshold: z.ZodNumber;
+        backgroundByDomain: z.ZodArray<z.ZodObject<{
+            domainIndex: z.ZodNumber;
+            meanAbsolute: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type NeuronTrainingSelectionResult = z.infer<typeof NeuronTrainingSelectionResultSchema>;
+export declare function parseAndVerifyNeuronTrainingSelection(raw: unknown, request: NeuronTrainingRequest): Promise<{
+    schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
+    modelHash: string;
+    dataHash: string;
+    selectionConfigHash: string;
+    preparedRowsHash: string;
+    source: "automatic" | "explicit";
+    targetExampleIds: string[];
+    eligibleCount: number;
+    entries: {
+        layer: number;
+        neuron: number;
+        targetMeanAbsolute: number;
+        backgroundMeanAbsolute: number;
+        backgroundTargetRatio: number;
+        gradientNorm: number;
+        score: number;
+        targetActivityThreshold: number;
+        backgroundByDomain: {
+            domainIndex: number;
+            meanAbsolute: number;
+        }[];
+    }[];
+    contentHash: string;
+}>;
+export declare const NeuronTrainingPatchTensorSchema: z.ZodObject<{
+    name: z.ZodString;
+    dtype: z.ZodEnum<{
+        F32: "F32";
+        I64: "I64";
+    }>;
+    shape: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>;
+export declare function neuronTrainingPatchTensorInventory(selection: NeuronTrainingSelectionResult): ({
+    name: string;
+    dtype: "I64";
+    shape: number[];
+} | {
+    name: string;
+    dtype: "F32";
+    shape: number[];
+})[];
+export declare const NeuronTrainingArtifactContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingArtifact.v1">;
+    method: z.ZodLiteral<"selective_neuron_training">;
+    algorithm: z.ZodObject<{
+        implementation: z.ZodLiteral<"openpond_qwen3_selective_columns_v1">;
+        upstream: z.ZodLiteral<"changjonathanc/neuron-tuning">;
+        revision: z.ZodLiteral<"8a55f3159f735eb0823d7a894f67f632bf568bb3">;
+        license: z.ZodLiteral<"Apache-2.0">;
+        hook: z.ZodLiteral<"mlp.down_proj">;
+        operation: z.ZodLiteral<"output_plus_selected_input_times_delta_v1">;
+        parameterization: z.ZodLiteral<"column_gain_rms_direction_v1">;
+        activityQuantile: z.ZodLiteral<0.9>;
+        backgroundFloor: z.ZodLiteral<0.000001>;
+        gradientSubsetSeed: z.ZodLiteral<0>;
+        optimizer: z.ZodLiteral<"Adam">;
+        betas: z.ZodTuple<[z.ZodLiteral<0.9>, z.ZodLiteral<0.999>], null>;
+        epsilon: z.ZodLiteral<1e-8>;
+        weightDecay: z.ZodLiteral<0>;
+        gradientClipNorm: z.ZodLiteral<1>;
+        batchSize: z.ZodLiteral<1>;
+        parameterDtype: z.ZodLiteral<"float32">;
+        resume: z.ZodLiteral<"unsupported">;
+    }, z.core.$strict>;
+    pins: z.ZodObject<{
+        baseModel: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+        inputHash: z.ZodString;
+        data: z.ZodObject<{
+            target: z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>;
+            background: z.ZodArray<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+                domain: z.ZodString;
+            }, z.core.$strict>>;
+            preservation: z.ZodNullable<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        dataHash: z.ZodString;
+        selectionConfigHash: z.ZodString;
+        trainingConfigHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        parentArtifactHash: z.ZodNull;
+    }, z.core.$strict>;
+    selection: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
+        modelHash: z.ZodString;
+        dataHash: z.ZodString;
+        selectionConfigHash: z.ZodString;
+        preparedRowsHash: z.ZodString;
+        source: z.ZodEnum<{
+            automatic: "automatic";
+            explicit: "explicit";
+        }>;
+        targetExampleIds: z.ZodArray<z.ZodString>;
+        eligibleCount: z.ZodNumber;
+        entries: z.ZodArray<z.ZodObject<{
+            layer: z.ZodNumber;
+            neuron: z.ZodNumber;
+            targetMeanAbsolute: z.ZodNumber;
+            backgroundMeanAbsolute: z.ZodNumber;
+            backgroundTargetRatio: z.ZodNumber;
+            gradientNorm: z.ZodNumber;
+            score: z.ZodNumber;
+            targetActivityThreshold: z.ZodNumber;
+            backgroundByDomain: z.ZodArray<z.ZodObject<{
+                domainIndex: z.ZodNumber;
+                meanAbsolute: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    payload: z.ZodObject<{
+        path: z.ZodLiteral<"patch.safetensors">;
+        sha256: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        tensors: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            dtype: z.ZodEnum<{
+                F32: "F32";
+                I64: "I64";
+            }>;
+            shape: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const NeuronTrainingArtifactSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronTrainingArtifact.v1">;
+    method: z.ZodLiteral<"selective_neuron_training">;
+    algorithm: z.ZodObject<{
+        implementation: z.ZodLiteral<"openpond_qwen3_selective_columns_v1">;
+        upstream: z.ZodLiteral<"changjonathanc/neuron-tuning">;
+        revision: z.ZodLiteral<"8a55f3159f735eb0823d7a894f67f632bf568bb3">;
+        license: z.ZodLiteral<"Apache-2.0">;
+        hook: z.ZodLiteral<"mlp.down_proj">;
+        operation: z.ZodLiteral<"output_plus_selected_input_times_delta_v1">;
+        parameterization: z.ZodLiteral<"column_gain_rms_direction_v1">;
+        activityQuantile: z.ZodLiteral<0.9>;
+        backgroundFloor: z.ZodLiteral<0.000001>;
+        gradientSubsetSeed: z.ZodLiteral<0>;
+        optimizer: z.ZodLiteral<"Adam">;
+        betas: z.ZodTuple<[z.ZodLiteral<0.9>, z.ZodLiteral<0.999>], null>;
+        epsilon: z.ZodLiteral<1e-8>;
+        weightDecay: z.ZodLiteral<0>;
+        gradientClipNorm: z.ZodLiteral<1>;
+        batchSize: z.ZodLiteral<1>;
+        parameterDtype: z.ZodLiteral<"float32">;
+        resume: z.ZodLiteral<"unsupported">;
+    }, z.core.$strict>;
+    pins: z.ZodObject<{
+        baseModel: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+            modelId: z.ZodString;
+            revision: z.ZodString;
+            configHash: z.ZodString;
+            weightsHash: z.ZodString;
+            tokenizerHash: z.ZodString;
+            weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+            architecture: z.ZodLiteral<"dense_decoder">;
+            dtype: z.ZodEnum<{
+                bfloat16: "bfloat16";
+                float16: "float16";
+                float32: "float32";
+            }>;
+            quantization: z.ZodLiteral<"none">;
+            adapter: z.ZodNull;
+            hiddenSize: z.ZodNumber;
+            intermediateSizes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+        inputHash: z.ZodString;
+        data: z.ZodObject<{
+            target: z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>;
+            background: z.ZodArray<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+                domain: z.ZodString;
+            }, z.core.$strict>>;
+            preservation: z.ZodNullable<z.ZodObject<{
+                batch: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                examplesSha256: z.ZodString;
+                encodingHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        dataHash: z.ZodString;
+        selectionConfigHash: z.ZodString;
+        trainingConfigHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        parentArtifactHash: z.ZodNull;
+    }, z.core.$strict>;
+    selection: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronTrainingSelectionResult.v1">;
+        modelHash: z.ZodString;
+        dataHash: z.ZodString;
+        selectionConfigHash: z.ZodString;
+        preparedRowsHash: z.ZodString;
+        source: z.ZodEnum<{
+            automatic: "automatic";
+            explicit: "explicit";
+        }>;
+        targetExampleIds: z.ZodArray<z.ZodString>;
+        eligibleCount: z.ZodNumber;
+        entries: z.ZodArray<z.ZodObject<{
+            layer: z.ZodNumber;
+            neuron: z.ZodNumber;
+            targetMeanAbsolute: z.ZodNumber;
+            backgroundMeanAbsolute: z.ZodNumber;
+            backgroundTargetRatio: z.ZodNumber;
+            gradientNorm: z.ZodNumber;
+            score: z.ZodNumber;
+            targetActivityThreshold: z.ZodNumber;
+            backgroundByDomain: z.ZodArray<z.ZodObject<{
+                domainIndex: z.ZodNumber;
+                meanAbsolute: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    payload: z.ZodObject<{
+        path: z.ZodLiteral<"patch.safetensors">;
+        sha256: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        tensors: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            dtype: z.ZodEnum<{
+                F32: "F32";
+                I64: "I64";
+            }>;
+            shape: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type NeuronTrainingArtifact = z.infer<typeof NeuronTrainingArtifactSchema>;
+export declare function parseAndVerifyNeuronTrainingArtifact(raw: unknown, expected: {
+    request: NeuronTrainingRequest;
+    runtimeHash: string;
+}): Promise<{
+    schemaVersion: "openpond.neuronTrainingArtifact.v1";
+    method: "selective_neuron_training";
+    algorithm: {
+        implementation: "openpond_qwen3_selective_columns_v1";
+        upstream: "changjonathanc/neuron-tuning";
+        revision: "8a55f3159f735eb0823d7a894f67f632bf568bb3";
+        license: "Apache-2.0";
+        hook: "mlp.down_proj";
+        operation: "output_plus_selected_input_times_delta_v1";
+        parameterization: "column_gain_rms_direction_v1";
+        activityQuantile: 0.9;
+        backgroundFloor: 0.000001;
+        gradientSubsetSeed: 0;
+        optimizer: "Adam";
+        betas: [0.9, 0.999];
+        epsilon: 1e-8;
+        weightDecay: 0;
+        gradientClipNorm: 1;
+        batchSize: 1;
+        parameterDtype: "float32";
+        resume: "unsupported";
+    };
+    pins: {
+        baseModel: {
+            schemaVersion: "openpond.neuronSteeringModel.v1";
+            modelId: string;
+            revision: string;
+            configHash: string;
+            weightsHash: string;
+            tokenizerHash: string;
+            weightIdentity: "torch_state_dict_sha256_v1";
+            architecture: "dense_decoder";
+            dtype: "bfloat16" | "float16" | "float32";
+            quantization: "none";
+            adapter: null;
+            hiddenSize: number;
+            intermediateSizes: number[];
+        };
+        inputHash: string;
+        data: {
+            target: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+            };
+            background: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+                domain: string;
+            }[];
+            preservation: {
+                batch: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                examplesSha256: string;
+                encodingHash: string;
+            } | null;
+        };
+        dataHash: string;
+        selectionConfigHash: string;
+        trainingConfigHash: string;
+        runtimeHash: string;
+        parentArtifactHash: null;
+    };
+    selection: {
+        schemaVersion: "openpond.neuronTrainingSelectionResult.v1";
+        modelHash: string;
+        dataHash: string;
+        selectionConfigHash: string;
+        preparedRowsHash: string;
+        source: "automatic" | "explicit";
+        targetExampleIds: string[];
+        eligibleCount: number;
+        entries: {
+            layer: number;
+            neuron: number;
+            targetMeanAbsolute: number;
+            backgroundMeanAbsolute: number;
+            backgroundTargetRatio: number;
+            gradientNorm: number;
+            score: number;
+            targetActivityThreshold: number;
+            backgroundByDomain: {
+                domainIndex: number;
+                meanAbsolute: number;
+            }[];
+        }[];
+        contentHash: string;
+    };
+    payload: {
+        path: "patch.safetensors";
+        sha256: string;
+        sizeBytes: number;
+        tensors: {
+            name: string;
+            dtype: "F32" | "I64";
+            shape: number[];
+        }[];
+    };
+    contentHash: string;
+}>;
+//# sourceMappingURL=neuron-training-artifact.d.ts.map

package/dist/types/packages/sdk/src/neuron-training-artifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neuron-training-artifact.d.ts","sourceRoot":"","sources":["../../../../../src/neuron-training-artifact.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACmE,KAAK,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAKnI,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;kBAS/B,CAAC;AACZ,wBAAgB,uBAAuB;;;;;;;;;;;;;;;;;;;EAOtC;AACD,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;kBAKpC,CAAC;AACZ,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM5C,CAAC;AACZ,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAyE,CAAC;AAC1H,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAGhG,wBAAsB,qCAAqC,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;GA2BvG;AACD,eAAO,MAAM,+BAA+B;;;;;;;kBAGjC,CAAC;AACZ,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,6BAA6B;;WAIhD,KAAK;;;;WACP,KAAK;;KAE7C;AACD,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASrC,CAAC;AACZ,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAkE,CAAC;AAC5G,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,wBAAsB,oCAAoC,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE;IAAC,OAAO,EAAE,qBAAqB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAYvI"}

package/dist/types/packages/sdk/src/neuron-training-experiment-draft.d.ts

@@ -0,0 +1,172 @@
+import { z } from "zod";
+import { ModelProjectBaseModelSchema } from "./model-projects.js";
+export declare const SavedNeuronTrainingExperimentSourceSchema: z.ZodObject<{
+    modelProjectId: z.ZodString;
+    versionHash: z.ZodString;
+    artifact: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    modelHash: z.ZodString;
+}, z.core.$strict>;
+export type SavedNeuronTrainingExperimentSource = z.infer<typeof SavedNeuronTrainingExperimentSourceSchema>;
+export declare const NEURON_TRAINING_SELECTION_DEFAULTS: {
+    count: number;
+    span: "prompt" | "reply_prediction" | "reply_start";
+    backgroundStatistic: "max_domains" | "mean_domains";
+    maximumBackgroundTargetRatio: number;
+    gradientExamples: number;
+    explicitCoordinates: {
+        layer: number;
+        neuron: number;
+    }[] | null;
+};
+export declare const NEURON_TRAINING_DEFAULTS: {
+    learningRate: number;
+    maxSteps: number;
+    gradientAccumulationSteps: number;
+    maxSequenceLength: number;
+    preservationWeight: number;
+    preservationExamplesPerStep: number;
+    seed: number;
+    maxDurationSeconds: number;
+    maxCheckpointBytes: number;
+    maximumForwardTokenWork: number;
+};
+export declare const NeuronTrainingSelectionFormDraftSchema: z.ZodObject<{
+    count: z.ZodString;
+    span: z.ZodEnum<{
+        prompt: "prompt";
+        reply_prediction: "reply_prediction";
+        reply_start: "reply_start";
+    }>;
+    backgroundStatistic: z.ZodEnum<{
+        max_domains: "max_domains";
+        mean_domains: "mean_domains";
+    }>;
+    maximumBackgroundTargetRatio: z.ZodString;
+    gradientExamples: z.ZodString;
+    coordinates: z.ZodString;
+}, z.core.$strict>;
+export declare const NeuronTrainingSettingsFormDraftSchema: z.ZodObject<{
+    learningRate: z.ZodString;
+    maxSteps: z.ZodString;
+    gradientAccumulationSteps: z.ZodString;
+    maxSequenceLength: z.ZodString;
+    preservationWeight: z.ZodString;
+    preservationExamplesPerStep: z.ZodString;
+    seed: z.ZodString;
+    maxDurationSeconds: z.ZodString;
+    maxCheckpointBytes: z.ZodString;
+    maximumForwardTokenWork: z.ZodString;
+}, z.core.$strict>;
+export declare const NeuronTrainingInspectionSourceSchema: z.ZodObject<{
+    result: z.ZodObject<{
+        location: z.ZodLiteral<"cloud">;
+        apiOrigin: z.ZodURL;
+        owner: z.ZodObject<{
+            teamId: z.ZodString;
+            actorId: z.ZodString;
+        }, z.core.$strict>;
+        projectId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodLiteral<"managed_modification_result">;
+        executionId: z.ZodString;
+        method: z.ZodEnum<{
+            inspect_activations: "inspect_activations";
+            neuron_steering: "neuron_steering";
+        }>;
+        inputHash: z.ZodString;
+        runtimeHash: z.ZodString;
+        resultHash: z.ZodString;
+    }, z.core.$strict>;
+    modelHash: z.ZodString;
+}, z.core.$strict>;
+/** Selection provenance is reauthorized by the compiler; this reference grants
+ * no access to a capture and cannot replace reviewed target/background data. */
+export declare const NeuronTrainingExperimentFormDraftSchema: z.ZodObject<{
+    baseModel: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.baseModelPreference.v1">;
+        modelId: z.ZodString;
+        revision: z.ZodNullable<z.ZodString>;
+        tokenizerRevision: z.ZodNullable<z.ZodString>;
+        chatTemplateHash: z.ZodNullable<z.ZodString>;
+        modelAssetId: z.ZodNullable<z.ZodString>;
+        source: z.ZodEnum<{
+            builtin: "builtin";
+            local: "local";
+            managed: "managed";
+        }>;
+    }, z.core.$strict>>;
+    targetBatch: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>>;
+    background: z.ZodArray<z.ZodObject<{
+        domain: z.ZodString;
+        batch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    preservationBatch: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>>;
+    name: z.ZodString;
+    maximumSpendUsd: z.ZodString;
+    selection: z.ZodObject<{
+        count: z.ZodString;
+        span: z.ZodEnum<{
+            prompt: "prompt";
+            reply_prediction: "reply_prediction";
+            reply_start: "reply_start";
+        }>;
+        backgroundStatistic: z.ZodEnum<{
+            max_domains: "max_domains";
+            mean_domains: "mean_domains";
+        }>;
+        maximumBackgroundTargetRatio: z.ZodString;
+        gradientExamples: z.ZodString;
+        coordinates: z.ZodString;
+    }, z.core.$strict>;
+    training: z.ZodObject<{
+        learningRate: z.ZodString;
+        maxSteps: z.ZodString;
+        gradientAccumulationSteps: z.ZodString;
+        maxSequenceLength: z.ZodString;
+        preservationWeight: z.ZodString;
+        preservationExamplesPerStep: z.ZodString;
+        seed: z.ZodString;
+        maxDurationSeconds: z.ZodString;
+        maxCheckpointBytes: z.ZodString;
+        maximumForwardTokenWork: z.ZodString;
+    }, z.core.$strict>;
+    parentArtifact: z.ZodNull;
+    inspectionSource: z.ZodOptional<z.ZodObject<{
+        result: z.ZodObject<{
+            location: z.ZodLiteral<"cloud">;
+            apiOrigin: z.ZodURL;
+            owner: z.ZodObject<{
+                teamId: z.ZodString;
+                actorId: z.ZodString;
+            }, z.core.$strict>;
+            projectId: z.ZodNullable<z.ZodString>;
+            kind: z.ZodLiteral<"managed_modification_result">;
+            executionId: z.ZodString;
+            method: z.ZodEnum<{
+                inspect_activations: "inspect_activations";
+                neuron_steering: "neuron_steering";
+            }>;
+            inputHash: z.ZodString;
+            runtimeHash: z.ZodString;
+            resultHash: z.ZodString;
+        }, z.core.$strict>;
+        modelHash: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type NeuronTrainingExperimentFormDraft = z.infer<typeof NeuronTrainingExperimentFormDraftSchema>;
+export declare function newNeuronTrainingExperimentForm(baseModel?: z.infer<typeof ModelProjectBaseModelSchema> | null): NeuronTrainingExperimentFormDraft;
+//# sourceMappingURL=neuron-training-experiment-draft.d.ts.map

package/dist/types/packages/sdk/src/neuron-training-experiment-draft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neuron-training-experiment-draft.d.ts","sourceRoot":"","sources":["../../../../../src/neuron-training-experiment-draft.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,2BAA2B,EAAkC,MAAM,qBAAqB,CAAC;AAKlG,eAAO,MAAM,yCAAyC;;;;;;;;kBAG3C,CAAC;AACZ,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAC5G,eAAO,MAAM,kCAAkC;;;;;;;;;;CAG7C,CAAC;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;CAInC,CAAC;AAEH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;kBAMxC,CAAC;AACZ,eAAO,MAAM,qCAAqC;;;;;;;;;;;kBAIvC,CAAC;AACZ,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;kBAGtC,CAAC;AACZ;gFACgF;AAChF,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAOzC,CAAC;AACZ,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,CAAC;AACxG,wBAAgB,+BAA+B,CAAC,SAAS,GAAE,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,GAAG,IAAW,GAAG,iCAAiC,CASvJ"}