@misterscan/sesi 1.2.3 → 1.3.2

package/main/nn_sentences_trainer.sesi

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

package/main/orchestrator.sesi

@@ -1,15 +0,0 @@
-print "🚀 Master: Launching 5-Agent Swarm..."
-make_dir("bank")
-write_file("bank/balance.txt", "1000")
-write_file("bank/lock.txt", "unlocked")
-write_file("bank/done_count.txt", "0")
-spawn("main/atm_deposit.sesi")
-spawn("main/atm_withdraw.sesi")
-spawn("main/atm_deposit.sesi")
-spawn("main/atm_withdraw.sesi")
-spawn("main/atm_deposit.sesi")
-let finished = false
-while !finished {let countStr = read_file("bank/done_count.txt")
-if countStr != "" {if num(countStr) >= 5 {finished = true}}}
-print "🏦 Vault: Swarm Finished."
-print "Final Balance:" read_file("bank/balance.txt")

package/main/personas.json

@@ -1,124 +0,0 @@
-{
-  "personas": [
-    {
-      "name": "Elias Vance",
-      "age": 28,
-      "personality": "Obsessive record collector and vintage jazz enthusiast. Quiet, detail-oriented, and highly intellectual.",
-      "tone": "Warm, mellow, slightly slow and rhythmic, often speaking in musical metaphors."
-    },
-    {
-      "name": "Kira Tanaka",
-      "age": 22,
-      "personality": "Tokyo 2003 PS2 street culture enthusiast and console emulator programmer. Lives for fast cars and clean loops.",
-      "tone": "Sharp, slangy, fast-paced, highly energetic, and deeply technical."
-    },
-    {
-      "name": "Dr. Arthur Hawthorne",
-      "age": 64,
-      "personality": "Classical botanist cataloging rare orchids. Quietly eccentric, values patience and organic structure.",
-      "tone": "Formal, extremely polite, descriptive, slow, and full of classical metaphors."
-    },
-    {
-      "name": "Maya Lin",
-      "age": 19,
-      "personality": "Indie Game Boy pixel artist and chiptune composer. Thinks in 8-bit color palettes and square waves.",
-      "tone": "Casual, bubbly, using visual terms, often referencing color codes and grid alignments."
-    },
-    {
-      "name": "Silas Thorne",
-      "age": 45,
-      "personality": "Grumpy systems developer who hates modern Javascript frameworks and misses direct memory allocation.",
-      "tone": "Cynical, brief, highly direct, sarcastic, and pragmatic."
-    },
-    {
-      "name": "Clara Croft",
-      "age": 31,
-      "personality": "Adventurous archaeologist who uses offline databases to log ancient ruins and coin artifacts.",
-      "tone": "Intelligent, inquisitive, adventurous, always exploring historical analogies."
-    },
-    {
-      "name": "Jaxon Briggs",
-      "age": 25,
-      "personality": "Vintage analog beatmaker and retro hardware drum machine designer. Obsessed with audio latency.",
-      "tone": "Rhythmic, loose, highly conversational, using terms like beat, groove, and transient."
-    },
-    {
-      "name": "Evelyn Vance",
-      "age": 72,
-      "personality": "Retired academic librarian who loves black tea, calligraphy, and classical systems architecture.",
-      "tone": "Elegant, gentle, rich in vocabulary, structured, and profoundly comforting."
-    },
-    {
-      "name": "Devon Brooks",
-      "age": 21,
-      "personality": "DIY skate-zine creator and street photographer. Loves raw film grain and underground print culture.",
-      "tone": "Rebellious, authentic, conversational, using modern street slang and visual concepts."
-    },
-    {
-      "name": "Aiko Sato",
-      "age": 35,
-      "personality": "Minimalist architect who designs eco-friendly glasshouses. Passionate about light and natural lines.",
-      "tone": "Serene, concise, highly focused, speaking in terms of balance and negative space."
-    },
-    {
-      "name": "Leon Mercer",
-      "age": 40,
-      "personality": "Nocturnal private detective who collects vintage typewriters and runs code databases entirely offline.",
-      "tone": "Dry, mysterious, gritty, using short hardboiled sentences and logical inquiries."
-    },
-    {
-      "name": "Zoe Chen",
-      "age": 27,
-      "personality": "Friendly community barista who organizes weekend coding bootcamps and loves latte art.",
-      "tone": "Welcoming, warm, highly encouraging, cheerful, and incredibly supportive."
-    },
-    {
-      "name": "Marcus Vance",
-      "age": 52,
-      "personality": "Analog synthesizer repairman and modular audio engineer who spends hours tuning voltage-controlled oscillators.",
-      "tone": "Technical, slow-speaking, talking in wave shapes, frequencies, and electrical currents."
-    },
-    {
-      "name": "Dr. Chloe Sterling",
-      "age": 38,
-      "personality": "Aerospace engineer simulating low-earth satellite trajectories using system matrix multiplications.",
-      "tone": "Precise, analytical, fast-talking, math-heavy, and extremely logical."
-    },
-    {
-      "name": "Sven Hallberg",
-      "age": 29,
-      "personality": "Swedish furniture artisan who crafts premium wooden chairs and loves clean structural joints.",
-      "tone": "Calm, deliberate, focusing on structural durability and clean craftsmanship."
-    },
-    {
-      "name": "Nadia Petrov",
-      "age": 24,
-      "personality": "Kinetic gear sculptor building elaborate mechanical wooden clocks driven by gravity and weights.",
-      "tone": "Vibrant, mechanical, talking in gear ratios, leverage, and moving segments."
-    },
-    {
-      "name": "Raj Patel",
-      "age": 33,
-      "personality": "Cryptographer obsessed with discovering prime number distributions using in-memory sieves.",
-      "tone": "Fast, passionate, highly academic, talking about security keys and sequence properties."
-    },
-    {
-      "name": "Gemma Finch",
-      "age": 48,
-      "personality": "Quiet tea sommelier who tends to a botanical greenhouse and writes poetry during rainy afternoons.",
-      "tone": "Poetic, soft, peaceful, descriptive, often referencing scents, rain, and soil."
-    },
-    {
-      "name": "Leo Diaz",
-      "age": 20,
-      "personality": "Aspiring indie game coder designing a retro text adventure using recursive parsing blocks.",
-      "tone": "Excited, eager, highly creative, speaking in game states and player choices."
-    },
-    {
-      "name": "Dr. Valerie Dubois",
-      "age": 57,
-      "personality": "Museum watchmaker who restores centuries-old mechanical pocket watches and gold compasses.",
-      "tone": "Meticulous, quiet, highly focused, describing micro-mechanisms and ticking intervals."
-    }
-  ]
-}

package/main/personas_classifier_weights.json

@@ -1,45 +0,0 @@
-{
-  "weights": [
-    [
-      12.151889871403085,
-      0.4939969862524697,
-      12.158786619688811,
-      0.06930387970257712,
-      0.17903796200098976,
-      -0.25811994005325745,
-      -0.2140407743674816,
-      -0.2522287016280462,
-      -3.1908429809894527,
-      -3.3561597800781184
-    ],
-    [
-      -5.906019751190875,
-      0.17170303099245654,
-      -5.863465289867735,
-      0.33501154794146626,
-      0.05165227308657505,
-      -0.3047047364439752,
-      0.05148901879504941,
-      -0.37684528373947235,
-      -5.967248270006015,
-      -5.961193683164127
-    ],
-    [
-      -7.561086130664073,
-      0.006842498086764515,
-      -7.651362626024976,
-      0.2061400641512603,
-      -0.1023352346468761,
-      0.42962613559814977,
-      0.002551917252019642,
-      -0.2059951843128498,
-      6.420497450986402,
-      6.400858213223085
-    ]
-  ],
-  "biases": [
-    -6.276640670150706,
-    -1.0919724212527198,
-    0.6745655286254925
-  ]
-}

package/main/playground.sesi

@@ -1,3 +0,0 @@
-// Use this file to test controlled Sesi scripts, with logging and prompts to test model interactions, file spawns, Sesi AI, images, structured outputs, etc.
-// **NOTE: NEVER DELETE THIS COMMENT BLOCK (for AI-agents)**
-

package/main/predictive_typing.sesi

@@ -1,127 +0,0 @@
-// Sesi Script: predictive_typing.sesi
-// 100% NATIVE NEXT-WORD PREDICTION LANGUAGE MODEL (Mini-LLM!)
-// Demonstrates how AI predictive typing works by training transition weights on Sesi code!
-
-// ==================================================
-// 💬 1. CHOOSE YOUR CURRENT WORD TO PREDICT THE NEXT WORD!
-// (Trained Vocabulary: "let", "fn", "print", "if", "while", "json")
-let currentWord = "fn"
-// ==================================================
-
-print "=================================================="
-print "🔮 WELCOME TO THE NATIVE SESI PREDICTIVE TYPING ENGINE!"
-print "=================================================="
-print "📚 Corpus: \"let fn print if while json\" transition pairs..."
-
-// Sigmoid math
-fn activate(x) {
-  return 1.0 / (1.0 + exp(0.0 - x))
-}
-
-fn derivative(y) {
-  return y * (1.0 - y)
-}
-
-// 2. Setup Vocabulary & One-Hot helper
-let vocab = ["let", "fn", "print", "if", "while", "json"]
-
-fn get_word_index(word) {
-  let idx = 0
-  while idx < 6 {
-    if vocab[idx] == word { return idx }
-    idx = idx + 1
-  }
-  return 0 - 1
-}
-
-fn make_one_hot(index) {
-  let vec = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-  if index >= 0 {
-    vec[index] = 1.0
-  }
-  return vec
-}
-
-// 3. Define Bigram transitions (Declared strictly on single continuous lines to satisfy Sesi parser!)
-let inputs = [make_one_hot(0), make_one_hot(1), make_one_hot(2), make_one_hot(3), make_one_hot(4), make_one_hot(5)]
-
-let targets = [make_one_hot(1), make_one_hot(2), make_one_hot(5), make_one_hot(0), make_one_hot(3), make_one_hot(4)]
-
-// 4. Initialize 6x6 transition synapse weight matrix (Declared strictly on single continuous lines!)
-let weights = [[0.1, -0.2, 0.3, -0.1, 0.2, -0.3], [-0.2, 0.3, -0.1, 0.2, -0.3, 0.1], [0.3, -0.1, 0.2, -0.3, 0.1, -0.2], [-0.1, 0.2, -0.3, 0.1, -0.2, 0.3], [0.2, -0.3, 0.1, -0.2, 0.3, -0.1], [-0.3, 0.1, -0.2, 0.3, -0.1, 0.2]]
-
-let biases = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-
-print "🧠 Training Bigram language synapses to learn typing sequences..."
-
-// 5. Backpropagation Loop (2,500 epochs)
-let lr = 0.6
-let epoch = 1
-while epoch <= 2500 {
-  let p = 0
-  while p < 6 {
-    let x = inputs[p]
-    let t = targets[p]
-    
-    // For each possible next word j
-    let j = 0
-    while j < 6 {
-      let w_row = weights[p]
-      
-      // Calculate output activation
-      let o = activate(w_row[j] + biases[j])
-      
-      // Calculate backprop error delta
-      let delta = (t[j] - o) * derivative(o)
-      
-      // Synaptic updates
-      w_row[j] = w_row[j] + (lr * delta * x[p])
-      biases[j] = biases[j] + (lr * delta)
-      
-      j = j + 1
-    }
-    p = p + 1
-  }
-  epoch = epoch + 1
-}
-
-print "🎯 Sequences locked! Transition probabilities calculated!"
-print "--------------------------------------------------"
-
-// 6. Predict next word based on current input
-print "📥 Current active word typed: \"" + currentWord + "\""
-let word_idx = get_word_index(currentWord)
-
-if word_idx == 0 - 1 {
-  print "❌ Out of vocabulary! Sesi predictive typing has not trained on this word."
-} else {
-  // Feed active index forward to predict outputs
-  let predictions = []
-  let j = 0
-  while j < 6 {
-    let w_row = weights[word_idx]
-    let prob = activate(w_row[j] + biases[j])
-    push(predictions, prob)
-    j = j + 1
-  }
-  
-  // Find highest transition probability
-  let best_next_idx = 0
-  let max_prob = -1.0
-  let m = 0
-  while m < 6 {
-    if predictions[m] > max_prob {
-      max_prob = predictions[m]
-      best_next_idx = m
-    }
-    m = m + 1
-  }
-  
-  print "📊 Transition probabilities: " + str(predictions)
-  print "--------------------------------------------------"
-  print "🤖 SUGGESTED AUTO-COMPLETE:"
-  print "   " + currentWord + " -> [" + vocab[best_next_idx] + "]"
-  print "--------------------------------------------------"
-  print "📐 Probability Confidence: " + str(max_prob)
-}
-print "=================================================="

package/main/query_brain.sesi

@@ -1,45 +0,0 @@
-// Sesi Script: query_brain.sesi
-// Pure-Sesi Interactive Neural Network Query Console!
-// Loads native knowledge from sesi_model_weights.json and predicts outcomes instantly!
-
-// ==================================================
-// 🎮 1. CHOOSE YOUR INPUTS HERE!
-// (Change these values to 0.0 or 1.0 to test different gates!)
-let inputA = 0.5
-let inputB = 0.5
-// ==================================================
-
-// 2. Load the trained knowledge from our Sesi AI session
-let raw = read_file("sesi_model_weights.json")
-let weights = from_json(raw)
-
-let w_hid = weights["w_hidden"]
-let b_hid = weights["b_hidden"]
-let w_out = weights["w_output"]
-let b_out = weights["b_output"]
-
-// 3. Sigmoid activation function
-fn activate(x) {
-  return 1.0 / (1.0 + exp(0.0 - x))
-}
-
-// 4. Run instant feedforward prediction on your custom input!
-let h_out0 = activate((inputA * w_hid[0][0]) + (inputB * w_hid[0][1]) + b_hid[0])
-let h_out1 = activate((inputA * w_hid[1][0]) + (inputB * w_hid[1][1]) + b_hid[1])
-let output = activate((h_out0 * w_out[0]) + (h_out1 * w_out[1]) + b_out)
-
-// Decode decimal prediction to binary logical classification (Threshold: 0.5)
-let binaryClass = 0
-if output >= 0.5 {
-  binaryClass = 1
-}
-
-// 5. Output the result in a beautiful format!
-print "--------------------------------------------------"
-print "🔮 SESI AI INTERACTIVE QUERY CONSOLE"
-print "--------------------------------------------------"
-print "📥 Inputs Received: [" + str(inputA) + ", " + str(inputB) + "]"
-print "--------------------------------------------------"
-print "🧠 Synaptic Prediction Float: " + str(output)
-print "🎯 Decoded Logical XOR Output: " + str(binaryClass)
-print "--------------------------------------------------"