@misterscan/sesi 1.2.3 → 1.3.2

package/main/nn_personas_trainer.sesi

@@ -1,302 +0,0 @@
-// Sesi Script: nn_personas_trainer.sesi
-// 🧠 NATIVE NEURAL NETWORK PERSONA & DIALOGUE CLASSIFIER
-// Trains a 10x3 synapse network on 300 sentences from main/conversational_sentences.json,
-// then zero-shot evaluates and classifies the bios of all 20 personas in main/personas.json!
-
-print "=================================================="
-print "🧠 INITIATING Sesi NEURAL PERSONA & DIALOGUE 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: " + str(vocab)
-
-// 2. Load 300 conversational sentences
-print "📂 Loading main/conversational_sentences.json dataset..."
-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 "📊 Ingested " + str(num_sentences) + " sentences."
-
-// 3. Compile inputs and targets natively in Sesi
-print "🧹 Processing text sentences into Bag-of-Words feature matrices..."
-let inputs = []
-let targets = []
-
-let s_idx = 0
-while s_idx < num_sentences {
-  let sentence = sentences[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 has_audio = false
-  let has_mech = false
-  let has_sys = false
-  
-  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
-        if v_idx < 3 { has_audio = true }
-        if v_idx >= 3 {
-          if v_idx < 6 { has_mech = true }
-        }
-        if v_idx >= 6 { has_sys = true }
-      }
-      w = w + 1
-    }
-    
-    x[v_idx] = found
-    v_idx = v_idx + 1
-  }
-  
-  push(inputs, x)
-  
-  // Classify target label dynamically based on keywords or original indices
-  let t = [0.0, 0.0, 0.0]
-  if has_audio {
-    t[0] = 1.0
-  } else {
-    if has_mech {
-      t[1] = 1.0
-    } else {
-      if has_sys {
-        t[2] = 1.0
-      } else {
-        // Fallback default balanced targets using index slices
-        if s_idx < 100 { t[0] = 1.0 } // Audio
-        if s_idx >= 100 {
-          if s_idx < 200 { t[1] = 1.0 } // Mechanical
-        }
-        if s_idx >= 200 { t[2] = 1.0 } // Systems
-      }
-    }
-  }
-  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_sentences {
-    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_sentences * 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/conversational_classifier_weights.json", to_json(saved_weights))
-print "💾 Saved trained synapses to main/conversational_classifier_weights.json"
-print "--------------------------------------------------"
-
-// Helper to run forward pass inference on a block of text
-fn predict(bio_text) {
-  let words = split(bio_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 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 Personas and zero-shot evaluate them!
-print "👥 Loading main/personas.json for neural zero-shot evaluation..."
-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 "🔮 EVALUATING AND CLASSIFYING ALL 20 DEVELOPER PERSONAS:"
-print "--------------------------------------------------"
-
-let p_idx = 0
-while p_idx < num_personas {
-  let p = personas[p_idx]
-  let name = p["name"]
-  let bio = p["personality"] + " " + p["tone"]
-  
-  let pred = predict(bio)
-  
-  // Classify highest probability category index
-  let max_val = pred[0]
-  let predicted_class = "AUDIO"
-  
-  if pred[1] > max_val {
-    max_val = pred[1]
-    predicted_class = "MECHANICAL"
-  }
-  if pred[2] > max_val {
-    max_val = pred[2]
-    predicted_class = "SYSTEMS"
-  }
-  
-  print "[" + str(p_idx) + "] " + name + " ➜ Predicted: " + predicted_class + " [Audio: " + str(pred[0]) + ", Mech: " + str(pred[1]) + ", Sys: " + str(pred[2]) + "]"
-  p_idx = p_idx + 1
-}
-
-print "=================================================="

package/main/nn_responses_trainer.sesi

@@ -1,269 +0,0 @@
-// 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 "=================================================="