@misterscan/sesi 1.1.1 → 1.2.0

package/main/nn_responses_trainer.sesi

@@ -0,0 +1,269 @@
+// Sesi Script: nn_responses_trainer.sesi
+// 🧠 NATIVE DEEP LEARNING RESPONSE CLASSIFIER TRAINER
+// Compiles Bag-of-Words feature vectors from main/varied_responses.json,
+// trains a 10x3 dynamic neural synapse matrix over 1500 gradient descent epochs,
+// saves weights to disk, and tests custom prediction sentences!
+
+print "=================================================="
+print "🧠 INITIATING Sesi DEEP LEARNING RESPONSE TRAINER"
+print "=================================================="
+
+// Custom integer floor function
+fn floor(x) {
+  let s = str(x)
+  let parts = split(s, ".")
+  return num(parts[0])
+}
+
+// Fast Sigmoid (Softsign) activation
+fn activate(x) {
+  let absX = x
+  if x < 0.0 {
+    absX = 0.0 - x
+  }
+  return 0.5 + (0.5 * (x / (1.0 + absX)))
+}
+
+fn activate_derivative(y) {
+  return y * (1.0 - y)
+}
+
+// 1. Define 10-keyword Vocabulary for Bag-of-Words vectors
+let vocab = ["synthesizer", "vinyl", "record", "wood", "gears", "clock", "compiler", "framework", "memory", "offline"]
+print "📚 Vocabulary Features Index: " + str(vocab)
+
+// 2. Load 300 responses
+print "📂 Loading main/varied_responses.json dataset..."
+let raw_responses = read_file("main/varied_responses.json")
+let parsed = from_json(raw_responses)
+let responses = parsed["responses"]
+let num_responses = len(responses)
+print "📊 Ingested " + str(num_responses) + " sentences."
+
+// 3. Compile inputs and targets natively in Sesi
+print "🧹 Processing text sentences into Bag-of-Words numerical vectors..."
+let inputs = []
+let targets = []
+
+let s_idx = 0
+while s_idx < num_responses {
+  let sentence = responses[s_idx]
+  let words = split(sentence, " ")
+  let w_len = len(words)
+  
+  // 10-dimensional input vector
+  let x = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+  
+  let v_idx = 0
+  while v_idx < 10 {
+    let keyword = vocab[v_idx]
+    let found = 0.0
+    
+    let w = 0
+    while w < w_len {
+      let raw_word = words[w]
+      let word = raw_word
+      let w_char_len = len(word)
+      
+      if w_char_len > 1 {
+        let last_char = word[w_char_len - 1]
+        if last_char == "." { word = split(word, ".")[0] }
+        if last_char == "!" { word = split(word, "!")[0] }
+        if last_char == "?" { word = split(word, "?")[0] }
+        if last_char == "," { word = split(word, ",")[0] }
+      }
+      
+      if word == keyword {
+        found = 1.0
+      }
+      w = w + 1
+    }
+    
+    x[v_idx] = found
+    v_idx = v_idx + 1
+  }
+  
+  push(inputs, x)
+  
+  // One-Hot Target Vector [Audio, Mechanical, Systems]
+  let t = [0.0, 0.0, 0.0]
+  if s_idx < 100 {
+    t[0] = 1.0 // Audio Class
+  }
+  if s_idx >= 100 {
+    if s_idx < 200 {
+      t[1] = 1.0 // Mechanical Class
+    }
+  }
+  if s_idx >= 200 {
+    t[2] = 1.0 // Systems Class
+  }
+  push(targets, t)
+  
+  s_idx = s_idx + 1
+}
+
+print "✅ Dataset vectorization complete!"
+print "--------------------------------------------------"
+
+// 4. Initialize 10x3 Synapse Matrix
+print "🎲 Initializing 10x3 random neural synapses..."
+let weights = []
+let biases = []
+
+let c = 0
+while c < 3 {
+  let w_row = []
+  let k = 0
+  while k < 10 {
+    let w_val = random() - 0.5
+    push(w_row, w_val)
+    k = k + 1
+  }
+  push(weights, w_row)
+  push(biases, 0.0)
+  c = c + 1
+}
+
+// 5. Backpropagation Epoch Training Loop
+let lr = 0.3
+let max_epochs = 1500
+print "🚀 Training synapses across " + str(max_epochs) + " epochs (lr = " + str(lr) + ")..."
+
+let epoch = 1
+while epoch <= max_epochs {
+  let total_loss = 0.0
+  let sample_idx = 0
+  
+  while sample_idx < num_responses {
+    let x = inputs[sample_idx]
+    let t = targets[sample_idx]
+    
+    // Outputs container
+    let outputs = [0.0, 0.0, 0.0]
+    let deltas = [0.0, 0.0, 0.0]
+    
+    // Forward Pass
+    let c_idx = 0
+    while c_idx < 3 {
+      let sum = 0.0
+      let w_row = weights[c_idx]
+      let k = 0
+      while k < 10 {
+        sum = sum + (x[k] * w_row[k])
+        k = k + 1
+      }
+      let o = activate(sum + biases[c_idx])
+      outputs[c_idx] = o
+      
+      // Calculate Loss and Delta
+      let err = t[c_idx] - o
+      total_loss = total_loss + (err * err)
+      deltas[c_idx] = err * activate_derivative(o)
+      
+      c_idx = c_idx + 1
+    }
+    
+    // Backpropagation Gradient Weight Updates
+    c_idx = 0
+    while c_idx < 3 {
+      let w_row = weights[c_idx]
+      let delta = deltas[c_idx]
+      let k = 0
+      while k < 10 {
+        w_row[k] = w_row[k] + (lr * delta * x[k])
+        k = k + 1
+      }
+      biases[c_idx] = biases[c_idx] + (lr * delta)
+      c_idx = c_idx + 1
+    }
+    
+    sample_idx = sample_idx + 1
+  }
+  
+  let avg_loss = total_loss / (num_responses * 3.0)
+  
+  if (epoch % 300) == 0 {
+    print "Epoch " + str(epoch) + " - Average Class Loss: " + str(avg_loss)
+  }
+  
+  epoch = epoch + 1
+}
+
+print "--------------------------------------------------"
+print "🎉 Synapse Epoch Training Complete!"
+print "--------------------------------------------------"
+
+// 6. Save calibrated synapses to JSON
+let saved_weights = {}
+saved_weights["weights"] = weights
+saved_weights["biases"] = biases
+write_file("main/response_classifier_weights.json", to_json(saved_weights))
+print "💾 Saved trained dynamic synapses to main/response_classifier_weights.json"
+print "--------------------------------------------------"
+
+// 7. Test calibrated network predictions
+print "🔮 Testing Tuned Predictions on new inputs:"
+
+// Helper to run offline forward pass inference
+fn predict(test_sentence) {
+  let words = split(test_sentence, " ")
+  let w_len = len(words)
+  let x = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+  
+  let v_idx = 0
+  while v_idx < 10 {
+    let keyword = vocab[v_idx]
+    let found = 0.0
+    let w = 0
+    while w < w_len {
+      let raw_word = words[w]
+      let word = raw_word
+      let w_char_len = len(word)
+      if w_char_len > 1 {
+        let last_char = word[w_char_len - 1]
+        if last_char == "." { word = split(word, ".")[0] }
+        if last_char == "!" { word = split(word, "!")[0] }
+      }
+      if word == keyword {
+        found = 1.0
+      }
+      w = w + 1
+    }
+    x[v_idx] = found
+    v_idx = v_idx + 1
+  }
+  
+  // Forward pass through trained weights
+  let predictions = [0.0, 0.0, 0.0]
+  let c_idx = 0
+  while c_idx < 3 {
+    let sum = 0.0
+    let w_row = weights[c_idx]
+    let k = 0
+    while k < 10 {
+      sum = sum + (x[k] * w_row[k])
+      k = k + 1
+    }
+    predictions[c_idx] = activate(sum + biases[c_idx])
+    c_idx = c_idx + 1
+  }
+  return predictions
+}
+
+let test_1 = "My analog modular synthesizer uses voltage filters."
+let pred_1 = predict(test_1)
+print "Input 1: \"" + test_1 + "\""
+print "  ➜ Predictions: [Audio: " + str(pred_1[0]) + ", Mechanical: " + str(pred_1[1]) + ", Systems: " + str(pred_1[2]) + "]"
+
+let test_2 = "The wooden clock gears align beautifully."
+let pred_2 = predict(test_2)
+print "Input 2: \"" + test_2 + "\""
+print "  ➜ Predictions: [Audio: " + str(pred_2[0]) + ", Mechanical: " + str(pred_2[1]) + ", Systems: " + str(pred_2[2]) + "]"
+
+let test_3 = "Our native Sesi compiler is optimized completely offline."
+let pred_3 = predict(test_3)
+print "Input 3: \"" + test_3 + "\""
+print "  ➜ Predictions: [Audio: " + str(pred_3[0]) + ", Mechanical: " + str(pred_3[1]) + ", Systems: " + str(pred_3[2]) + "]"
+
+print "=================================================="

package/main/nn_sentences_trainer.sesi

@@ -0,0 +1,330 @@
+// Sesi Script: nn_sentences_trainer.sesi
+// 🧠 NATIVE NEURAL NETWORK SENTENCE CLASSIFIER (TRAINED ON PERSONAS)
+// Trains a 10x3 synapse network on the 20 personas inside main/personas.json,
+// then zero-shot classifies all 300 conversational sentences in main/conversational_sentences.json!
+
+print "=================================================="
+print "🧠 INITIATING Sesi NEURAL DIALOGUE CLASSIFIER"
+print "=================================================="
+
+// Custom integer floor function
+fn floor(x) {
+  let s = str(x)
+  let parts = split(s, ".")
+  return num(parts[0])
+}
+
+// Fast Sigmoid (Softsign) activation
+fn activate(x) {
+  let absX = x
+  if x < 0.0 {
+    absX = 0.0 - x
+  }
+  return 0.5 + (0.5 * (x / (1.0 + absX)))
+}
+
+fn activate_derivative(y) {
+  return y * (1.0 - y)
+}
+
+// 1. Define 10-keyword Vocabulary for Bag-of-Words vectors
+let vocab = ["synthesizer", "vinyl", "record", "wood", "gears", "clock", "compiler", "framework", "memory", "offline"]
+print "📚 Vocabulary Features: " + str(vocab)
+
+// 2. Load 20 Personas Database
+print "📂 Loading main/personas.json dataset..."
+let raw_personas = read_file("main/personas.json")
+let parsed_personas = from_json(raw_personas)
+let personas = parsed_personas["personas"]
+let num_personas = len(personas)
+print "👥 Loaded " + str(num_personas) + " personas."
+
+// Helper to determine persona category class natively
+fn get_persona_category(persona) {
+  let p = persona["personality"]
+  let t = persona["tone"]
+  let combined = p + " " + t
+  let words = split(combined, " ")
+  let w_len = len(words)
+  
+  let w = 0
+  while w < w_len {
+    let word = words[w]
+    if word == "synthesizer" { return "audio" }
+    if word == "vinyl" { return "audio" }
+    if word == "record" { return "audio" }
+    if word == "jazz" { return "audio" }
+    if word == "beatmaker" { return "audio" }
+    if word == "music" { return "audio" }
+    if word == "audio" { return "audio" }
+    if word == "chiptune" { return "audio" }
+    
+    if word == "wood" { return "mechanical" }
+    if word == "furniture" { return "mechanical" }
+    if word == "watch" { return "mechanical" }
+    if word == "clock" { return "mechanical" }
+    if word == "gears" { return "mechanical" }
+    if word == "Game" { return "mechanical" }
+    if word == "Boy" { return "mechanical" }
+    if word == "botanist" { return "mechanical" }
+    if word == "architect" { return "mechanical" }
+    w = w + 1
+  }
+  return "systems"
+}
+
+// 3. Compile inputs and targets from Personas
+print "🧹 Processing persona bio descriptions into training matrices..."
+let inputs = []
+let targets = []
+
+let p_idx = 0
+while p_idx < num_personas {
+  let p = personas[p_idx]
+  let bio = p["personality"] + " " + p["tone"]
+  let words = split(bio, " ")
+  let w_len = len(words)
+  
+  // 10-dimensional input vector
+  let x = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+  
+  let v_idx = 0
+  while v_idx < 10 {
+    let keyword = vocab[v_idx]
+    let found = 0.0
+    let w = 0
+    while w < w_len {
+      let raw_word = words[w]
+      let word = raw_word
+      let w_char_len = len(word)
+      if w_char_len > 1 {
+        let last_char = word[w_char_len - 1]
+        if last_char == "." { word = split(word, ".")[0] }
+        if last_char == "," { word = split(word, ",")[0] }
+      }
+      if word == keyword {
+        found = 1.0
+      }
+      w = w + 1
+    }
+    x[v_idx] = found
+    v_idx = v_idx + 1
+  }
+  push(inputs, x)
+  
+  // One-Hot Target Class mapping [Audio, Mechanical, Systems]
+  let cat = get_persona_category(p)
+  let t = [0.0, 0.0, 0.0]
+  if cat == "audio" { t[0] = 1.0 }
+  if cat == "mechanical" { t[1] = 1.0 }
+  if cat == "systems" { t[2] = 1.0 }
+  push(targets, t)
+  
+  p_idx = p_idx + 1
+}
+
+print "✅ Persona vectorization complete!"
+print "--------------------------------------------------"
+
+// 4. Initialize 10x3 Synapse Matrix
+print "🎲 Initializing 10x3 random neural synapses..."
+let weights = []
+let biases = []
+
+let c = 0
+while c < 3 {
+  let w_row = []
+  let k = 0
+  while k < 10 {
+    let w_val = random() - 0.5
+    push(w_row, w_val)
+    k = k + 1
+  }
+  push(weights, w_row)
+  push(biases, 0.0)
+  c = c + 1
+}
+
+// 5. Backpropagation Epoch Training Loop (2500 epochs for high convergence on 20 samples)
+let lr = 0.3
+let max_epochs = 2500
+print "🚀 Training synapses across " + str(max_epochs) + " epochs (lr = " + str(lr) + ")..."
+
+let epoch = 1
+while epoch <= max_epochs {
+  let total_loss = 0.0
+  let sample_idx = 0
+  
+  while sample_idx < num_personas {
+    let x = inputs[sample_idx]
+    let t = targets[sample_idx]
+    
+    // Outputs container
+    let outputs = [0.0, 0.0, 0.0]
+    let deltas = [0.0, 0.0, 0.0]
+    
+    // Forward Pass
+    let c_idx = 0
+    while c_idx < 3 {
+      let sum = 0.0
+      let w_row = weights[c_idx]
+      let k = 0
+      while k < 10 {
+        sum = sum + (x[k] * w_row[k])
+        k = k + 1
+      }
+      let o = activate(sum + biases[c_idx])
+      outputs[c_idx] = o
+      
+      // Calculate Loss and Delta
+      let err = t[c_idx] - o
+      total_loss = total_loss + (err * err)
+      deltas[c_idx] = err * activate_derivative(o)
+      
+      c_idx = c_idx + 1
+    }
+    
+    // Backpropagation Gradient Weight Updates
+    c_idx = 0
+    while c_idx < 3 {
+      let w_row = weights[c_idx]
+      let delta = deltas[c_idx]
+      let k = 0
+      while k < 10 {
+        w_row[k] = w_row[k] + (lr * delta * x[k])
+        k = k + 1
+      }
+      biases[c_idx] = biases[c_idx] + (lr * delta)
+      c_idx = c_idx + 1
+    }
+    sample_idx = sample_idx + 1
+  }
+  
+  let avg_loss = total_loss / (num_personas * 3.0)
+  
+  if (epoch % 500) == 0 {
+    print "Epoch " + str(epoch) + " - Average Class Loss: " + str(avg_loss)
+  }
+  
+  epoch = epoch + 1
+}
+
+print "--------------------------------------------------"
+print "🎉 Synapse Epoch Training Complete!"
+print "--------------------------------------------------"
+
+// 6. Save calibrated synapses to JSON
+let saved_weights = {}
+saved_weights["weights"] = weights
+saved_weights["biases"] = biases
+write_file("main/personas_classifier_weights.json", to_json(saved_weights))
+print "💾 Saved trained synapses to main/personas_classifier_weights.json"
+print "--------------------------------------------------"
+
+// Helper to run forward pass inference on a text sentence
+fn predict(sentence_text) {
+  let words = split(sentence_text, " ")
+  let w_len = len(words)
+  let x = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+  
+  let v_idx = 0
+  while v_idx < 10 {
+    let keyword = vocab[v_idx]
+    let found = 0.0
+    let w = 0
+    while w < w_len {
+      let raw_word = words[w]
+      let word = raw_word
+      let w_char_len = len(word)
+      if w_char_len > 1 {
+        let last_char = word[w_char_len - 1]
+        if last_char == "." { word = split(word, ".")[0] }
+        if last_char == "!" { word = split(word, "!")[0] }
+        if last_char == "?" { word = split(word, "?")[0] }
+        if last_char == "," { word = split(word, ",")[0] }
+      }
+      if word == keyword {
+        found = 1.0
+      }
+      w = w + 1
+    }
+    x[v_idx] = found
+    v_idx = v_idx + 1
+  }
+  
+  // Forward pass
+  let predictions = [0.0, 0.0, 0.0]
+  let c_idx = 0
+  while c_idx < 3 {
+    let sum = 0.0
+    let w_row = weights[c_idx]
+    let k = 0
+    while k < 10 {
+      sum = sum + (x[k] * w_row[k])
+      k = k + 1
+    }
+    predictions[c_idx] = activate(sum + biases[c_idx])
+    c_idx = c_idx + 1
+  }
+  return predictions
+}
+
+// 7. Load Conversational Sentences and zero-shot evaluate all 300!
+print "📂 Loading main/conversational_sentences.json dataset for sentence classification..."
+let raw_conversations = read_file("main/conversational_sentences.json")
+let parsed_conv = from_json(raw_conversations)
+let sentences = parsed_conv["sentences"]
+let num_sentences = len(sentences)
+
+print "🔮 ZERO-SHOT EVALUATING 300 CONVERSATIONAL SENTENCES:"
+print "--------------------------------------------------"
+
+let audio_count = 0
+let mech_count = 0
+let sys_count = 0
+
+let s_idx = 0
+while s_idx < num_sentences {
+  let sentence = sentences[s_idx]
+  let pred = predict(sentence)
+  
+  let max_val = pred[0]
+  let pred_class = "AUDIO"
+  if pred[1] > max_val {
+    max_val = pred[1]
+    pred_class = "MECHANICAL"
+  }
+  if pred[2] > max_val {
+    max_val = pred[2]
+    pred_class = "SYSTEMS"
+  }
+  
+  if pred_class == "AUDIO" { audio_count = audio_count + 1 }
+  if pred_class == "MECHANICAL" { mech_count = mech_count + 1 }
+  if pred_class == "SYSTEMS" { sys_count = sys_count + 1 }
+  
+  // Log first 6 sentences of each 100-sentence slice as representation samples
+  let log_item = false
+  if s_idx < 6 { log_item = true }
+  if s_idx >= 100 {
+    if s_idx < 106 { log_item = true }
+  }
+  if s_idx >= 200 {
+    if s_idx < 206 { log_item = true }
+  }
+  
+  if log_item {
+    print "[" + str(s_idx) + "] \"" + sentence + "\""
+    print "    ➜ Classified: " + pred_class + " [Audio: " + str(pred[0]) + ", Mech: " + str(pred[1]) + ", Sys: " + str(pred[2]) + "]"
+    print ""
+  }
+  
+  s_idx = s_idx + 1
+}
+
+print "--------------------------------------------------"
+print "📊 FINAL SENTENCE CLASS DISTRIBUTION STATS:"
+print "🎧 AUDIO SENTENCES:       " + str(audio_count)
+print "⚙️  MECHANICAL SENTENCES:  " + str(mech_count)
+print "🖥️  SYSTEMS/GEN SENTENCES: " + str(sys_count)
+print "=================================================="