@spiky-panda/core 0.1.0

package/dist/neuralnetwork/ann/mlp/training/mlp.optimizers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mlp.optimizers.js","sourceRoot":"","sources":["../../../../../src/neuralnetwork/ann/mlp/training/mlp.optimizers.ts"],"names":[],"mappings":"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","sourcesContent":["/// <summary>\r\n/// Stochastic Gradient Descent (SGD) optimizer\r\n\r\nimport { IBackpropSynapseContext, IOptimizer } from \"./mlp.training.interfaces\";\r\n\r\nexport class Optimizers {\r\n    /// </summary>\r\n    public static SGD = (): IOptimizer => ({\r\n        apply(synapse, lr, gradient, ctx) {\r\n            const bag = (synapse.bag ??= { gradient: gradient }) as IBackpropSynapseContext;\r\n\r\n            bag.gradient = gradient;\r\n            bag.weightDelta = -lr * gradient;\r\n\r\n            synapse.weight += bag.weightDelta;\r\n        },\r\n    });\r\n\r\n    /// <summary>\r\n    /// SGD with Momentum optimizer\r\n    /// </summary>\r\n    public static MomentumSGD = (momentum: number): IOptimizer => ({\r\n        apply(synapse, lr, gradient, ctx) {\r\n            const bag = (synapse.bag ??= { gradient: gradient }) as IBackpropSynapseContext;\r\n\r\n            bag.gradient = gradient;\r\n            bag.velocity ??= 0;\r\n\r\n            bag.velocity = momentum * bag.velocity - lr * gradient;\r\n            bag.weightDelta = bag.velocity;\r\n\r\n            synapse.weight += bag.weightDelta;\r\n        },\r\n    });\r\n\r\n    /// <summary>\r\n    /// Nesterov Accelerated Gradient (NAG) optimizer\r\n    /// </summary>\r\n    public static NAG = (momentum: number = 0.9): IOptimizer => ({\r\n        apply(synapse, lr, gradient, ctx) {\r\n            const bag = (synapse.bag ??= { gradient: gradient }) as IBackpropSynapseContext;\r\n\r\n            bag.gradient = gradient;\r\n            bag.velocity ??= 0;\r\n\r\n            bag.velocity = momentum * bag.velocity - lr * gradient;\r\n            bag.weightDelta = bag.velocity;\r\n\r\n            synapse.weight += bag.weightDelta;\r\n            bag.prelookedWeight = undefined;\r\n        },\r\n    });\r\n\r\n    /// <summary>\r\n    /// Adam optimizer with bias correction\r\n    /// </summary>\r\n    public static Adam = (beta1 = 0.9, beta2 = 0.999, epsilon = 1e-8): IOptimizer => ({\r\n        apply(synapse, lr, gradient, ctx) {\r\n            const bag = (synapse.bag ??= { gradient: gradient }) as IBackpropSynapseContext;\r\n            const t = ctx.iteration + 1;\r\n\r\n            bag.gradient = gradient;\r\n            bag.m ??= 0;\r\n            bag.v ??= 0;\r\n\r\n            bag.m = beta1 * bag.m + (1 - beta1) * gradient;\r\n            bag.v = beta2 * bag.v + (1 - beta2) * gradient * gradient;\r\n\r\n            const mHat = bag.m / (1 - Math.pow(beta1, t));\r\n            const vHat = bag.v / (1 - Math.pow(beta2, t));\r\n\r\n            bag.weightDelta = (-lr * mHat) / (Math.sqrt(vHat) + epsilon);\r\n            synapse.weight += bag.weightDelta;\r\n        },\r\n    });\r\n}\r\n"]}

package/dist/neuralnetwork/ann/mlp/training/mlp.training.d.ts

@@ -0,0 +1,22 @@
+import { IMlpGraph } from "../mlp.interfaces";
+import { MLPInferenceRuntime } from "../mlp.inference";
+import { ILossFunction, IOptimizer, ITrainingContext } from "./mlp.training.interfaces";
+export declare class MLPTrainingRuntime {
+    readonly graph: IMlpGraph;
+    readonly runtime: MLPInferenceRuntime;
+    readonly lossFn: ILossFunction;
+    readonly learningRate: number;
+    readonly optimizer: IOptimizer;
+    private context;
+    constructor(graph: IMlpGraph, runtime: MLPInferenceRuntime, lossFn: ILossFunction, learningRate: number, optimizer: IOptimizer);
+    trainStep(inputs: number[], expected: number[]): number;
+    /**
+     * Performs backpropagation and stores gradients in neuron and synapse bags.
+     * This version properly propagates gradients through all layers of the network.
+     */
+    private _backpropagate;
+    private _applyGradients;
+    get trainingContext(): Readonly<ITrainingContext>;
+    clearContext(): void;
+    deleteContext(): void;
+}

package/dist/neuralnetwork/ann/mlp/training/mlp.training.interfaces.d.ts

@@ -0,0 +1,27 @@
+import { IInferenceNeuronContext, IMlpSynapse } from "../mlp.interfaces";
+export interface IBackpropNeuronContext extends IInferenceNeuronContext {
+    error: number;
+    gradient?: number;
+}
+export interface IBackpropSynapseContext {
+    gradient: number;
+    velocity?: number;
+    m?: number;
+    v?: number;
+    prelookedWeight?: number;
+    weightDelta?: number;
+}
+export interface ILossFunction {
+    loss(output: number, expected: number): number;
+    dLoss(output: number, expected: number): number;
+}
+export interface IOptimizer {
+    apply(synapse: IMlpSynapse, learningRate: number, gradient: number, context: ITrainingContext): void;
+}
+export interface ITrainingContext {
+    iteration: number;
+    epoch?: number;
+    batchIndex?: number;
+    batchSize?: number;
+    loss?: number;
+}

package/dist/neuralnetwork/ann/mlp/training/mlp.training.interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mlp.training.interfaces.js.map

package/dist/neuralnetwork/ann/mlp/training/mlp.training.interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mlp.training.interfaces.js","sourceRoot":"","sources":["../../../../../src/neuralnetwork/ann/mlp/training/mlp.training.interfaces.ts"],"names":[],"mappings":"","sourcesContent":["import { IInferenceNeuronContext, IMlpSynapse } from \"../mlp.interfaces\";\r\n\r\nexport interface IBackpropNeuronContext extends IInferenceNeuronContext {\r\n    error: number;\r\n    gradient?: number;\r\n}\r\n\r\n/// <summary>\r\n/// Represents the runtime training context for a synapse during backpropagation.\r\n/// </summary>\r\nexport interface IBackpropSynapseContext {\r\n    /// <summary>Gradient of the loss with respect to the synaptic weight</summary>\r\n    gradient: number;\r\n\r\n    /// <summary>Velocity term used in momentum-based optimizers (e.g., SGD with momentum, NAG)</summary>\r\n    velocity?: number;\r\n\r\n    /// <summary>First moment estimate (mean of gradients), used by the Adam optimizer</summary>\r\n    m?: number;\r\n\r\n    /// <summary>Second moment estimate (uncentered variance of gradients), used by the Adam optimizer</summary>\r\n    v?: number;\r\n\r\n    /// <summary>Anticipated weight used during the forward pass (for NAG optimizers)</summary>\r\n    prelookedWeight?: number;\r\n\r\n    /// <summary>Suggested weight update (usually learningRate × gradient), may be applied after batch or optimization step</summary>\r\n    weightDelta?: number;\r\n}\r\n\r\nexport interface ILossFunction {\r\n    loss(output: number, expected: number): number;\r\n    dLoss(output: number, expected: number): number;\r\n}\r\n\r\n/// <summary>\r\n/// Defines a strategy for applying weight updates to a synapse during training.\r\n/// </summary>\r\nexport interface IOptimizer {\r\n    /// <summary>Applies the weight update based on gradient and internal context</summary>\r\n    apply(synapse: IMlpSynapse, learningRate: number, gradient: number, context: ITrainingContext): void;\r\n}\r\nexport interface ITrainingContext {\r\n    iteration: number;\r\n    epoch?: number;\r\n    batchIndex?: number;\r\n    batchSize?: number;\r\n    loss?: number;\r\n}\r\n"]}

package/dist/neuralnetwork/ann/mlp/training/mlp.training.js

@@ -0,0 +1,107 @@
+import { MLPRuntimeUtils } from "../mlp.runtime.utils";
+/// <summary>
+/// Handles backpropagation and weight updates for an MLP graph.
+/// </summary>
+export class MLPTrainingRuntime {
+    constructor(graph, runtime, lossFn, learningRate, optimizer) {
+        this.graph = graph;
+        this.runtime = runtime;
+        this.lossFn = lossFn;
+        this.learningRate = learningRate;
+        this.optimizer = optimizer;
+        this.context = { iteration: 0 };
+    }
+    /// <summary>
+    /// Runs a forward + backward pass and updates weights.
+    /// </summary>
+    trainStep(inputs, expected) {
+        const outputs = this.runtime.run(inputs);
+        const loss = this._backpropagate(outputs, expected);
+        this._applyGradients();
+        this.context.iteration++;
+        return loss;
+    }
+    /**
+     * Performs backpropagation and stores gradients in neuron and synapse bags.
+     * This version properly propagates gradients through all layers of the network.
+     */
+    _backpropagate(outputs, expected) {
+        let totalLoss = 0;
+        // STEP 1 – Output layer: compute error and gradient
+        for (let i = 0; i < this.graph.outputs.length; i++) {
+            const neuron = this.graph.outputs[i];
+            const y = expected[i];
+            const bag = (neuron.bag ??= {});
+            const output = bag.activation;
+            const loss = this.lossFn.loss(output, y);
+            totalLoss += loss;
+            const dLoss = this.lossFn.dLoss(output, y); // ∂L/∂o
+            const activationPrime = (neuron.activationFn ?? this.runtime.mainActivation).derivative;
+            bag.gradient = dLoss * activationPrime(output); // ∂L/∂z
+            bag.error = y - output;
+        }
+        // STEP 2 – Hidden layer: compute gradients from output layer
+        for (let i = this.graph.hiddens.length - 1; i >= 0; i--) {
+            const neuron = this.graph.hiddens[i];
+            const bag = (neuron.bag ??= {});
+            const activation = bag.activation;
+            const activationPrime = (neuron.activationFn ?? this.runtime.mainActivation).derivative;
+            let downstreamSum = 0;
+            for (const syn of neuron.onsc() ?? []) {
+                const to = syn.ofin;
+                const toBag = to.bag;
+                downstreamSum += syn.weight * (toBag?.gradient ?? 0);
+            }
+            bag.gradient = activationPrime(activation) * downstreamSum;
+        }
+        // STEP 3 – Accumulate gradient on all synapses
+        for (const syn of this.graph.links) {
+            const from = syn.oini;
+            const to = syn.ofin;
+            const fromBag = from.bag;
+            const toBag = to.bag;
+            const synBag = (syn.bag ??= {});
+            synBag.gradient = (toBag?.gradient ?? 0) * (fromBag?.activation ?? 0);
+        }
+        return totalLoss;
+    }
+    /// <summary>
+    /// Applies weight updates using the selected optimizer.
+    /// </summary>
+    _applyGradients() {
+        // Update synapse weights
+        for (const synapse of this.graph.links) {
+            const ctx = synapse.bag;
+            if (ctx?.gradient !== undefined) {
+                this.optimizer.apply(synapse, this.learningRate, ctx.gradient, this.context);
+            }
+        }
+        // Update neuron biases
+        for (const neuron of this.graph.nodes) {
+            const ctx = neuron.bag;
+            if (ctx?.gradient !== undefined) {
+                neuron.bias -= this.learningRate * ctx.gradient;
+            }
+        }
+    }
+    get trainingContext() {
+        return this.context;
+    }
+    clearContext() {
+        for (const neuron of this.graph.nodes) {
+            MLPRuntimeUtils.resetBackpropContext(neuron);
+        }
+        for (const synapse of this.graph.links) {
+            MLPRuntimeUtils.resetBackpropContext(synapse);
+        }
+    }
+    deleteContext() {
+        for (const neuron of this.graph.nodes) {
+            neuron.bag = undefined;
+        }
+        for (const synapse of this.graph.links) {
+            synapse.bag = undefined;
+        }
+    }
+}
+//# sourceMappingURL=mlp.training.js.map

package/dist/neuralnetwork/ann/mlp/training/mlp.training.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mlp.training.js","sourceRoot":"","sources":["../../../../../src/neuralnetwork/ann/mlp/training/mlp.training.ts"],"names":[],"mappings":"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","sourcesContent":["import { IMlpGraph, IMlpNeuron, IMlpSynapse } from \"../mlp.interfaces\";\r\nimport { MLPInferenceRuntime } from \"../mlp.inference\";\r\nimport { IBackpropNeuronContext, IBackpropSynapseContext, ILossFunction, IOptimizer, ITrainingContext } from \"./mlp.training.interfaces\";\r\nimport { MLPRuntimeUtils } from \"../mlp.runtime.utils\";\r\n\r\n/// <summary>\r\n/// Handles backpropagation and weight updates for an MLP graph.\r\n/// </summary>\r\nexport class MLPTrainingRuntime {\r\n    private context: ITrainingContext = { iteration: 0 };\r\n\r\n    constructor(\r\n        public readonly graph: IMlpGraph,\r\n        public readonly runtime: MLPInferenceRuntime,\r\n        public readonly lossFn: ILossFunction,\r\n        public readonly learningRate: number,\r\n        public readonly optimizer: IOptimizer\r\n    ) {}\r\n\r\n    /// <summary>\r\n    /// Runs a forward + backward pass and updates weights.\r\n    /// </summary>\r\n    public trainStep(inputs: number[], expected: number[]): number {\r\n        const outputs = this.runtime.run(inputs);\r\n        const loss = this._backpropagate(outputs, expected);\r\n        this._applyGradients();\r\n        this.context.iteration++;\r\n        return loss;\r\n    }\r\n\r\n    /**\r\n     * Performs backpropagation and stores gradients in neuron and synapse bags.\r\n     * This version properly propagates gradients through all layers of the network.\r\n     */\r\n    private _backpropagate(outputs: number[], expected: number[]): number {\r\n        let totalLoss = 0;\r\n\r\n        // STEP 1 – Output layer: compute error and gradient\r\n        for (let i = 0; i < this.graph.outputs.length; i++) {\r\n            const neuron = this.graph.outputs[i] as IMlpNeuron;\r\n            const y = expected[i];\r\n\r\n            const bag = (neuron.bag ??= {}) as IBackpropNeuronContext;\r\n            const output = bag.activation;\r\n\r\n            const loss = this.lossFn.loss(output, y);\r\n            totalLoss += loss;\r\n\r\n            const dLoss = this.lossFn.dLoss(output, y); // ∂L/∂o\r\n            const activationPrime = (neuron.activationFn ?? this.runtime.mainActivation).derivative;\r\n\r\n            bag.gradient = dLoss * activationPrime(output); // ∂L/∂z\r\n            bag.error = y - output;\r\n        }\r\n\r\n        // STEP 2 – Hidden layer: compute gradients from output layer\r\n        for (let i = this.graph.hiddens.length - 1; i >= 0; i--) {\r\n            const neuron = this.graph.hiddens[i] as IMlpNeuron;\r\n            const bag = (neuron.bag ??= {}) as IBackpropNeuronContext;\r\n            const activation = bag.activation;\r\n            const activationPrime = (neuron.activationFn ?? this.runtime.mainActivation).derivative;\r\n\r\n            let downstreamSum = 0;\r\n            for (const syn of neuron.onsc<IMlpSynapse>() ?? []) {\r\n                const to = syn.ofin as IMlpNeuron;\r\n                const toBag = to.bag as IBackpropNeuronContext;\r\n                downstreamSum += syn.weight * (toBag?.gradient ?? 0);\r\n            }\r\n\r\n            bag.gradient = activationPrime(activation) * downstreamSum;\r\n        }\r\n\r\n        // STEP 3 – Accumulate gradient on all synapses\r\n        for (const syn of this.graph.links) {\r\n            const from = syn.oini as IMlpNeuron;\r\n            const to = syn.ofin as IMlpNeuron;\r\n\r\n            const fromBag = from.bag as IBackpropNeuronContext;\r\n            const toBag = to.bag as IBackpropNeuronContext;\r\n\r\n            const synBag = (syn.bag ??= {}) as IBackpropSynapseContext;\r\n            synBag.gradient = (toBag?.gradient ?? 0) * (fromBag?.activation ?? 0);\r\n        }\r\n\r\n        return totalLoss;\r\n    }\r\n\r\n    /// <summary>\r\n    /// Applies weight updates using the selected optimizer.\r\n    /// </summary>\r\n    private _applyGradients(): void {\r\n        // Update synapse weights\r\n        for (const synapse of this.graph.links) {\r\n            const ctx = synapse.bag as IBackpropSynapseContext;\r\n            if (ctx?.gradient !== undefined) {\r\n                this.optimizer.apply(synapse, this.learningRate, ctx.gradient, this.context);\r\n            }\r\n        }\r\n\r\n        // Update neuron biases\r\n        for (const neuron of this.graph.nodes) {\r\n            const ctx = neuron.bag as IBackpropNeuronContext;\r\n            if (ctx?.gradient !== undefined) {\r\n                neuron.bias -= this.learningRate * ctx.gradient;\r\n            }\r\n        }\r\n    }\r\n    get trainingContext(): Readonly<ITrainingContext> {\r\n        return this.context;\r\n    }\r\n\r\n    public clearContext() {\r\n        for (const neuron of this.graph.nodes) {\r\n            MLPRuntimeUtils.resetBackpropContext(neuron);\r\n        }\r\n        for (const synapse of this.graph.links) {\r\n            MLPRuntimeUtils.resetBackpropContext(synapse);\r\n        }\r\n    }\r\n\r\n    public deleteContext() {\r\n        for (const neuron of this.graph.nodes) {\r\n            neuron.bag = undefined;\r\n        }\r\n        for (const synapse of this.graph.links) {\r\n            synapse.bag = undefined;\r\n        }\r\n    }\r\n}\r\n"]}

package/dist/neuralnetwork/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./ann";
+export * from "./snn";
+export * from "./nn.weights";
+export * from "./nn.interfaces";
+export * from "./nn.interfaces.builder";
+export * from "./nn.synapse";
+export * from "./nn.neuron";
+export * from "./nn.builders";

package/dist/neuralnetwork/index.js

@@ -0,0 +1,9 @@
+export * from "./ann";
+export * from "./snn";
+export * from "./nn.weights";
+export * from "./nn.interfaces";
+export * from "./nn.interfaces.builder";
+export * from "./nn.synapse";
+export * from "./nn.neuron";
+export * from "./nn.builders";
+//# sourceMappingURL=index.js.map

package/dist/neuralnetwork/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/neuralnetwork/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC","sourcesContent":["export * from \"./ann\";\r\nexport * from \"./snn\";\r\nexport * from \"./nn.weights\";\r\nexport * from \"./nn.interfaces\";\r\nexport * from \"./nn.interfaces.builder\";\r\nexport * from \"./nn.synapse\";\r\nexport * from \"./nn.neuron\";\r\nexport * from \"./nn.builders\";\r\n"]}

package/dist/neuralnetwork/nn.builders.d.ts

@@ -0,0 +1,21 @@
+import { LinkBuilder } from "../graph";
+import { ILayer, ILayerConnection, INeuron, ISynapse, LayerConnectionType } from "./nn.interfaces";
+import { ILayerConnectionBuilder, ISynapseBuilder } from "./nn.interfaces.builder";
+import { IWeightInitializer } from "./nn.weights";
+export declare class SynapseBuilder extends LinkBuilder implements ISynapseBuilder {
+    private _weight;
+    constructor();
+    withWeight(weight: number): ISynapseBuilder;
+    build(...args: any[]): ISynapse;
+}
+export declare class LayerConnectionBuilder implements ILayerConnectionBuilder {
+    private _type;
+    private _weightInitializer;
+    private _synapseBuilder;
+    withType(type: LayerConnectionType): ILayerConnectionBuilder;
+    withWeightInitializer(initializer: IWeightInitializer): ILayerConnectionBuilder;
+    withSynapseBuilder(builder: SynapseBuilder): ILayerConnectionBuilder;
+    build(source: ILayer<INeuron>, target: ILayer<INeuron>): ILayerConnection<ISynapse> | undefined;
+    private buildFullConnection;
+    private buildOneToOneConnection;
+}

package/dist/neuralnetwork/nn.builders.js

@@ -0,0 +1,71 @@
+import { LinkBuilder } from "../graph";
+import { LayerConnectionType } from "./nn.interfaces";
+import { Synapse } from "./nn.synapse";
+import { Uniform } from "./nn.weights";
+export class SynapseBuilder extends LinkBuilder {
+    constructor() {
+        super();
+        this._weight = 0.0; // Default weight
+        this.withType(Synapse);
+    }
+    withWeight(weight) {
+        this._weight = weight;
+        return this;
+    }
+    build(...args) {
+        const synapse = super.build(...args);
+        synapse.weight = this._weight;
+        return synapse;
+    }
+}
+export class LayerConnectionBuilder {
+    constructor() {
+        this._type = LayerConnectionType.FullyConnected; // Default connection type
+        this._weightInitializer = new Uniform(); // Default weight initializer
+        this._synapseBuilder = new SynapseBuilder(); // Default synapse builder
+    }
+    withType(type) {
+        this._type = type;
+        return this;
+    }
+    withWeightInitializer(initializer) {
+        this._weightInitializer = initializer;
+        return this;
+    }
+    withSynapseBuilder(builder) {
+        this._synapseBuilder = builder;
+        return this;
+    }
+    build(source, target) {
+        switch (this._type) {
+            case LayerConnectionType.FullyConnected:
+                return this.buildFullConnection(source, target);
+            case LayerConnectionType.OneToOne:
+                return this.buildOneToOneConnection(source, target);
+            default:
+                return undefined;
+        }
+    }
+    buildFullConnection(source, target) {
+        const synapses = [];
+        for (const sourceNeuron of source) {
+            for (const targetNeuron of target) {
+                const synapse = this._synapseBuilder.withWeight(this._weightInitializer.next()).withFrom(sourceNeuron).withTo(targetNeuron).build();
+                synapses.push(synapse);
+            }
+        }
+        return synapses;
+    }
+    buildOneToOneConnection(source, target) {
+        if (source.length !== target.length) {
+            throw new Error("Source and target layers must have the same number of neurons for one-to-one connection.");
+        }
+        const synapses = [];
+        for (let i = 0; i < source.length; i++) {
+            const synapse = this._synapseBuilder.withWeight(this._weightInitializer.next()).withFrom(source[i]).withTo(target[i]).build();
+            synapses.push(synapse);
+        }
+        return synapses;
+    }
+}
+//# sourceMappingURL=nn.builders.js.map

package/dist/neuralnetwork/nn.builders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nn.builders.js","sourceRoot":"","sources":["../../src/neuralnetwork/nn.builders.ts"],"names":[],"mappings":"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","sourcesContent":["import { LinkBuilder } from \"../graph\";\r\nimport { ILayer, ILayerConnection, INeuron, ISynapse, LayerConnectionType } from \"./nn.interfaces\";\r\nimport { ILayerConnectionBuilder, ISynapseBuilder } from \"./nn.interfaces.builder\";\r\nimport { Synapse } from \"./nn.synapse\";\r\nimport { IWeightInitializer, Uniform } from \"./nn.weights\";\r\n\r\nexport class SynapseBuilder extends LinkBuilder implements ISynapseBuilder {\r\n    private _weight: number = 0.0; // Default weight\r\n\r\n    public constructor() {\r\n        super();\r\n        this.withType(Synapse);\r\n    }\r\n\r\n    public withWeight(weight: number): ISynapseBuilder {\r\n        this._weight = weight;\r\n        return this;\r\n    }\r\n\r\n    public build(...args: any[]): ISynapse {\r\n        const synapse = super.build(...args) as ISynapse;\r\n        synapse.weight = this._weight;\r\n        return synapse;\r\n    }\r\n}\r\n\r\nexport class LayerConnectionBuilder implements ILayerConnectionBuilder {\r\n    private _type: LayerConnectionType = LayerConnectionType.FullyConnected; // Default connection type\r\n    private _weightInitializer: IWeightInitializer = new Uniform(); // Default weight initializer\r\n    private _synapseBuilder: SynapseBuilder = new SynapseBuilder(); // Default synapse builder\r\n\r\n    public withType(type: LayerConnectionType): ILayerConnectionBuilder {\r\n        this._type = type;\r\n        return this;\r\n    }\r\n\r\n    public withWeightInitializer(initializer: IWeightInitializer): ILayerConnectionBuilder {\r\n        this._weightInitializer = initializer;\r\n        return this;\r\n    }\r\n\r\n    public withSynapseBuilder(builder: SynapseBuilder): ILayerConnectionBuilder {\r\n        this._synapseBuilder = builder;\r\n        return this;\r\n    }\r\n\r\n    build(source: ILayer<INeuron>, target: ILayer<INeuron>): ILayerConnection<ISynapse> | undefined {\r\n        switch (this._type) {\r\n            case LayerConnectionType.FullyConnected:\r\n                return this.buildFullConnection(source, target);\r\n            case LayerConnectionType.OneToOne:\r\n                return this.buildOneToOneConnection(source, target);\r\n            default:\r\n                return undefined;\r\n        }\r\n    }\r\n\r\n    private buildFullConnection(source: ILayer<INeuron>, target: ILayer<INeuron>): ILayerConnection<ISynapse> {\r\n        const synapses: Array<ISynapse> = [];\r\n        for (const sourceNeuron of source) {\r\n            for (const targetNeuron of target) {\r\n                const synapse = this._synapseBuilder.withWeight(this._weightInitializer.next()).withFrom(sourceNeuron).withTo(targetNeuron).build() as ISynapse;\r\n                synapses.push(synapse);\r\n            }\r\n        }\r\n        return synapses;\r\n    }\r\n\r\n    private buildOneToOneConnection(source: ILayer<INeuron>, target: ILayer<INeuron>): ILayerConnection<ISynapse> | undefined {\r\n        if (source.length !== target.length) {\r\n            throw new Error(\"Source and target layers must have the same number of neurons for one-to-one connection.\");\r\n        }\r\n        const synapses: ILayerConnection<ISynapse> = [];\r\n        for (let i = 0; i < source.length; i++) {\r\n            const synapse = this._synapseBuilder.withWeight(this._weightInitializer.next()).withFrom(source[i]).withTo(target[i]).build() as ISynapse;\r\n            synapses.push(synapse);\r\n        }\r\n        return synapses;\r\n    }\r\n}\r\n"]}

package/dist/neuralnetwork/nn.interfaces.builder.d.ts

@@ -0,0 +1,16 @@
+import { ILinkBuilder } from "../graph";
+import { SynapseBuilder } from "./nn.builders";
+import { ILayer, ILayerConnection, INeuron, ISynapse, LayerConnectionType } from "./nn.interfaces";
+import { IWeightInitializer } from "./nn.weights";
+export interface ISynapseBuilder extends ILinkBuilder {
+    withWeight(weight: number): ISynapseBuilder;
+}
+export interface ISynapseBuilderConstructor<T extends ISynapseBuilder> {
+    new (weight?: number): T;
+}
+export interface ILayerConnectionBuilder {
+    withType(type: LayerConnectionType): ILayerConnectionBuilder;
+    withWeightInitializer(initializer: IWeightInitializer): ILayerConnectionBuilder;
+    withSynapseBuilder(builder: SynapseBuilder): ILayerConnectionBuilder;
+    build(source: ILayer<INeuron>, target: ILayer<INeuron>): ILayerConnection<ISynapse> | undefined;
+}

package/dist/neuralnetwork/nn.interfaces.builder.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=nn.interfaces.builder.js.map

package/dist/neuralnetwork/nn.interfaces.builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nn.interfaces.builder.js","sourceRoot":"","sources":["../../src/neuralnetwork/nn.interfaces.builder.ts"],"names":[],"mappings":"","sourcesContent":["import { ILinkBuilder } from \"../graph\";\r\nimport { SynapseBuilder } from \"./nn.builders\";\r\nimport { ILayer, ILayerConnection, INeuron, ISynapse, LayerConnectionType } from \"./nn.interfaces\";\r\nimport { IWeightInitializer } from \"./nn.weights\";\r\n\r\nexport interface ISynapseBuilder extends ILinkBuilder {\r\n    withWeight(weight: number): ISynapseBuilder;\r\n}\r\n\r\nexport interface ISynapseBuilderConstructor<T extends ISynapseBuilder> {\r\n    new (weight?: number): T;\r\n}\r\n\r\nexport interface ILayerConnectionBuilder {\r\n    withType(type: LayerConnectionType): ILayerConnectionBuilder;\r\n    withWeightInitializer(initializer: IWeightInitializer): ILayerConnectionBuilder;\r\n    withSynapseBuilder(builder: SynapseBuilder): ILayerConnectionBuilder;\r\n    build(source: ILayer<INeuron>, target: ILayer<INeuron>): ILayerConnection<ISynapse> | undefined;\r\n}\r\n"]}

package/dist/neuralnetwork/nn.interfaces.d.ts

@@ -0,0 +1,16 @@
+import { ILinkSet, INode, INodeSet, IOlink } from "../graph";
+export interface INeuron extends INode {
+    reset(): void;
+}
+export interface ILayer<N extends INeuron> extends INodeSet<N> {
+}
+export interface ILayerConnection<L extends ISynapse> extends ILinkSet<L> {
+}
+export declare enum LayerConnectionType {
+    FullyConnected = "fully_connected",
+    OneToOne = "one_to_one",
+    Unknown = "unknown"
+}
+export interface ISynapse extends IOlink {
+    weight: number;
+}

package/dist/neuralnetwork/nn.interfaces.js

@@ -0,0 +1,18 @@
+/// <summary>
+/// Describes how two neural layers are connected.
+/// </summary>
+export var LayerConnectionType;
+(function (LayerConnectionType) {
+    /// <summary>
+    /// Every neuron in the source layer is connected to every neuron in the target layer.
+    /// This is the standard connection in most MLP architectures.
+    /// </summary>
+    LayerConnectionType["FullyConnected"] = "fully_connected";
+    /// <summary>
+    /// Each neuron in the source layer is connected to the neuron with the same index in the target layer.
+    /// Requires source and target layers to have the same number of neurons.
+    /// </summary>
+    LayerConnectionType["OneToOne"] = "one_to_one";
+    LayerConnectionType["Unknown"] = "unknown";
+})(LayerConnectionType || (LayerConnectionType = {}));
+//# sourceMappingURL=nn.interfaces.js.map

package/dist/neuralnetwork/nn.interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nn.interfaces.js","sourceRoot":"","sources":["../../src/neuralnetwork/nn.interfaces.ts"],"names":[],"mappings":"AAoBA,aAAa;AACb,kDAAkD;AAClD,cAAc;AACd,MAAM,CAAN,IAAY,mBAcX;AAdD,WAAY,mBAAmB;IAC3B,aAAa;IACb,sFAAsF;IACtF,8DAA8D;IAC9D,cAAc;IACd,yDAAkC,CAAA;IAElC,aAAa;IACb,uGAAuG;IACvG,yEAAyE;IACzE,cAAc;IACd,8CAAuB,CAAA;IAEvB,0CAAmB,CAAA;AACvB,CAAC,EAdW,mBAAmB,KAAnB,mBAAmB,QAc9B","sourcesContent":["import { ILinkSet, INode, INodeSet, IOlink } from \"../graph\";\r\n\r\n\r\n\r\n/// <summary>\r\n/// Represents a generic neuron (node) in a neural network.\r\n/// This interface is extended by specific neuron types (e.g., spiking, activation-based).\r\n/// </summary>\r\nexport interface INeuron extends INode {\r\n    /// <summary>Resets the neuron to its initial state</summary>\r\n    reset(): void;\r\n}\r\n\r\n/// <summary>\r\n/// Represents a Layer in a neural network.\r\n/// </summary>\r\nexport interface ILayer<N extends INeuron> extends INodeSet<N> {}\r\n\r\nexport interface ILayerConnection<L extends ISynapse> extends ILinkSet<L> {}\r\n\r\n/// <summary>\r\n/// Describes how two neural layers are connected.\r\n/// </summary>\r\nexport enum LayerConnectionType {\r\n    /// <summary>\r\n    /// Every neuron in the source layer is connected to every neuron in the target layer.\r\n    /// This is the standard connection in most MLP architectures.\r\n    /// </summary>\r\n    FullyConnected = \"fully_connected\",\r\n\r\n    /// <summary>\r\n    /// Each neuron in the source layer is connected to the neuron with the same index in the target layer.\r\n    /// Requires source and target layers to have the same number of neurons.\r\n    /// </summary>\r\n    OneToOne = \"one_to_one\",\r\n\r\n    Unknown = \"unknown\",\r\n}\r\n\r\n/// <summary>\r\n/// Represents a synapse (link) between two neurons in a network.\r\n/// This interface is extended by specific synapse types (e.g., with weights, delays, STDP).\r\n/// </summary>\r\nexport interface ISynapse extends IOlink {\r\n    /// <summary>Synaptic weight</summary>\r\n    weight: number;\r\n}\r\n"]}

package/dist/neuralnetwork/nn.neuron.d.ts

@@ -0,0 +1,8 @@
+import { ICartesian } from "../geometry";
+import { GraphNode, IOlink } from "../graph";
+import { Nullable } from "../types";
+import { INeuron } from "./nn.interfaces";
+export declare class Neuron extends GraphNode implements INeuron {
+    constructor(onsc?: Nullable<IOlink[]>, opsc?: Nullable<IOlink[]>, position?: ICartesian);
+    reset(): void;
+}

package/dist/neuralnetwork/nn.neuron.js

@@ -0,0 +1,10 @@
+import { GraphNode } from "../graph";
+export class Neuron extends GraphNode {
+    constructor(onsc = null, opsc = null, position) {
+        super(onsc, opsc, position);
+    }
+    reset() {
+        this.bag = undefined;
+    }
+}
+//# sourceMappingURL=nn.neuron.js.map

package/dist/neuralnetwork/nn.neuron.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nn.neuron.js","sourceRoot":"","sources":["../../src/neuralnetwork/nn.neuron.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAU,MAAM,UAAU,CAAC;AAI7C,MAAM,OAAO,MAAO,SAAQ,SAAS;IAEjC,YAAY,OAA2B,IAAI,EAAE,OAA2B,IAAI,EAAE,QAAqB;QAC/F,KAAK,CAAC,IAAI,EAAC,IAAI,EAAC,QAAQ,CAAC,CAAC;IAC9B,CAAC;IAED,KAAK;QACD,IAAI,CAAC,GAAG,GAAG,SAAS,CAAC;IACzB,CAAC;CACJ","sourcesContent":["import { ICartesian } from \"../geometry\";\r\nimport { GraphNode, IOlink } from \"../graph\";\r\nimport { Nullable } from \"../types\";\r\nimport { INeuron } from \"./nn.interfaces\";\r\n\r\nexport class Neuron extends GraphNode implements INeuron {\r\n\r\n    constructor(onsc: Nullable<IOlink[]> = null, opsc: Nullable<IOlink[]> = null, position?: ICartesian){\r\n        super(onsc,opsc,position);\r\n    }\r\n\r\n    reset(): void {\r\n        this.bag = undefined;\r\n    }\r\n}\r\n"]}

package/dist/neuralnetwork/nn.synapse.d.ts

@@ -0,0 +1,6 @@
+import { GraphOLink, INode } from "../graph";
+import { ISynapse } from "./nn.interfaces";
+export declare class Synapse extends GraphOLink implements ISynapse {
+    weight: number;
+    constructor(oini: INode, ofin: INode, weight?: number);
+}

package/dist/neuralnetwork/nn.synapse.js

@@ -0,0 +1,14 @@
+import { __decorate, __metadata } from "tslib";
+import { cloneable, GraphOLink } from "../graph";
+export class Synapse extends GraphOLink {
+    constructor(oini, ofin, weight = 0) {
+        super(oini, ofin);
+        this.weight = 0;
+        this.weight = weight;
+    }
+}
+__decorate([
+    cloneable,
+    __metadata("design:type", Number)
+], Synapse.prototype, "weight", void 0);
+//# sourceMappingURL=nn.synapse.js.map

package/dist/neuralnetwork/nn.synapse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nn.synapse.js","sourceRoot":"","sources":["../../src/neuralnetwork/nn.synapse.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAS,MAAM,UAAU,CAAC;AAGxD,MAAM,OAAO,OAAQ,SAAQ,UAAU;IAEnC,YAAmB,IAAW,EAAE,IAAW,EAAE,SAAiB,CAAC;QAC3D,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAFJ,WAAM,GAAW,CAAC,CAAC;QAGjC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACzB,CAAC;CACJ;AALqB;IAAjB,SAAS;;uCAA2B","sourcesContent":["import { cloneable, GraphOLink, INode } from \"../graph\";\r\nimport { ISynapse } from \"./nn.interfaces\";\r\n\r\nexport class Synapse extends GraphOLink implements ISynapse {\r\n    @cloneable public weight: number = 0;\r\n    public constructor(oini: INode, ofin: INode, weight: number = 0) {\r\n        super(oini, ofin);\r\n        this.weight = weight;\r\n    }\r\n}\r\n"]}

package/dist/neuralnetwork/nn.weights.d.ts

@@ -0,0 +1,42 @@
+export declare class WeightInit {
+    static Glorot(fanIn: number, fanOut: number): number;
+    static He(fanIn: number): number;
+    static Normal(mean?: number, stdDev?: number): number;
+    static Uniform(min?: number, max?: number): number;
+}
+export declare enum WeightInitializerType {
+    Glorot = "glorot",
+    He = "he",
+    Normal = "normal",
+    Uniform = "uniform"
+}
+export interface IWeightInitializer {
+    type: WeightInitializerType;
+    next(): number;
+}
+export declare class Glorot implements IWeightInitializer {
+    private limit;
+    constructor(fanIn: number, fanOut: number);
+    get type(): WeightInitializerType;
+    next(): number;
+}
+export declare class He implements IWeightInitializer {
+    private limit;
+    constructor(fanIn: number);
+    get type(): WeightInitializerType;
+    next(): number;
+}
+export declare class Normal implements IWeightInitializer {
+    private mean;
+    private stdDev;
+    constructor(mean?: number, stdDev?: number);
+    get type(): WeightInitializerType;
+    next(): number;
+}
+export declare class Uniform implements IWeightInitializer {
+    private min;
+    private max;
+    constructor(min?: number, max?: number);
+    get type(): WeightInitializerType;
+    next(): number;
+}

package/dist/neuralnetwork/nn.weights.js

@@ -0,0 +1,120 @@
+/// <summary>
+/// WeightInit provides commonly used weight initialization strategies for neural networks.
+/// These initializers are not specific to MLPs and are widely used in various types of neural architectures
+/// including CNNs, RNNs, Transformers, and others, especially in deep learning.
+/// </summary>
+export class WeightInit {
+    /// <summary>
+    /// Glorot/Xavier initialization.
+    /// Typically used with tanh or sigmoid activations.
+    /// Scales weights to keep variance roughly equal across layers.
+    /// </summary>
+    static Glorot(fanIn, fanOut) {
+        const limit = Math.sqrt(6 / (fanIn + fanOut));
+        return (Math.random() * 2 - 1) * limit;
+    }
+    /// <summary>
+    /// He initialization.
+    /// Typically used with ReLU and its variants.
+    /// Helps prevent vanishing gradients in deep networks.
+    /// </summary>
+    static He(fanIn) {
+        const limit = Math.sqrt(6 / fanIn);
+        return (Math.random() * 2 - 1) * limit;
+    }
+    /// <summary>
+    /// Gaussian initialization using the Box-Muller transform.
+    /// Can be used as a general-purpose initializer.
+    /// </summary>
+    static Normal(mean = 0, stdDev = 1) {
+        let u = 1 - Math.random();
+        let v = 1 - Math.random();
+        return mean + stdDev * Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+    }
+    /// <summary>
+    /// Uniform initialization between min and max values.
+    /// </summary>
+    static Uniform(min = -1, max = 1) {
+        return Math.random() * (max - min) + min;
+    }
+}
+export var WeightInitializerType;
+(function (WeightInitializerType) {
+    /// <summary>
+    /// Glorot/Xavier initializer, typically used with tanh or sigmoid activations.
+    /// </summary>
+    WeightInitializerType["Glorot"] = "glorot";
+    /// <summary>
+    /// He initializer, typically used with ReLU-like activations.
+    /// </summary>
+    WeightInitializerType["He"] = "he";
+    /// <summary>
+    /// Normal (Gaussian) initializer using the Box-Muller transform.
+    /// </summary>
+    WeightInitializerType["Normal"] = "normal";
+    /// <summary>
+    /// Uniform initializer between min and max values.
+    /// </summary>
+    WeightInitializerType["Uniform"] = "uniform";
+})(WeightInitializerType || (WeightInitializerType = {}));
+/// <summary>
+/// Glorot/Xavier initializer class for use in builder chains.
+/// </summary>
+export class Glorot {
+    constructor(fanIn, fanOut) {
+        this.limit = Math.sqrt(6 / (fanIn + fanOut));
+    }
+    get type() {
+        return WeightInitializerType.Glorot;
+    }
+    next() {
+        return (Math.random() * 2 - 1) * this.limit;
+    }
+}
+/// <summary>
+/// He initializer class, typically used with ReLU-like activations.
+/// </summary>
+export class He {
+    constructor(fanIn) {
+        this.limit = Math.sqrt(6 / fanIn);
+    }
+    get type() {
+        return WeightInitializerType.He;
+    }
+    next() {
+        return (Math.random() * 2 - 1) * this.limit;
+    }
+}
+/// <summary>
+/// Normal (Gaussian) initializer using the Box-Muller transform.
+/// </summary>
+export class Normal {
+    constructor(mean = 0, stdDev = 1) {
+        this.mean = mean;
+        this.stdDev = stdDev;
+    }
+    get type() {
+        return WeightInitializerType.Normal;
+    }
+    next() {
+        let u = 1 - Math.random();
+        let v = 1 - Math.random();
+        return this.mean + this.stdDev * Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+    }
+}
+/// <summary>
+/// Uniform initializer between min and max.
+/// </summary>
+export class Uniform {
+    constructor(min = -1, max = 1) {
+        this.min = min;
+        this.max = max;
+    }
+    get type() {
+        return WeightInitializerType.Uniform;
+    }
+    next() {
+        return Math.random() * (this.max - this.min) + this.min;
+    }
+}
+//# sourceMappingURL=nn.weights.js.map