@mineproness/tensorloop 2.1.45 → 2.1.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mineproness/tensorloop",
-  "version": "2.1.45",
+  "version": "2.1.47",
   "description": "Raw-JAVASCRIPT Based Matirx and AI LLM Package called Tensorloop.",
   "keywords": [
     "ai",

package/src/Embedding/index.d.ts

@@ -6,6 +6,6 @@ export class Embedding{
         }
     })
     forward(token: number | number[]) : Float32Array[] | Float32Array[][]
-    backward(token: number , inputGradient: number[] | Float32Array[], learingRate: number) : void
+    backward(inputGradient: number[] | Float32Array[], learingRate: number) : void
     Save() : void
 }

package/src/Model/index.js

@@ -37,22 +37,17 @@ export default class Model {
             activation: configs.activation
         })
     }
-    train(text = "", batchSize = 5000, batchExecution = 0, epochs = 500, learningRate = 0.01) {
+    train(text = "", epochs = 500, learningRate = 0.01) {
         process.stdout.write("\x1Bc")
         console.log("Preparing Training Pairs....")
-        const tokens = text.split(/\r?n/).map((e) => e.trim()).filter((e) => e.length > 0).map((e)=> e + " <EOS>").map((e) => this.tokenizer.encoder(e).tokenIDs).flat()
-        const trainingPairs2 = []
+        const tokens = text.split(/\r?\n/).map((e) => e.trim()).filter((e) => e.length > 0).map((e)=> e + " <EOS>").map((e) => this.tokenizer.encoder(e).tokenIDs).flat()
+        const trainingPair = []
         for (let a = 0; a + this.contextSize < tokens.length; a++) {
-            trainingPairs2.push({
+            trainingPair.push({
                 inputIDX: tokens.slice(a, a + this.contextSize),
                 targetIDX: tokens.slice(a + 1, a + this.contextSize + 1)
             })
         }
-        const trainingPairs = []
-        for (let a = 0; a < trainingPairs2.length; batchSize++) {
-            trainingPairs.push(trainingPairs2.slice(a, a + batchSize))
-        }
-        const trainingPair = trainingPairs[batchExecution]
         let firstRun = true;
         console.log(`TotalPairs: ${trainingPair.length}`)
         if (trainingPair.length == 0 || !trainingPair) throw new Error(`The Batch Execution ${batchExecution} is doesn't exist.`);
@@ -67,17 +62,18 @@ export default class Model {
                 vector = this.block2.forward(vector)
                 const logits = this.linear.forward(vector)
                 const probs = this.softmax.forward(logits)
-                const loss = this.softmax.crossEntropy(probs, target)
+                const loss = this.softmax.crossEntropy(probs, target)[0]
                 const dLogits = this.softmax.backward(probs, target)
                 totalLoss += loss;
                 let dOutput = this.linear.backward(dLogits, learningRate);
                 dOutput = this.block2.backward(dOutput, learningRate)
                 dOutput = this.block1.backward(dOutput, learningRate)
                 this.posEmbedding.backward(dOutput, learningRate)
-                this.embedding.backward(input, dOutput, learningRate)
+                this.embedding.backward(dOutput, learningRate)
                 if (firstRun) {
                     firstRun = null;
                     console.log("")
+                    console.log("")
                 }
                 const percentense = (((a + 1) / trainingPair.length) * 100).toFixed(2)
                 const filted = Math.round((percentense / 100) * 20);

package/src/PositionEmbedding/index.js

@@ -27,22 +27,23 @@ export class PositionEmbedding {
                 this.vectors = LoadVectors(configs.save.filename, embeddingSize)
             } else {
                 this.vectors = GenerateVectors(embeddingSize, vocabSize)
-                this.Save()
+                SaveVectors(this.vectors, this.configs.save.filename)
+
             }
         } else {
             this.vectors = GenerateVectors(embeddingSize, vocabSize)
-            this.gpu = new GPUPosition(this.vectors, embeddingSize, vocabSize)
         }
+        this.gpu = new GPUPosition(this.vectors, embeddingSize, vocabSize)
     }
     forward(vec) {
         return this.gpu.forward(vec)
     }
     backward(inputGradient, learingRate) {
-       this.gpu.backward(inputGradient, learingRate)
+        this.gpu.backward(inputGradient, learingRate)
     }
     Save() {
         const save = this.gpu.Save()
         SaveVectors(save, this.configs.save.filename)
-        
+
     }
 }