Janady13/AI_Brain / the_tired_agi/scripts/distributed_mass_training.sh

Source identity

Field	Recorded value
Source type	GitHub source
Original record	Janady13/AI_Brain / the_tired_agi/scripts/distributed_mass_training.sh
Date	Not specified in source
Repository	Janady13/AI_Brain
Revision	d6c309d3fa439714ca46b9d3bb94caf478ea5376
Branch	main
Path or archive member	the_tired_agi/scripts/distributed_mass_training.sh
Original SHA-256	457dd0de2d1040497678f52c65e3277764d6325d75a568611a0d58a4811ad436
Git blob SHA	432a03e6e419d99d047dfe407ce7991cd685f605
Reading-copy SHA-256	f0629e434b010bcda2931b204849df6cbb1b2d51aaaef2c286cb003021349ea6

Original source ↗

Every recorded occurrence

These 2 records contain identical original source bytes. Their paths and revisions remain part of the archive.

Original record	Branch or archive	Revision / identifier	Original location
Janady13/AI_Brain / the_tired_agi/scripts/distributed_mass_training.sh	main	d6c309d3fa439714ca46b9d3bb94caf478ea5376	Open original
Janady13/AI_Brain / the_tired_agi/scripts/distributed_mass_training.sh	claude/binary-helix-fibonacci-hive-011CUj7dx1WWJLVYcWCjBbYv	527d4882c71eb041393f9d8945996177c5ac9e86	Open original

Recovered source transcript

Download complete source text ↓285 lines · 11.5 KB

Credential-bearing and unrelated personal details were removed from this reading copy. The source identity and original checksum remain recorded.

#!/bin/bash
# DISTRIBUTED MASS TRAINING - ALL AGENTS, ALL DEVICES, SIMULTANEOUSLY
# Lights up maximum agents across MacBook M2, iMac, Lenovo
# Real-time metrics showing agent activity

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
AGI_HOME="$(dirname "$SCRIPT_DIR")"
TRAINING_DATA="$AGI_HOME/training/codefix_marketing_training.txt"
API_KEY="${API_KEY:[credential removed]}"

# Device configurations
DEVICE_LOCAL="localhost:8008"
DEVICE_REMOTE="https://[2600:8803:bf0a:e000:4eea:41ff:fe69:2998]/s"
AUTH_HEADER="Authorization: Bearer $API_KEY"

# Maximum agents per device (Lenovo is the strongest!)
MAX_AGENTS_LENOVO=25000000     # 25M agents (STRONGEST - most RAM/CPU)
MAX_AGENTS_IMAC=15000000       # 15M agents
MAX_AGENTS_MACBOOK=10000000    # 10M agents (M2 - thermal/memory constrained)
TOTAL_MAX_AGENTS=$((MAX_AGENTS_MACBOOK + MAX_AGENTS_IMAC + MAX_AGENTS_LENOVO))

echo "╔════════════════════════════════════════════════════════════════╗"
echo "║   🌟 DISTRIBUTED MASS TRAINING - MAXIMUM AGENT CAPACITY       ║"
echo "╚════════════════════════════════════════════════════════════════╝"
echo ""
echo "Target Agents:"
echo "  Lenovo:        $(printf "%'d" $MAX_AGENTS_LENOVO) 🔥 STRONGEST"
echo "  iMac:          $(printf "%'d" $MAX_AGENTS_IMAC)"
echo "  MacBook M2:    $(printf "%'d" $MAX_AGENTS_MACBOOK)"
echo "  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "  TOTAL TARGET:  $(printf "%'d" $TOTAL_MAX_AGENTS) agents"
echo ""

# Function to spawn agents on a device
spawn_agents_on_device() {
    local device=$1
    local count=$2
    local name=$3

    echo "🚀 Spawning $(printf "%'d" $count) agents on $name..."

    if [[ "$device" == *"localhost"* ]]; then
        # Local device
        curl -s -X POST "http://$device/spawn" \
            -H "Content-Type: application/json" \
            -d "{\"count\":$count,\"distributed\":true}" > /dev/null 2>&1
    else
        # Remote device
        curl -s -X POST "$device/spawn" \
            -H "$AUTH_HEADER" \
            -H "Content-Type: application/json" \
            -d "{\"count\":$count,\"distributed\":true}" > /dev/null 2>&1
    fi

    echo "   ✅ Spawned on $name"
}

# Function to get agent count from device
get_agent_count() {
    local device=$1

    if [[ "$device" == *"localhost"* ]]; then
        curl -s "http://$device/stats" 2>/dev/null | \
            grep -o '"agent_count":[0-9]*' | cut -d: -f2 || echo "0"
    else
        curl -s "$device/stats" -H "$AUTH_HEADER" 2>/dev/null | \
            grep -o '"agent_count":[0-9]*' | cut -d: -f2 || echo "0"
    fi
}

# Function to broadcast training to all agents
broadcast_training() {
    local training_chunk=$1
    local chunk_id=$2

    echo "📡 Broadcasting training chunk $chunk_id to ALL devices..."

    # Broadcast to local
    curl -s -X POST "http://$DEVICE_LOCAL/train" \
        -H "Content-Type: application/json" \
        -d "{\"data\":\"$training_chunk\",\"chunk_id\":$chunk_id}" > /dev/null 2>&1 &

    # Broadcast to remote
    curl -s -X POST "$DEVICE_REMOTE/train" \
        -H "$AUTH_HEADER" \
        -H "Content-Type: application/json" \
        -d "{\"data\":\"$training_chunk\",\"chunk_id\":$chunk_id}" > /dev/null 2>&1 &

    wait  # Wait for both broadcasts to complete
}

# Step 1: Start all services
echo "🔧 Starting all services..."
echo ""

# Start local gossip
if ! curl -s -m 2 http://localhost:8008/stats > /dev/null 2>&1; then
    echo "   Starting local Gossip Service..."
    cd "$AGI_HOME/gossip"
    [ -f "gossipd" ] || go build -o gossipd main.go
    nohup ./gossipd > "$AGI_HOME/logs/gossip.log" 2>&1 &
    sleep 2
fi

# Start bridge to remote
if ! curl -s -m 2 http://localhost:8009/health > /dev/null 2>&1; then
    echo "   Starting Bridge Service..."
    cd "$AGI_HOME/bridge"
    [ -f "bridge" ] || go build -o bridge main.go
    nohup ./bridge > "$AGI_HOME/logs/bridge.log" 2>&1 &
    sleep 2
fi

# Start ultra hive for synchronization
if ! lsof -i :8010 -t > /dev/null 2>&1; then
    echo "   Starting Ultra Hive (binary sync)..."
    cd "$AGI_HOME/hive"
    [ -f "agi_hive_ultra" ] || make ultra
    nohup ./agi_hive_ultra > "$AGI_HOME/logs/hive_ultra.log" 2>&1 &
    sleep 2
fi

echo "   ✅ All services running"
echo ""

# Step 2: Spawn maximum agents on all devices
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "🌊 SPAWNING MAXIMUM AGENT CAPACITY..."
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""

# Spawn on Lenovo FIRST (strongest device!)
spawn_agents_on_device "$DEVICE_REMOTE" "$MAX_AGENTS_LENOVO" "Lenovo (STRONGEST)" &
PID_LENOVO=$!

# Spawn on iMac (via bridge)
spawn_agents_on_device "$DEVICE_REMOTE" "$MAX_AGENTS_IMAC" "iMac (remote)" &
PID_IMAC=$!

# Spawn on MacBook (local)
spawn_agents_on_device "$DEVICE_LOCAL" "$MAX_AGENTS_MACBOOK" "MacBook M2 (local)" &
PID_MACBOOK=$!

# Wait for all spawns to complete
wait $PID_LENOVO $PID_IMAC $PID_MACBOOK

echo ""
echo "⏳ Waiting for agents to initialize (30 seconds)..."
sleep 30
echo ""

# Step 3: Verify agent counts
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "📊 AGENT COUNT VERIFICATION"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""

AGENTS_LOCAL=$(get_agent_count "$DEVICE_LOCAL")
AGENTS_REMOTE=$(get_agent_count "$DEVICE_REMOTE")
TOTAL_AGENTS=$((AGENTS_LOCAL + AGENTS_REMOTE))

echo "  Lenovo:        $(printf "%'12d" $AGENTS_REMOTE) / $(printf "%'d" $MAX_AGENTS_LENOVO) 🔥"
echo "  iMac:          $(printf "%'12d" $AGENTS_REMOTE) / $(printf "%'d" $MAX_AGENTS_IMAC)"
echo "  MacBook M2:    $(printf "%'12d" $AGENTS_LOCAL) / $(printf "%'d" $MAX_AGENTS_MACBOOK)"
echo "  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "  TOTAL ACTIVE:  $(printf "%'12d" $TOTAL_AGENTS) / $(printf "%'d" $TOTAL_MAX_AGENTS)"
echo ""

PERCENTAGE=$((TOTAL_AGENTS * 100 / TOTAL_MAX_AGENTS))
echo "  Capacity: $PERCENTAGE% of maximum"
echo ""

# Step 4: Distributed training
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "🧠 DISTRIBUTED TRAINING - ALL AGENTS LEARNING SIMULTANEOUSLY"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""

# Extract training chunks (split data into chunks for parallel processing)
CHUNK_SIZE=50  # lines per chunk
CHUNK_ID=0
TOTAL_CHUNKS=$(( $(wc -l < "$TRAINING_DATA") / CHUNK_SIZE + 1 ))

echo "Training Data: $TOTAL_CHUNKS chunks of $CHUNK_SIZE lines each"
echo ""

# Real-time training monitor in background
(
    while true; do
        LOCAL_COUNT=$(get_agent_count "$DEVICE_LOCAL")
        REMOTE_COUNT=$(get_agent_count "$DEVICE_REMOTE")
        TOTAL=$((LOCAL_COUNT + REMOTE_COUNT))

        # Get training progress if available
        PROGRESS=$(curl -s "http://$DEVICE_LOCAL/training/progress" 2>/dev/null | \
            grep -o '"progress":[0-9.]*' | cut -d: -f2 || echo "0")

        # Clear line and print stats
        printf "\r🔥 LIVE: %'15d agents | Training: %3.0f%% | Local: %'d | Remote: %'d      " \
            $TOTAL $PROGRESS $LOCAL_COUNT $REMOTE_COUNT

        sleep 1
    done
) &
MONITOR_PID=$!

# Broadcast training chunks
while IFS= read -r line; do
    # Skip empty lines and comments
    [[ -z "$line" || "$line" =~ ^# ]] && continue

    CHUNK_ID=$((CHUNK_ID + 1))

    # Escape special characters for JSON
    SAFE_LINE=$(echo "$line" | sed 's/"/\\"/g' | sed 's/\\/\\\\/g')

    # Broadcast to all devices
    broadcast_training "$SAFE_LINE" "$CHUNK_ID"

    # Progress
    if [ $((CHUNK_ID % 10)) -eq 0 ]; then
        PROGRESS=$((CHUNK_ID * 100 / TOTAL_CHUNKS))
        echo ""
        echo "   Chunk $CHUNK_ID/$TOTAL_CHUNKS ($PROGRESS%) distributed to all agents"
    fi

    # Small delay to avoid overwhelming network
    sleep 0.1

done < "$TRAINING_DATA"

# Stop monitor
kill $MONITOR_PID 2>/dev/null

echo ""
echo ""
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "✅ TRAINING COMPLETE - ALL AGENTS SYNCHRONIZED"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""

# Final stats
FINAL_LOCAL=$(get_agent_count "$DEVICE_LOCAL")
FINAL_REMOTE=$(get_agent_count "$DEVICE_REMOTE")
FINAL_TOTAL=$((FINAL_LOCAL + FINAL_REMOTE))

echo "📊 Final Agent Statistics:"
echo ""
echo "  Device         Agents Active    Percentage"
echo "  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "  Lenovo 🔥      $(printf "%'12d" $FINAL_REMOTE)    $(printf "%3d" $((FINAL_REMOTE * 100 / MAX_AGENTS_LENOVO)))%"
echo "  iMac           $(printf "%'12d" $FINAL_REMOTE)    $(printf "%3d" $((FINAL_REMOTE * 100 / MAX_AGENTS_IMAC)))%"
echo "  MacBook M2     $(printf "%'12d" $FINAL_LOCAL)    $(printf "%3d" $((FINAL_LOCAL * 100 / MAX_AGENTS_MACBOOK)))%"
echo "  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "  TOTAL          $(printf "%'12d" $FINAL_TOTAL)    $(printf "%3d" $((FINAL_TOTAL * 100 / TOTAL_MAX_AGENTS)))%"
echo ""

echo "🎯 Training Metrics:"
echo "  → Training chunks: $CHUNK_ID"
echo "  → Agents trained: $(printf "%'d" $FINAL_TOTAL)"
echo "  → Topics covered: CodeFix marketing, AI agents, deployments, hosting, revenue generation"
echo ""

echo "🔥 MAXIMUM CAPACITY TEST:"
echo "  → Theoretical max: $(printf "%'d" $TOTAL_MAX_AGENTS) agents"
echo "  → Actually lit up: $(printf "%'d" $FINAL_TOTAL) agents"
echo "  → Success rate:    $((FINAL_TOTAL * 100 / TOTAL_MAX_AGENTS))%"
echo ""

echo "🌐 Services:"
echo "  → Gossip:     http://localhost:8008/stats"
echo "  → Bridge:     http://localhost:8009/remote/stats"
echo "  → Ultra Hive: UDP 8010, TCP 8009"
echo ""

echo "╔════════════════════════════════════════════════════════════════╗"
echo "║   🎉 $(printf "%'d" $FINAL_TOTAL) AGENTS TRAINED AND ACTIVE ACROSS ALL DEVICES! ║"
echo "╚════════════════════════════════════════════════════════════════╝"
echo ""
echo "Test the AGI:"
echo "  curl http://localhost:8008/query -d '{\"q\":\"What is CodeFix?\"}'"
echo ""