Crate omega_meta_sona 

Omega Meta-SONA

Self-Organizing Neural Architecture (META-SONA) - The intelligence design engine for ExoGenesis Omega.

Overview

META-SONA is the component that enables ExoGenesis Omega to design new cognitive architectures. While SONA optimizes weights within a fixed architecture, META-SONA optimizes the architecture itself.

Features

• Architecture Search: Monte Carlo Tree Search (MCTS) for exploring architecture space
• Hyperparameter Optimization: Proximal Policy Optimization (PPO) for tuning
• Multi-Objective Fitness: Evaluation across capability, efficiency, alignment, and novelty
• Intelligence Factory: Create and evolve intelligences from specifications

Architecture

                   ┌─────────────────────┐
                   │   META-SONA         │
                   └──────────┬──────────┘
                              │
         ┌────────────────────┼────────────────────┐
         │                    │                    │
         ▼                    ▼                    ▼
┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐
│ Architecture    │  │ Intelligence    │  │  Fitness        │
│ Search (MCTS)   │  │ Factory         │  │  Evaluation     │
└─────────────────┘  └─────────────────┘  └─────────────────┘
         │                    │                    │
         ▼                    ▼                    ▼
┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐
│ PPO             │  │ Architecture    │  │  Benchmarks     │
│ Optimization    │  │ Space           │  │  & Metrics      │
└─────────────────┘  └─────────────────┘  └─────────────────┘

Usage

use omega_meta_sona::{IntelligenceFactory, IntelligenceSpec};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create factory
    let mut factory = IntelligenceFactory::new();

    // Define specification
    let spec = IntelligenceSpec {
        name: "My AI".to_string(),
        min_capability: 0.8,
        ..Default::default()
    };

    // Create intelligence
    let intelligence = factory.create_intelligence(spec).await?;

    println!("Created: {} with fitness {:.2}",
        intelligence.name,
        intelligence.architecture.fitness.unwrap().overall
    );

    Ok(())
}

Components

Architecture Module

Defines how architectures are represented and encoded:

• ArchitectureSpace: The space of all possible architectures
• ArchitectureEncoding: Vector representations for optimization
• ComputationalGraph: Graph structure of neural architectures

Search Module

Algorithms for discovering architectures:

• MCTS: Monte Carlo Tree Search with UCB1 selection
• Parallel simulations and rollouts
• Architecture-specific exploration bonuses

Optimization Module

Refinement of discovered architectures:

• PPOOptimizer: Proximal Policy Optimization
• Generalized Advantage Estimation (GAE)
• Clipped surrogate objectives

Fitness Module

Multi-objective evaluation:

• Capability evaluation (benchmarks)
• Efficiency evaluation (resource usage)
• Alignment evaluation (safety tests)
• Novelty evaluation (innovation metrics)

Factory Module

Intelligence creation and evolution:

• IntelligenceFactory: Main API for creating intelligences
• Specification-based creation
• Multi-generation evolution

Re-exports

pub use architecture::ArchitectureSpace;

pub use architecture::ArchitectureEncoding;

pub use architecture::ArchitectureNode;

pub use architecture::NodeType;

pub use architecture::Parameters;

pub use architecture::Connection;

pub use architecture::ComputationalGraph;

pub use search::MCTS;

pub use search::MCTSConfig;

pub use search::MCTSError;

pub use optimization::PPOOptimizer;

pub use optimization::PPOConfig;

pub use optimization::Trajectory;

pub use optimization::OptimizationResult;

pub use fitness::FitnessEvaluator;

pub use fitness::MetricWeight;

pub use fitness::EvaluationError;

pub use factory::IntelligenceFactory;

pub use factory::IntelligenceSpec;

pub use factory::FactoryError;

Modules

architecture

Architecture space representation for META-SONA

factory

Intelligence factory for creating and evolving intelligences

fitness

Fitness evaluation for architectures

optimization

Architecture optimization algorithms

search

Architecture search algorithms

Structs

MetaSONA

Meta-SONA orchestrator - main entry point

Constants

VERSION

Version information

Type Aliases

Result

Result type for META-SONA operations