dreamwell-intelligence 1.0.0

// qgpt-train — Train QuantumGPT (The Loom).
//
// Usage: cargo run -p dreamwell-intelligence --bin qgpt-train --release
//
// The Loom weaves quantum threads into classical fabric.
// Density matrix attention × thermodynamic loss × φ-scaled causal dephasing.

use dreamwell_intelligence::checkpoint;
use dreamwell_intelligence::dataset::TokenDataset;
use dreamwell_intelligence::generate::generate;
use dreamwell_intelligence::metrics::TrainingReport;
use dreamwell_intelligence::train::{train, TrainConfig};
use dreamwell_intelligence::*;

fn main() {
    env_logger::init();

    println!("╔══════════════════════════════════════════════════════╗");
    println!("║  QuantumGPT — The Loom                              ║");
    println!("║  Density matrix attention × thermodynamic loss       ║");
    println!("║  φ-scaled causal dephasing × Born rule measurement   ║");
    println!("╚══════════════════════════════════════════════════════╝");
    println!();

    // Dataset
    let dataset = TokenDataset::shakespeare();
    println!(
        "Corpus: {} chars → {} tokens, vocab = {}",
        dataset::SHAKESPEARE.len(),
        dataset.len(),
        dataset.vocab_size()
    );

    // Model
    let dim = 5;
    let blocks = 2;
    let config = QCTConfig {
        vocab_size: dataset.vocab_size(),
        dim,
        num_blocks: blocks,
        seed: 42,
    };
    let mut model = QCT::new(config);
    println!(
        "Model: {} parameters (dim={}, blocks={}, vocab={})",
        model.num_params(),
        dim,
        blocks,
        dataset.vocab_size()
    );
    let initial_digest = checkpoint::model_digest(&model);
    println!(
        "Initial seal: {:02x}{:02x}{:02x}{:02x}...",
        initial_digest[0], initial_digest[1], initial_digest[2], initial_digest[3]
    );
    println!();

    // Train
    let epochs = 20; // reduced for demo — full training uses more
    println!(
        "Training ({} epochs, full-parameter shift gradient, cosine LR)...",
        epochs
    );
    println!();
    let train_config = TrainConfig {
        learning_rate: 0.03,
        num_epochs: epochs,
        context_length: 64,
        log_interval: 5,
        grad_clip: 5.0,
        use_cosine_decay: true,
        warmup_epochs: 3,
    };
    let epoch_metrics = train(&mut model, &dataset.tokens, &train_config);

    // Report
    let mut report = TrainingReport::new();
    report.total_tokens = dataset.len();
    for m in epoch_metrics {
        report.record(m);
    }
    println!();
    report.print_summary();
    println!();

    // Generate at different temperatures
    let prompt_text = "First Citizen:";
    let prompt = dataset.tokenizer.encode(prompt_text);

    for (name, temp) in [("Cold (0.3)", 0.3), ("Warm (0.8)", 0.8), ("Hot (1.5)", 1.5)] {
        let generated = generate(&model, &prompt, 100, temp, 42);
        let text = dataset.decode(&generated);
        println!("── {} ─────────────────────", name);
        println!("{}", text);
        println!();
    }

    // Seal
    let final_digest = checkpoint::model_digest(&model);
    println!(
        "Final seal: {:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
        final_digest[0],
        final_digest[1],
        final_digest[2],
        final_digest[3],
        final_digest[4],
        final_digest[5],
        final_digest[6],
        final_digest[7]
    );

    // Save checkpoint
    let ckpt_path = std::path::PathBuf::from("loom_checkpoint.quantumtensor");
    match checkpoint::save_checkpoint(&model, &ckpt_path) {
        Ok(()) => println!(
            "Checkpoint saved: {} ({} bytes)",
            ckpt_path.display(),
            std::fs::metadata(&ckpt_path).map(|m| m.len()).unwrap_or(0)
        ),
        Err(e) => println!("Checkpoint save failed: {e}"),
    }

    // CSV metrics
    let csv_path = std::path::PathBuf::from("qgpt_metrics.csv");
    match report.export_csv(&csv_path) {
        Ok(()) => println!("Metrics exported: {}", csv_path.display()),
        Err(e) => println!("Metrics export failed: {e}"),
    }

    println!();
    println!("{} parameters. The Loom weaves.", model.num_params());
}