Paragon AI Framework

📈 ADHD Performance (Train Set):
- 0-10%: 55,263 samples (98.68%)    ✅ Excellent predictions
- 10-20%: 108 samples (0.19%)       ✅ Good predictions  
- 20-30%: 65 samples (0.12%)        ⚠️  Moderate errors
- 30-40%: 50 samples (0.09%)        ⚠️  Moderate errors
- 40-50%: 43 samples (0.08%)        ⚠️  High errors
- 50-100%: 224 samples (0.40%)      ❌ Very high errors
- 100%+: 247 samples (0.44%)        ❌ Complete failures

📊 Overall ADHD Score: 99.13%
🎯 Classification Accuracy: 98.68%

// GPU-optimized float32 network
nnFloat32 := paragon.NewNetwork[float32](layerSizes, activations, connectivity)

// Memory-efficient int32 network  
nnInt32 := paragon.NewNetwork[int32](layerSizes, activations, connectivity)

// Ultra-compact int8 network for edge deployment
nnInt8 := paragon.NewNetwork[int8](layerSizes, activations, connectivity)

// Specialized uint32 network for positive-only data
nnUint32 := paragon.NewNetwork[uint32](layerSizes, activations, connectivity)

// Convert between types seamlessly
convertedNet, err := paragon.ConvertNetwork[float32, int32](nnFloat32)
if err == nil {
    fmt.Println("✅ Successfully converted float32 → int32 network")
}

// Enable WebGPU with automatic optimization
nn.WebGPUNative = true

// Initialize optimized GPU pipelines
if err := nn.InitializeOptimizedGPU(); err != nil {
    fmt.Printf("⚠️ GPU initialization failed: %v\n", err)
    fmt.Println("   Falling back to CPU computation...")
    nn.WebGPUNative = false
} else {
    fmt.Println("✅ WebGPU acceleration enabled")
    
    // GPU info and capabilities
    gpuInfo, _ := nn.GetAllGPUInfo()
    for _, gpu := range gpuInfo {
        fmt.Printf("🚀 Using: %s (%s)\n", gpu["name"], gpu["vendorName"])
        fmt.Printf("   Max Buffer: %s MB\n", gpu["maxBufferSizeMB"])
        fmt.Printf("   Compute Groups: %s\n", gpu["maxComputeInvocations"])
    }
    
    // Cleanup when done
    defer nn.CleanupOptimizedGPU()
}

// Training automatically uses GPU when available
nn.TrainWithGPUSync(inputs, targets, epochs, lr, false, clipUpper, clipLower)

// Forward pass with GPU acceleration
nn.Forward(testInput)

// Batch processing with GPU optimization
outputs, err := nn.ForwardBatch(batchInputs)

// Standard ADHD evaluation
expected := []float64{0, 1, 2, 1, 0} // Ground truth labels
actual := []float64{0, 1, 2, 0, 0}   // Model predictions
nn.EvaluateModel(expected, actual)

// Access detailed ADHD metrics
fmt.Printf("📊 ADHD Score: %.2f%%\n", nn.Performance.Score)
fmt.Printf("📈 Total Samples: %d\n", nn.Performance.Total)
fmt.Printf("❌ Failures (100%%+): %d\n", nn.Performance.Failures)

// Iterate through deviation buckets
for bucketName, bucket := range nn.Performance.Buckets {
    percentage := float64(bucket.Count) / float64(nn.Performance.Total) * 100
    fmt.Printf("   %s: %d samples (%.2f%%)\n", bucketName, bucket.Count, percentage)
}

// Advanced composite evaluation for detailed analysis
nn.EvaluateFull(expectedVector, actualVector)
nn.PrintFullDiagnostics()

// Sample-level performance for vector outputs
samplePerf := paragon.ComputePerSamplePerformance(
    expectedVectors, actualVectors, 
    0.01, // epsilon tolerance
    nn,
)
paragon.PrintSampleDiagnostics(samplePerf, 0.01)

// Basic network growth
improved := nn.Grow(
    checkpointLayer,    // Layer to checkpoint from
    testInputs,         // Test data for evaluation  
    expectedOutputs,    // Expected labels
    50,                 // Number of candidate architectures
    10,                 // Training epochs per candidate
    0.01,               // Learning rate
    1e-6,               // Convergence tolerance
    float32(2), float32(-2), // Gradient clipping
    16, 64,             // Width constraints (min, max)
    1, 4,               // Height constraints (min, max)
    []string{"relu", "leaky_relu", "swish", "gelu"}, // Activation pool
    4,                  // Max parallel threads
)

if improved {
    fmt.Println("🌱 Network successfully grown!")
    nn.PrintGrowthHistory()
} else {
    fmt.Println("⚠️ No improvement found")
}

// Advanced iterative NAS
bestNet, bestScore := nn.IterativeInitNAS(
    10,                 // Clones per round
    5,                  // NAS epochs
    0.001,              // Base learning rate
    0.1,                // Weight mutation rate
    false,              // Early stopping
    true,               // Allow activation mutations
    95.0,               // Target ADHD score
    5,                  // Max attempts
    inputs, targets,    // Training data
    float32(1), float32(-1), // Clipping bounds
)

fmt.Printf("🏆 Best NAS result: %.2f%% ADHD score\n", bestScore)

// Manual network architecture modification
nn.AddLayer(2, 128, 64, "relu", true)  // Insert layer at position 2
nn.AddNeuronsToLayer(1, 32)            // Add 32 neurons to layer 1

// Save growth history
nn.SaveGrowthLogJSON("./models/growth_log.json")

package main

import (
    "fmt"
    "github.com/openfluke/paragon/v3"
    "github.com/openfluke/pilot/experiments"
)

func main() {
    // Load MNIST dataset
    mnist := experiments.NewMNISTDatasetStage("./data/mnist")
    allInputs, allTargets, err := loadMNISTData("./data/mnist")
    if err != nil {
        panic(err)
    }
    
    // Split dataset 80/20
    trainInputs, trainTargets, testInputs, testTargets := 
        paragon.SplitDataset(allInputs, allTargets, 0.8)
    
    // Create optimized network
    nn := paragon.NewNetwork[float32](
        []struct{ Width, Height int }{28, 28}, {32, 32}, {10, 1},
        []string{"linear", "relu", "softmax"},
        []bool{true, true, true},
    )
    
    // Enable GPU acceleration
    nn.WebGPUNative = true
    if err := nn.InitializeOptimizedGPU(); err != nil {
        fmt.Printf("GPU unavailable: %v\n", err)
        nn.WebGPUNative = false
    }
    defer nn.CleanupOptimizedGPU()
    
    // Train with GPU synchronization
    nn.TrainWithGPUSync(trainInputs, trainTargets, 10, 0.05, 
        false, float32(2), float32(-2))
    
    // Evaluate with ADHD metrics
    expected := make([]float64, len(testInputs))
    actual := make([]float64, len(testInputs))
    
    for i, input := range testInputs {
        nn.Forward(input)
        output := nn.ExtractOutput()
        expected[i] = float64(paragon.ArgMax(testTargets[i][0]))
        actual[i] = float64(paragon.ArgMax(output))
    }
    
    nn.EvaluateModel(expected, actual)
    fmt.Printf("🎯 Test Accuracy: %.2f%%\n", nn.Performance.Score)
    
    // Save trained model
    nn.SaveJSON("./models/mnist_model.json")
}

// Comprehensive benchmark suite
results := paragon.RunAllBenchmarks(5 * time.Second)
fmt.Println("📊 Benchmark Results:")
fmt.Println(results)

// Type-specific benchmarks
float32Ops := paragon.BenchmarkNumericOps[float32]("float32", 
    2*time.Second, true)
int32Ops := paragon.BenchmarkNumericOps[int32]("int32", 
    2*time.Second, true)

fmt.Printf("Float32: %s ops/sec\n", formatNumber(float32Ops))
fmt.Printf("Int32: %s ops/sec\n", formatNumber(int32Ops))

// GPU device information
gpuInfo, err := paragon.GetAllGPUInfo()
if err == nil {
    for _, gpu := range gpuInfo {
        fmt.Printf("🚀 GPU: %s (%s)\n", gpu["name"], gpu["vendorName"])
        fmt.Printf("   Max Buffer: %s MB\n", gpu["maxBufferSizeMB"])
    }
}

// Advanced network growth with NAS
improved := nn.Grow(
    2,                  // Checkpoint layer
    validationInputs,   // Validation data
    validationLabels,   // Validation labels
    20,                 // Candidate architectures
    5,                  // Training epochs per candidate
    0.01,               // Learning rate
    1e-6,               // Convergence tolerance  
    float32(1), float32(-1), // Gradient clipping
    8, 128,             // Width constraints
    1, 8,               // Height constraints
    []string{"relu", "leaky_relu", "swish"}, // Activation pool
    4,                  // Parallel threads
)

if improved {
    fmt.Println("🌱 Network architecture improved!")
    nn.PrintGrowthHistory()
    
    // Save growth log
    nn.SaveGrowthLogJSON("growth_history.json")
} else {
    fmt.Println("⚠️ No architectural improvements found")
}

// Iterative NAS for maximum optimization
bestNet, bestScore := nn.IterativeInitNAS(
    15,     // Clones per iteration
    3,      // NAS epochs
    0.001,  // Base learning rate
    0.05,   // Weight mutation rate
    false,  // Early stopping
    true,   // Allow activation mutations
    98.0,   // Target ADHD score
    10,     // Maximum attempts
    trainInputs, trainTargets,
    float32(2), float32(-2),
)

fmt.Printf("🏆 Best NAS Score: %.2f%%\n", bestScore)