@dniskav/neuron 0.2.1 → 0.2.2

package/dist/index.d.mts

@@ -274,10 +274,36 @@ declare class NetworkTransformer {
     private _forward;
 }
 
+interface NetworkTransformerRLOptions {
+    d_model?: number;
+    nHeads?: number;
+    d_ff?: number;
+    nBlocks?: number;
+    nActions?: number;
+}
+declare class NetworkTransformerRL {
+    readonly seqLen: number;
+    readonly inputDim: number;
+    readonly d_model: number;
+    readonly nActions: number;
+    inputProj: WeightMatrix;
+    blocks: TransformerBlock[];
+    outputProj: WeightMatrix;
+    outputBias: number[];
+    private outBiasOpts;
+    private _projected;
+    constructor(seqLen: number, inputDim: number, options?: NetworkTransformerRLOptions);
+    predict(sequence: number[][]): number[];
+    train(sequence: number[][], target: number[], lr: number): number;
+    getAttentionWeights(): (number[][] | null)[][];
+    private _forward;
+    private _pool;
+}
+
 declare function mse(predicted: number[], actual: number[]): number;
 declare function crossEntropy(predicted: number[], actual: number[]): number;
 declare function mseDelta(predicted: number, actual: number): number;
 declare function crossEntropyDelta(predicted: number, actual: number): number;
 declare function crossEntropyDeltaRaw(predicted: number, actual: number): number;
 
-export { type Activation, Adam, AttentionHead, EmbeddingMatrix, LSTMLayer, Layer, LayerNorm, Momentum, MultiHeadAttention, Network, NetworkLSTM, type NetworkLSTMOptions, NetworkN, type NetworkNOptions, NetworkTransformer, type NetworkTransformerOptions, Neuron, NeuronN, type Optimizer, type OptimizerFactory, SGD, TransformerBlock, type TransformerBlockOptions, WeightMatrix, crossEntropy, crossEntropyDelta, crossEntropyDeltaRaw, elu, leakyRelu, linear, makeElu, makeLeakyRelu, matMul, mse, mseDelta, relu, sigmoid, softmax, softmaxBackward, tanh, transpose };
+export { type Activation, Adam, AttentionHead, EmbeddingMatrix, LSTMLayer, Layer, LayerNorm, Momentum, MultiHeadAttention, Network, NetworkLSTM, type NetworkLSTMOptions, NetworkN, type NetworkNOptions, NetworkTransformer, type NetworkTransformerOptions, NetworkTransformerRL, type NetworkTransformerRLOptions, Neuron, NeuronN, type Optimizer, type OptimizerFactory, SGD, TransformerBlock, type TransformerBlockOptions, WeightMatrix, crossEntropy, crossEntropyDelta, crossEntropyDeltaRaw, elu, leakyRelu, linear, makeElu, makeLeakyRelu, matMul, mse, mseDelta, relu, sigmoid, softmax, softmaxBackward, tanh, transpose };

package/dist/index.d.ts

@@ -274,10 +274,36 @@ declare class NetworkTransformer {
     private _forward;
 }
 
+interface NetworkTransformerRLOptions {
+    d_model?: number;
+    nHeads?: number;
+    d_ff?: number;
+    nBlocks?: number;
+    nActions?: number;
+}
+declare class NetworkTransformerRL {
+    readonly seqLen: number;
+    readonly inputDim: number;
+    readonly d_model: number;
+    readonly nActions: number;
+    inputProj: WeightMatrix;
+    blocks: TransformerBlock[];
+    outputProj: WeightMatrix;
+    outputBias: number[];
+    private outBiasOpts;
+    private _projected;
+    constructor(seqLen: number, inputDim: number, options?: NetworkTransformerRLOptions);
+    predict(sequence: number[][]): number[];
+    train(sequence: number[][], target: number[], lr: number): number;
+    getAttentionWeights(): (number[][] | null)[][];
+    private _forward;
+    private _pool;
+}
+
 declare function mse(predicted: number[], actual: number[]): number;
 declare function crossEntropy(predicted: number[], actual: number[]): number;
 declare function mseDelta(predicted: number, actual: number): number;
 declare function crossEntropyDelta(predicted: number, actual: number): number;
 declare function crossEntropyDeltaRaw(predicted: number, actual: number): number;
 
-export { type Activation, Adam, AttentionHead, EmbeddingMatrix, LSTMLayer, Layer, LayerNorm, Momentum, MultiHeadAttention, Network, NetworkLSTM, type NetworkLSTMOptions, NetworkN, type NetworkNOptions, NetworkTransformer, type NetworkTransformerOptions, Neuron, NeuronN, type Optimizer, type OptimizerFactory, SGD, TransformerBlock, type TransformerBlockOptions, WeightMatrix, crossEntropy, crossEntropyDelta, crossEntropyDeltaRaw, elu, leakyRelu, linear, makeElu, makeLeakyRelu, matMul, mse, mseDelta, relu, sigmoid, softmax, softmaxBackward, tanh, transpose };
+export { type Activation, Adam, AttentionHead, EmbeddingMatrix, LSTMLayer, Layer, LayerNorm, Momentum, MultiHeadAttention, Network, NetworkLSTM, type NetworkLSTMOptions, NetworkN, type NetworkNOptions, NetworkTransformer, type NetworkTransformerOptions, NetworkTransformerRL, type NetworkTransformerRLOptions, Neuron, NeuronN, type Optimizer, type OptimizerFactory, SGD, TransformerBlock, type TransformerBlockOptions, WeightMatrix, crossEntropy, crossEntropyDelta, crossEntropyDeltaRaw, elu, leakyRelu, linear, makeElu, makeLeakyRelu, matMul, mse, mseDelta, relu, sigmoid, softmax, softmaxBackward, tanh, transpose };

package/dist/index.js

@@ -32,6 +32,7 @@ __export(index_exports, {
   NetworkLSTM: () => NetworkLSTM,
   NetworkN: () => NetworkN,
   NetworkTransformer: () => NetworkTransformer,
+  NetworkTransformerRL: () => NetworkTransformerRL,
   Neuron: () => Neuron,
   NeuronN: () => NeuronN,
   SGD: () => SGD,
@@ -1098,6 +1099,124 @@ var NetworkTransformer = class {
   }
 };
 
+// src/NetworkTransformerRL.ts
+var NetworkTransformerRL = class {
+  constructor(seqLen, inputDim, options = {}) {
+    // Forward caches para backprop
+    this._projected = null;
+    const {
+      d_model = 32,
+      nHeads = 2,
+      d_ff = 64,
+      nBlocks = 2,
+      nActions = 2
+    } = options;
+    this.seqLen = seqLen;
+    this.inputDim = inputDim;
+    this.d_model = d_model;
+    this.nActions = nActions;
+    this.inputProj = new WeightMatrix(d_model, inputDim);
+    this.blocks = Array.from(
+      { length: nBlocks },
+      () => new TransformerBlock({ d_model, nHeads, d_ff })
+    );
+    this.outputProj = new WeightMatrix(nActions, d_model);
+    this.outputBias = new Array(nActions).fill(0);
+    this.outBiasOpts = Array.from({ length: nActions }, () => new Adam());
+  }
+  // ── Forward ────────────────────────────────────────────────────────────────
+  // sequence: seqLen × inputDim → nActions Q-values
+  predict(sequence) {
+    const h = this._forward(sequence);
+    const pooled = this._pool(h);
+    return this.outputProj.W.map(
+      (row, c) => row.reduce((s, w, m) => s + w * pooled[m], this.outputBias[c])
+    );
+  }
+  // ── Training ────────────────────────────────────────────────────────────────
+  // sequence: seqLen × inputDim
+  // target:   nActions Q-values (one-hot style para Q-learning)
+  // lr:       learning rate
+  // Returns: MSE loss
+  train(sequence, target, lr) {
+    const h = this._forward(sequence);
+    const pooled = this._pool(h);
+    const pred = this.outputProj.W.map(
+      (row, c) => row.reduce((s, w, m) => s + w * pooled[m], this.outputBias[c])
+    );
+    const n = this.nActions;
+    let loss = 0;
+    for (let c = 0; c < n; c++) {
+      const diff = pred[c] - target[c];
+      loss += diff * diff;
+    }
+    loss /= n;
+    const dPred = pred.map((p, c) => 2 * (p - target[c]) / n);
+    const dPooled = Array.from(
+      { length: this.d_model },
+      (_, m) => dPred.reduce((s, dp, c) => s + dp * this.outputProj.W[c][m], 0)
+    );
+    const dWout = Array.from(
+      { length: this.nActions },
+      (_, c) => Array.from(
+        { length: this.d_model },
+        (_2, m) => dPred[c] * pooled[m]
+      )
+    );
+    const dBout = dPred.slice();
+    this.outputProj.update(dWout, lr);
+    for (let c = 0; c < this.nActions; c++)
+      this.outputBias[c] = this.outBiasOpts[c].step(this.outputBias[c], dBout[c], lr);
+    let dH = Array.from(
+      { length: this.seqLen },
+      (_, i) => dPooled.map((v) => v / this.seqLen)
+      // Gradiente dividido entre posiciones
+    );
+    for (let b = this.blocks.length - 1; b >= 0; b--)
+      dH = this.blocks[b].backward(dH, lr);
+    for (let i = 0; i < this.seqLen; i++) {
+      const dInputProj = Array.from(
+        { length: this.d_model },
+        (_, k) => Array.from(
+          { length: this.inputDim },
+          (_2, m) => dH[i][k] * sequence[i][m]
+        )
+      );
+      this.inputProj.update(dInputProj, lr);
+    }
+    return loss;
+  }
+  // Attention weights from every block for visualization.
+  getAttentionWeights() {
+    return this.blocks.map((b) => b.getAttentionWeights());
+  }
+  // ── Internal ────────────────────────────────────────────────────────────────
+  _forward(sequence) {
+    let h = sequence.map(
+      (step) => this.inputProj.W.map(
+        (row, k) => row.reduce((s, w, m) => s + w * step[m], 0)
+      )
+    );
+    for (const block of this.blocks)
+      h = block.predict(h);
+    this._projected = h;
+    return h;
+  }
+  _pool(h) {
+    const weights = Array.from(
+      { length: this.seqLen },
+      (_, i) => i === this.seqLen - 1 ? 2 : 1
+    );
+    const totalWeight = weights.reduce((a, b) => a + b, 0);
+    return Array.from({ length: this.d_model }, (_, m) => {
+      let sum = 0;
+      for (let i = 0; i < this.seqLen; i++)
+        sum += weights[i] * h[i][m];
+      return sum / totalWeight;
+    });
+  }
+};
+
 // src/losses.ts
 function mse(predicted, actual) {
   return predicted.reduce((sum, p, i) => sum + (actual[i] - p) ** 2, 0) / predicted.length;
@@ -1134,6 +1253,7 @@ function crossEntropyDeltaRaw(predicted, actual) {
   NetworkLSTM,
   NetworkN,
   NetworkTransformer,
+  NetworkTransformerRL,
   Neuron,
   NeuronN,
   SGD,

package/dist/index.mjs

@@ -1039,6 +1039,124 @@ var NetworkTransformer = class {
   }
 };
 
+// src/NetworkTransformerRL.ts
+var NetworkTransformerRL = class {
+  constructor(seqLen, inputDim, options = {}) {
+    // Forward caches para backprop
+    this._projected = null;
+    const {
+      d_model = 32,
+      nHeads = 2,
+      d_ff = 64,
+      nBlocks = 2,
+      nActions = 2
+    } = options;
+    this.seqLen = seqLen;
+    this.inputDim = inputDim;
+    this.d_model = d_model;
+    this.nActions = nActions;
+    this.inputProj = new WeightMatrix(d_model, inputDim);
+    this.blocks = Array.from(
+      { length: nBlocks },
+      () => new TransformerBlock({ d_model, nHeads, d_ff })
+    );
+    this.outputProj = new WeightMatrix(nActions, d_model);
+    this.outputBias = new Array(nActions).fill(0);
+    this.outBiasOpts = Array.from({ length: nActions }, () => new Adam());
+  }
+  // ── Forward ────────────────────────────────────────────────────────────────
+  // sequence: seqLen × inputDim → nActions Q-values
+  predict(sequence) {
+    const h = this._forward(sequence);
+    const pooled = this._pool(h);
+    return this.outputProj.W.map(
+      (row, c) => row.reduce((s, w, m) => s + w * pooled[m], this.outputBias[c])
+    );
+  }
+  // ── Training ────────────────────────────────────────────────────────────────
+  // sequence: seqLen × inputDim
+  // target:   nActions Q-values (one-hot style para Q-learning)
+  // lr:       learning rate
+  // Returns: MSE loss
+  train(sequence, target, lr) {
+    const h = this._forward(sequence);
+    const pooled = this._pool(h);
+    const pred = this.outputProj.W.map(
+      (row, c) => row.reduce((s, w, m) => s + w * pooled[m], this.outputBias[c])
+    );
+    const n = this.nActions;
+    let loss = 0;
+    for (let c = 0; c < n; c++) {
+      const diff = pred[c] - target[c];
+      loss += diff * diff;
+    }
+    loss /= n;
+    const dPred = pred.map((p, c) => 2 * (p - target[c]) / n);
+    const dPooled = Array.from(
+      { length: this.d_model },
+      (_, m) => dPred.reduce((s, dp, c) => s + dp * this.outputProj.W[c][m], 0)
+    );
+    const dWout = Array.from(
+      { length: this.nActions },
+      (_, c) => Array.from(
+        { length: this.d_model },
+        (_2, m) => dPred[c] * pooled[m]
+      )
+    );
+    const dBout = dPred.slice();
+    this.outputProj.update(dWout, lr);
+    for (let c = 0; c < this.nActions; c++)
+      this.outputBias[c] = this.outBiasOpts[c].step(this.outputBias[c], dBout[c], lr);
+    let dH = Array.from(
+      { length: this.seqLen },
+      (_, i) => dPooled.map((v) => v / this.seqLen)
+      // Gradiente dividido entre posiciones
+    );
+    for (let b = this.blocks.length - 1; b >= 0; b--)
+      dH = this.blocks[b].backward(dH, lr);
+    for (let i = 0; i < this.seqLen; i++) {
+      const dInputProj = Array.from(
+        { length: this.d_model },
+        (_, k) => Array.from(
+          { length: this.inputDim },
+          (_2, m) => dH[i][k] * sequence[i][m]
+        )
+      );
+      this.inputProj.update(dInputProj, lr);
+    }
+    return loss;
+  }
+  // Attention weights from every block for visualization.
+  getAttentionWeights() {
+    return this.blocks.map((b) => b.getAttentionWeights());
+  }
+  // ── Internal ────────────────────────────────────────────────────────────────
+  _forward(sequence) {
+    let h = sequence.map(
+      (step) => this.inputProj.W.map(
+        (row, k) => row.reduce((s, w, m) => s + w * step[m], 0)
+      )
+    );
+    for (const block of this.blocks)
+      h = block.predict(h);
+    this._projected = h;
+    return h;
+  }
+  _pool(h) {
+    const weights = Array.from(
+      { length: this.seqLen },
+      (_, i) => i === this.seqLen - 1 ? 2 : 1
+    );
+    const totalWeight = weights.reduce((a, b) => a + b, 0);
+    return Array.from({ length: this.d_model }, (_, m) => {
+      let sum = 0;
+      for (let i = 0; i < this.seqLen; i++)
+        sum += weights[i] * h[i][m];
+      return sum / totalWeight;
+    });
+  }
+};
+
 // src/losses.ts
 function mse(predicted, actual) {
   return predicted.reduce((sum, p, i) => sum + (actual[i] - p) ** 2, 0) / predicted.length;
@@ -1074,6 +1192,7 @@ export {
   NetworkLSTM,
   NetworkN,
   NetworkTransformer,
+  NetworkTransformerRL,
   Neuron,
   NeuronN,
   SGD,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dniskav/neuron",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Minimal neural network from scratch — neuron, layer, network, backpropagation. No dependencies.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",