@oxide-js/spiking 1.1.0 → 1.3.0

package/test/SpikingSelfAttention.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Matrix } from '@oxide-js/core';
+import { SpikingSelfAttention } from '../src/layers/SpikingSelfAttention.js';
+
+describe('SpikingSelfAttention Layer', () => {
+  const d_model = 4;
+  const sequenceLength = 3;
+  const batch = 2;
+  const batchSeq = batch * sequenceLength;
+
+  let attentionLayer: SpikingSelfAttention;
+
+  beforeEach(() => {
+    attentionLayer = new SpikingSelfAttention({
+      d_model,
+      sequenceLength,
+      kernelInitializer: 'ones' // Inisialisasi awal statis agar prediktabilitas baik
+    });
+    attentionLayer.build([batchSeq, d_model]);
+  });
+
+  it('should initialize parameters correctly', () => {
+    expect(attentionLayer.d_model).toBe(d_model);
+    expect(attentionLayer.sequenceLength).toBe(sequenceLength);
+    expect(attentionLayer.kernelQ).toBeDefined();
+    expect(attentionLayer.kernelK).toBeDefined();
+    expect(attentionLayer.kernelV).toBeDefined();
+    
+    // Potentials harus diawali kosong
+    expect(attentionLayer.potentialsQ._data.length).toBe(0);
+    expect(attentionLayer.potentialsScores._data.length).toBe(0);
+  });
+
+  it('should compute output with the correct shape and binary spike format', () => {
+    // Buat input dummy berupa array biner (0 dan 1)
+    const inputData = new Float32Array(batchSeq * d_model);
+    for (let i = 0; i < inputData.length; i++) {
+        inputData[i] = Math.random() > 0.5 ? 1 : 0;
+    }
+    const inputs = Matrix.fromFlat(inputData, [batchSeq, d_model]);
+
+    const output = attentionLayer.forward(inputs) as Matrix;
+
+    // Cek shape output yang diharapkan: [batch * seqLen, d_model]
+    expect(output._shape[0]).toBe(batchSeq);
+    expect(output._shape[1]).toBe(d_model);
+
+    // Pastikan output hanya berisi format spike biner (0.0 atau 1.0)
+    const outputData = output._data;
+    for (let i = 0; i < outputData.length; i++) {
+        expect([0, 1]).toContain(outputData[i]);
+    }
+    
+    // State potentials harus terbentuk sesuai shape
+    expect(attentionLayer.potentialsQ._data.length).toBe(batchSeq * d_model);
+    expect(attentionLayer.potentialsScores._data.length).toBe(batchSeq * sequenceLength);
+  });
+
+  it('should properly accumulate potentials in sequential steps', () => {
+    const inputData = new Float32Array(batchSeq * d_model).fill(1);
+    const inputs = Matrix.fromFlat(inputData, [batchSeq, d_model]);
+
+    // Jalankan beberapa time-steps (forward pass)
+    attentionLayer.forward(inputs);
+    
+    // Ambil sebagian data dari potentialsQ untuk verifikasi akumulasi
+    const firstStepPotentials = new Float32Array(attentionLayer.potentialsQ._data);
+    
+    attentionLayer.forward(inputs);
+    
+    // Karena input konstan, seharusnya potensial naik atau diset ulang setelah spike, 
+    // tetapi setidaknya harus berjalan normal (tidak crash)
+    expect(attentionLayer.potentialsQ._data).toBeDefined();
+    // Pada saat reset, potensial harus dikembalikan ke 0
+    attentionLayer.resetState();
+    const zeros = new Float32Array(attentionLayer.potentialsQ._data.length).fill(0);
+    expect(attentionLayer.potentialsQ._data).toEqual(zeros);
+  });
+
+  it('should throw error if input batch length is not multiple of sequence length', () => {
+    const invalidBatchSeq = 7; // Bukan kelipatan sequenceLength (3)
+    const inputData = new Float32Array(invalidBatchSeq * d_model).fill(1);
+    const inputs = Matrix.fromFlat(inputData, [invalidBatchSeq, d_model]);
+
+    expect(() => {
+        attentionLayer.forward(inputs);
+    }).toThrowError(/Jumlah baris input/);
+  });
+
+  it('should correctly compute exact Self-Attention math (Deterministic Correctness)', () => {
+    // Set up environment yang sepenuhnya deterministik
+    const testLayer = new SpikingSelfAttention({
+        d_model: 2,
+        sequenceLength: 2,
+        kernelInitializer: 'zeros' // Kita override manual
+    });
+    
+    testLayer.build([2, 2]); // batchSeq=2, d_model=2
+
+    // Override bobot menjadi Identity Matrix
+    const identity = new Float32Array([1, 0, 0, 1]);
+    testLayer.kernelQ!._data.set(identity);
+    testLayer.kernelK!._data.set(identity);
+    testLayer.kernelV!._data.set(identity);
+
+    // Override LIF properties agar seketika spike jika input >= 1
+    testLayer.betaQKV.fill(0.0);
+    testLayer.thresholdQKV.fill(0.5);
+    
+    testLayer.betaScores.fill(0.0);
+    testLayer.thresholdScores.fill(0.5); // Threshold kecil agar skor >= 1 langsung tembak spike
+
+    // Input: Token 0 = [1, 0], Token 1 = [0, 1]
+    const inputs = Matrix.fromFlat(new Float32Array([1, 0, 0, 1]), [2, 2]);
+
+    // Lakukan forward pass
+    const output = testLayer.forward(inputs) as Matrix;
+
+    // Analisis ekspektasi:
+    // SQ, SK, SV akan identik dengan input (karena dikali Identity dan threshold < 1.0)
+    // SQ dot SK^T:
+    // - Token 0 dot Token 0 = 1 (match index 0)
+    // - Token 0 dot Token 1 = 0
+    // - Token 1 dot Token 0 = 0
+    // - Token 1 dot Token 1 = 1
+    // S_Scores akan menjadi Identity Matrix [1, 0, 0, 1]
+    // Hasil akhir: S_Scores dikali SV -> [1, 0, 0, 1]
+
+    expect(output._shape).toEqual([2, 2]);
+    expect(output._data).toEqual(new Float32Array([1, 0, 0, 1]));
+
+    // Mari tes dengan Token yang identik: Token 0 = [1, 0], Token 1 = [1, 0]
+    const inputsSame = Matrix.fromFlat(new Float32Array([1, 0, 1, 0]), [2, 2]);
+    const outputSame = testLayer.forward(inputsSame) as Matrix;
+    
+    // SQ dot SK^T:
+    // - Token 0 dot Token 0 = 1
+    // - Token 0 dot Token 1 = 1
+    // - Token 1 dot Token 0 = 1
+    // - Token 1 dot Token 1 = 1
+    // S_Scores akan menjadi [1, 1, 1, 1] (semuanya spike karena saling cocok)
+    // SV = [1, 0, 1, 0]
+    // Perkalian akhir: 
+    // Out Token 0 = S_Scores[0]*SV[0] + S_Scores[1]*SV[1] = 1*1 + 1*1 = 2 (Lalu dikunci/clamped ke 1) = [1, 0]
+    // Out Token 1 = [1, 0]
+    expect(outputSame._data).toEqual(new Float32Array([1, 0, 1, 0]));
+  });
+});

package/test/test_embedding_overlap.ts

@@ -0,0 +1,181 @@
+import { Matrix } from "@oxide-js/core";
+import { SpikingEmbedding } from "../src/layers/SpikingEmbedding.js";
+import { SpikingDense } from "../src/layers/SpikingDense.js";
+
+// Kamus Kosakata (Vocabulary)
+// 0: Kucing
+// 1: Manusia
+// 2: Makan
+// 3: Ikan
+// 4: Tidur
+// 5: Kasur
+const vocabSize = 6;
+const embedDim = 16;
+const numClasses = 2; // Kelas 0: Hewan, Kelas 1: Manusia
+
+// Dataset Kalimat (Urutan indeks kata)
+// Kalimat 1: Kucing(0) makan(2) ikan(3) -> Target: Hewan [1, 0]
+// Kalimat 2: Manusia(1) makan(2) ikan(3) -> Target: Manusia [0, 1]
+// Kalimat 3: Kucing(0) tidur(4) kasur(5) -> Target: Hewan [1, 0]
+// Kalimat 4: Manusia(1) tidur(4) kasur(5) -> Target: Manusia [0, 1]
+
+const sentences = [
+  [0, 2, 3], // Kucing makan ikan
+  [1, 2, 3], // Manusia makan ikan
+  [0, 4, 5], // Kucing tidur kasur
+  [1, 4, 5]  // Manusia tidur kasur
+];
+
+const targets = [
+  [1, 0], // Hewan
+  [0, 1], // Manusia
+  [1, 0], // Hewan
+  [0, 1]  // Manusia
+];
+
+console.log("Inisialisasi SpikingEmbedding & SpikingDense (Tes Overlap)...");
+
+const embedding = new SpikingEmbedding({
+  inputDim: vocabSize,
+  outputDim: embedDim,
+  beta: 0.9,
+  threshold: 1.0,
+  embeddingsInitializer: "glorot_normal"
+});
+
+const outputLayer = new SpikingDense({
+  units: numClasses,
+  beta: 0.9,
+  threshold: 1.0,
+  useBias: true,
+  kernelInitializer: "glorot_normal"
+});
+
+// Batch size 1, num_tokens 1 (Konteks diumpankan secara berurutan dalam timesteps)
+embedding.build([1, 1]);
+outputLayer.build([1, embedDim]);
+
+// Matriks Feedback Alignment (B) yang bernilai acak namun tetap
+const bData = new Float32Array(numClasses * embedDim);
+for (let i = 0; i < bData.length; i++) bData[i] = (Math.random() * 2) - 1;
+const B = Matrix.fromFlat(bData, [numClasses, embedDim]);
+
+const epochs = 300; // Epoch butuh lebih banyak karena ada tarik-menarik gradien
+const learningRate = 0.005;
+
+console.log("Mulai training SNN Word-to-Class dengan overlapping context...");
+
+for (let epoch = 0; epoch < epochs; epoch++) {
+  let totalError = 0;
+
+  for (let i = 0; i < sentences.length; i++) {
+    const sentence = sentences[i];
+    const y = Matrix.fromFlat(new Float32Array(targets[i]), [1, numClasses]);
+
+    let outSpikes = Matrix.fromFlat(new Float32Array(numClasses), [1, numClasses]);
+    let sudahSpike = new Array(numClasses).fill(false);
+
+    embedding.resetState();
+    outputLayer.resetState();
+
+    // Loop melewati kata-kata di kalimat berulang kali (simulasi durasi waktu SNN membaca)
+    // 3 kata x 4 siklus = 12 timestep
+    for (let t = 0; t < 12; t++) {
+      const tokenIdx = sentence[t % sentence.length]; // Ambil token secara round-robin
+      const x = Matrix.fromFlat(new Float32Array([tokenIdx]), [1, 1]);
+
+      const eSpikes = embedding.forward(x) as Matrix;
+      outSpikes = outputLayer.forward(eSpikes) as Matrix;
+
+      const actual = outSpikes._data;
+      const target = y._data;
+
+      const errData = new Float32Array(numClasses);
+      let stepError = 0;
+
+      for (let j = 0; j < numClasses; j++) {
+        if (actual[j] === 1) sudahSpike[j] = true;
+
+        if (target[j] === 1) {
+          if (!sudahSpike[j]) errData[j] = 1; // Dorong sampai spike
+          else errData[j] = 0;                // Sudah spike, biarkan santai
+        } else {
+          errData[j] = 0 - actual[j];         // Penalti jika salah spike
+        }
+        stepError += Math.abs(errData[j]);
+      }
+
+      totalError += stepError;
+
+      if (stepError !== 0) {
+        const errorSignal = Matrix.fromFlat(errData, [1, numClasses]);
+        outputLayer.learnOutput(errorSignal, learningRate);
+        embedding.learnEmbedding(errorSignal, B, learningRate);
+      }
+    }
+  }
+
+  if (epoch % 50 === 0 || epoch === epochs - 1) {
+    console.log(`Epoch ${epoch} | Total Spiking Error: ${totalError}`);
+  }
+}
+
+// Uji coba inferensi kalimat
+console.log("\n--- HASIL PENGUJIAN KALIMAT ---");
+for (let i = 0; i < sentences.length; i++) {
+  const sentence = sentences[i];
+  embedding.resetState();
+  outputLayer.resetState();
+
+  let totalTembakan = new Float32Array(numClasses);
+
+  // Baca kalimat selama 12 timestep
+  for (let t = 0; t < 12; t++) {
+    const tokenIdx = sentence[t % sentence.length];
+    const x = Matrix.fromFlat(new Float32Array([tokenIdx]), [1, 1]);
+
+    const eSpikes = embedding.forward(x) as Matrix;
+    const outSpikes = outputLayer.forward(eSpikes) as Matrix;
+
+    for (let j = 0; j < numClasses; j++) {
+      totalTembakan[j] += outSpikes._data[j];
+    }
+  }
+
+  const teks = sentence.map(s => {
+    switch (s) {
+      case 0: return "Kucing";
+      case 1: return "Manusia";
+      case 2: return "Makan";
+      case 3: return "Ikan";
+      case 4: return "Tidur";
+      case 5: return "Kasur";
+      default: return "";
+    }
+  }).join(" ");
+
+  console.log(`Kalimat: "${teks}"`);
+  console.log(` -> Prediksi Spike [Hewan, Manusia]: [${totalTembakan.join(", ")}] | Target Seharusnya: [${targets[i].join(", ")}]`);
+}
+
+// Uji coba tebak kata individu (untuk melihat sentimen yang dipelajari embedding layer)
+console.log("\n--- ANALISIS SENTIMEN KATA INDIVIDU ---");
+const words = ["Kucing (0)", "Manusia (1)", "Makan (2)", "Ikan (3)", "Tidur (4)", "Kasur (5)"];
+for (let i = 0; i < vocabSize; i++) {
+  embedding.resetState();
+  outputLayer.resetState();
+  let totalTembakan = new Float32Array(numClasses);
+
+  // Diberi input kata yang sama selama 10 timestep (memaksa SNN memikirkan kata ini saja)
+  for (let t = 0; t < 10; t++) {
+    const x = Matrix.fromFlat(new Float32Array([i]), [1, 1]);
+    const eSpikes = embedding.forward(x) as Matrix;
+    const outSpikes = outputLayer.forward(eSpikes) as Matrix;
+
+    for (let j = 0; j < numClasses; j++) {
+      totalTembakan[j] += outSpikes._data[j];
+    }
+  }
+
+  console.log(`Kata ${words[i]} -> Pola Spike [Hewan, Manusia]: [${totalTembakan.join(", ")}]`);
+}

package/examples/demo.ts

@@ -1,101 +0,0 @@
-import { SpikingNetwork } from "../src/core/SpikingNetwork.js";
-import { STDP } from "../src/learning/STDP.js";
-import { PoissonEncoder } from "../src/encoding/PoissonEncoder.js";
-
-/**
- * Simulasi Pengenalan Pola Sederhana menggunakan SNN
- * --------------------------------------------------
- * 1. Kita memiliki 3 neuron Input dan 1 neuron Output (Total 4 Neuron)
- * 2. Input merepresentasikan intensitas sinyal (misalnya: [0.9, 0.1, 0.8])
- * 3. Neuron Input terhubung ke Neuron Output
- * 4. STDP akan mengamati dan memperkuat bobot dari input yang sering "menyala" (0.9 dan 0.8)
- */
-async function runDemo() {
-  console.log("=== Memulai Simulasi SNN Add-Only ===\n");
-
-  // Konfigurasi
-  const NUM_INPUTS = 3;
-  const NUM_OUTPUTS = 1;
-  const TOTAL_NEURONS = NUM_INPUTS + NUM_OUTPUTS;
-  const TIME_STEPS = 100;
-
-  // 1. Inisialisasi Jaringan & Komponen
-  // Threshold di-set rendah agar output mudah menembakkan spike
-  const net = new SpikingNetwork(TOTAL_NEURONS, 0.8, 2.0);
-  const stdp = new STDP(net, {
-    learningRate: 0.05,
-    aPlus: 1.5,
-    aMinus: 0.5, // LTD diturunkan agar sinyal yang sering aktif (berkorelasi kuat) membesar
-    wMax: 10.0,
-    wMin: 0.0    // Bobot tidak boleh negatif dalam contoh ini
-  });
-  const encoder = new PoissonEncoder(1.0);
-
-  // Neuron Output berada di indeks ke-3 (karena 0,1,2 adalah input)
-  const OUTPUT_NEURON = 3;
-
-  // 2. Hubungkan Input ke Output dengan bobot awal yang seragam (kecil)
-  console.log("Membangun koneksi awal:");
-  for (let i = 0; i < NUM_INPUTS; i++) {
-    net.connect(i, OUTPUT_NEURON, 1.0);
-    console.log(`- Input Neuron ${i} -> Output Neuron ${OUTPUT_NEURON} (Bobot Awal: 1.0)`);
-  }
-  console.log("\n");
-
-  // 3. Menyiapkan Pola Input
-  // Neuron 0 (Sinyal Kuat), Neuron 1 (Sinyal Lemah), Neuron 2 (Sinyal Kuat)
-  const inputPattern = [0.9, 0.1, 0.8];
-  
-  let totalOutputSpikes = 0;
-
-  console.log(`Menjalankan simulasi selama ${TIME_STEPS} time-steps...`);
-  
-  for (let t = 0; t < TIME_STEPS; t++) {
-    // A. Encode sinyal input kontinu menjadi Spike
-    const currentSpikes = encoder.encodeArray(inputPattern);
-
-    // B. Injeksi spike input secara langsung ke neuron input
-    // (Beri potensial yang cukup agar mereka seketika menembakkan spike di step ini)
-    for (let i = 0; i < NUM_INPUTS; i++) {
-      if (currentSpikes[i] === 1) {
-        // Injeksi arus yang jauh di atas threshold (2.0) agar pasti spike
-        net.injectCurrent(i, 10.0); 
-      }
-    }
-
-    // C. Evaluasi Jaringan (Add-Only Propagation)
-    net.step();
-
-    // D. Hitung Spike Output
-    if (net.spikes[OUTPUT_NEURON] === 1) {
-      totalOutputSpikes++;
-    }
-
-    // E. Lakukan Proses Pembelajaran (Plasticity)
-    stdp.updateWeights();
-  }
-
-  // 4. Hasil Simulasi
-  console.log("\n=== Hasil Simulasi ===");
-  console.log(`Total tembakan (spikes) dari Neuron Output: ${totalOutputSpikes}`);
-  console.log("\nPerubahan Bobot Akhir (Setelah proses Belajar STDP):");
-  
-  for (let i = 0; i < NUM_INPUTS; i++) {
-    // Bobot ke-0 dari array koneksi neuron input 'i'
-    const finalWeight = net.weights[i][0];
-    const initialInput = inputPattern[i];
-    
-    let status = "";
-    if (finalWeight > 1.0) status = "📈 Diperkuat (LTP)";
-    else if (finalWeight < 1.0) status = "📉 Diperlemah (LTD)";
-    else status = "➖ Tetap";
-
-    console.log(`Neuron ${i} (Intensitas Sinyal: ${initialInput}) -> Bobot Akhir: ${finalWeight.toFixed(4)} ${status}`);
-  }
-
-  console.log("\nKesimpulan:");
-  console.log("Seperti yang terlihat, SNN secara otomatis mengenali dan memperkuat koneksi dari neuron input yang aktif (Intensitas 0.9 & 0.8),");
-  console.log("sementara neuron yang jarang aktif (Intensitas 0.1) bobotnya melemah secara natural melalui aturan STDP.");
-}
-
-runDemo().catch(console.error);

package/src/models/SpikingSentenceEmbedder.ts

@@ -1,135 +0,0 @@
-import { Matrix } from "@oxide-js/core";
-import { BaseModel } from "@oxide-js/models";
-import { SpikingEmbedding } from "../layers/SpikingEmbedding.js";
-import { SpikingDense } from "../layers/SpikingDense.js";
-
-export interface SpikingSentenceConfig {
-    vocabSize: number;
-    embedDim: number;  
-    beta?: number;     
-    threshold?: number;
-}
-
-export class SpikingSentenceEmbedder extends BaseModel {
-    public vocabSize: number;
-    public embedDim: number;
-    
-    public embedding: SpikingEmbedding;
-    public contextLayer: SpikingDense;
-
-    constructor(config: SpikingSentenceConfig) {
-        super();
-        this.vocabSize = config.vocabSize;
-        this.embedDim = config.embedDim;
-        const beta = config.beta ?? 0.9; 
-        const threshold = config.threshold ?? 1.0;
-
-        this.embedding = new SpikingEmbedding({
-            inputDim: this.vocabSize,
-            outputDim: this.embedDim,
-            beta: beta,
-            threshold: threshold,
-            embeddingsInitializer: "glorot_normal"
-        });
-        
-        this.contextLayer = new SpikingDense({
-            units: this.embedDim,
-            beta: beta,
-            threshold: threshold,
-            useBias: true,
-            kernelInitializer: "glorot_normal"
-        });
-
-        this.add(this.embedding);
-        this.add(this.contextLayer);
-    }
-
-    public resetState() {
-        this.embedding.resetState();
-        this.contextLayer.resetState();
-    }
-
-    /**
-     * Membaca sebuah kalimat utuh dan mengubahnya menjadi Vektor Semantik tunggal (Spike Count)
-     * @param inputs Matrix Token ID dari kalimat (shape: [batch=1, seq_len])
-     * @param optionsOrTraining Opsi forward (tidak dipakai di SNN ini, tapi dibutuhkan oleh abstract method)
-     * @returns Matrix Vektor berukuran `[1, embedDim]` yang berisi total Spike (Representasi Makna Kalimat)
-     */
-    public forward(inputs: Matrix, optionsOrTraining?: any): Matrix {
-        if (!this.isBuilt) {
-            this.build([1, 1]); // SNN layer selalu memproses kata per kata
-        }
-        
-        this.resetState();
-        const semanticVector = new Float32Array(this.embedDim);
-        
-        const seqLen = inputs._shape.length > 1 ? inputs._shape[1] : inputs._shape[0];
-        const inputData = inputs._data;
-
-        for (let i = 0; i < seqLen; i++) {
-            const x = Matrix.fromFlat(new Float32Array([inputData[i]]), [1, 1]);
-            
-            // Default readingTime = 3 timestep
-            for (let t = 0; t < 3; t++) {
-                const wordSpikes = this.embedding.forward(x) as Matrix;
-                const contextSpikes = this.contextLayer.forward(wordSpikes) as Matrix;
-
-                const outData = contextSpikes._data;
-                for(let j=0; j<this.embedDim; j++) {
-                    semanticVector[j] += outData[j];
-                }
-            }
-        }
-        
-        return Matrix.fromFlat(semanticVector, [1, this.embedDim]);
-    }
-
-    /**
-     * Melatih model sentence embedder menggunakan prinsip Word2Vec CBOW-style Hebbian Contrastive Learning.
-     * Secara otomatis mengambil rata-rata vektor konteks kalimat saat ini (Positive), 
-     * dan menolaknya dari list mean vector negatif (NegativeContexts).
-     * Metode ini bypass context layer dan langsung melatih embedding untuk mencegah representation collapse.
-     * 
-     * @returns Float32Array rata-rata vektor (meanVec) dari kalimat saat ini yang dapat disimpan ke historyBuffer.
-     */
-    public learnContrastive(
-        tokens: number[] | Float32Array,
-        negativeContexts: Float32Array[],
-        learningRate: number = 0.01,
-        marginPositive: number = 0.1,
-        marginNegative: number = 0.05
-    ): Float32Array {
-        const wordEmbeddings: { tokenId: number, vec: Float32Array }[] = [];
-        const kernel = this.embedding.getParameter('kernel')!._data;
-        const dim = this.embedDim;
-        
-        for (let i = 0; i < tokens.length; i++) {
-            const tokenId = Math.round(tokens[i]);
-            if (tokenId >= 0 && tokenId < this.vocabSize) {
-                const offset = tokenId * dim;
-                const vec = new Float32Array(dim);
-                for (let j = 0; j < dim; j++) vec[j] = kernel[offset + j];
-                wordEmbeddings.push({ tokenId, vec });
-            }
-        }
-        
-        const meanVec = new Float32Array(dim);
-        if (wordEmbeddings.length > 0) {
-            for (const w of wordEmbeddings) {
-                for (let j = 0; j < dim; j++) meanVec[j] += w.vec[j];
-            }
-            for (let j = 0; j < dim; j++) meanVec[j] /= wordEmbeddings.length;
-
-            this.embedding.learnHebbian(
-                tokens, 
-                meanVec, 
-                negativeContexts, 
-                learningRate, 
-                marginPositive, 
-                marginNegative
-            );
-        }
-        
-        return meanVec;
-    }
-}