Struct QuantumMemoryConfig 

pub struct QuantumMemoryConfig {
    pub memory_size: usize,
    pub associative_memory: bool,
    pub episodic_memory: bool,
    pub retrieval_mechanism: MemoryRetrievalType,
    pub quantum_compression: bool,
    pub coherence_time: f64,
}

Quantum memory configuration

Fields

memory_size: usize

Memory bank size

associative_memory: bool

Quantum associative memory

episodic_memory: bool

Episodic memory with quantum states

retrieval_mechanism: MemoryRetrievalType

Memory retrieval mechanism

quantum_compression: bool

Memory compression using quantum algorithms

coherence_time: f64

Memory coherence time

Implementations

impl QuantumMemoryConfig

pub fn default() -> Self

Default memory configuration

Examples found in repository

examples/quantum_llm.rs (line 158)

fn quantum_memory_demo() -> Result<()> {
    println!("   Testing quantum memory systems...");

    // Test different memory configurations
    let memory_configs = vec![
        ("Basic Associative", QuantumMemoryConfig::default()),
        ("Enhanced Memory", QuantumMemoryConfig::enhanced()),
        ("Advanced Holographic", QuantumMemoryConfig::advanced()),
    ];

    for (name, config) in memory_configs {
        println!("\n   --- {name} Memory ---");

        let mut memory_system = QuantumMemorySystem::new(config.clone())?;
        println!("   Memory configuration:");
        println!("   - Memory size: {}", config.memory_size);
        println!("   - Associative memory: {}", config.associative_memory);
        println!("   - Episodic memory: {}", config.episodic_memory);
        println!("   - Retrieval mechanism: {:?}", config.retrieval_mechanism);
        println!("   - Quantum compression: {}", config.quantum_compression);

        // Test memory storage and retrieval
        let test_embeddings = Array3::from_shape_fn((2, 10, 128), |(b, s, d)| {
            0.1 * (d as f64).mul_add(0.01, (s as f64).mul_add(0.1, b as f64))
        });

        // Enhance embeddings with memory
        let enhanced = memory_system.enhance_embeddings(&test_embeddings)?;
        println!("   Enhanced embeddings shape: {:?}", enhanced.dim());

        // Measure memory enhancement effect
        let original_variance = test_embeddings.var(0.0);
        let enhanced_variance = enhanced.var(0.0);
        let enhancement_factor = enhanced_variance / original_variance;

        println!("   Memory enhancement factor: {enhancement_factor:.3}");

        // Test memory update
        let input_ids = Array2::from_shape_fn((2, 10), |(b, s)| (b * 10 + s) % 1000);
        memory_system.update_memory(&enhanced, &input_ids)?;

        println!("   Memory updated with new experiences");

        // Test memory retrieval patterns
        test_memory_patterns(&memory_system, &config)?;
    }

    Ok(())
}

pub fn enhanced() -> Self

Enhanced memory configuration

Examples found in repository

examples/quantum_llm.rs (line 159)

fn quantum_memory_demo() -> Result<()> {
    println!("   Testing quantum memory systems...");

    // Test different memory configurations
    let memory_configs = vec![
        ("Basic Associative", QuantumMemoryConfig::default()),
        ("Enhanced Memory", QuantumMemoryConfig::enhanced()),
        ("Advanced Holographic", QuantumMemoryConfig::advanced()),
    ];

    for (name, config) in memory_configs {
        println!("\n   --- {name} Memory ---");

        let mut memory_system = QuantumMemorySystem::new(config.clone())?;
        println!("   Memory configuration:");
        println!("   - Memory size: {}", config.memory_size);
        println!("   - Associative memory: {}", config.associative_memory);
        println!("   - Episodic memory: {}", config.episodic_memory);
        println!("   - Retrieval mechanism: {:?}", config.retrieval_mechanism);
        println!("   - Quantum compression: {}", config.quantum_compression);

        // Test memory storage and retrieval
        let test_embeddings = Array3::from_shape_fn((2, 10, 128), |(b, s, d)| {
            0.1 * (d as f64).mul_add(0.01, (s as f64).mul_add(0.1, b as f64))
        });

        // Enhance embeddings with memory
        let enhanced = memory_system.enhance_embeddings(&test_embeddings)?;
        println!("   Enhanced embeddings shape: {:?}", enhanced.dim());

        // Measure memory enhancement effect
        let original_variance = test_embeddings.var(0.0);
        let enhanced_variance = enhanced.var(0.0);
        let enhancement_factor = enhanced_variance / original_variance;

        println!("   Memory enhancement factor: {enhancement_factor:.3}");

        // Test memory update
        let input_ids = Array2::from_shape_fn((2, 10), |(b, s)| (b * 10 + s) % 1000);
        memory_system.update_memory(&enhanced, &input_ids)?;

        println!("   Memory updated with new experiences");

        // Test memory retrieval patterns
        test_memory_patterns(&memory_system, &config)?;
    }

    Ok(())
}

pub fn advanced() -> Self

Advanced memory configuration

Examples found in repository

examples/quantum_llm.rs (line 160)

fn quantum_memory_demo() -> Result<()> {
    println!("   Testing quantum memory systems...");

    // Test different memory configurations
    let memory_configs = vec![
        ("Basic Associative", QuantumMemoryConfig::default()),
        ("Enhanced Memory", QuantumMemoryConfig::enhanced()),
        ("Advanced Holographic", QuantumMemoryConfig::advanced()),
    ];

    for (name, config) in memory_configs {
        println!("\n   --- {name} Memory ---");

        let mut memory_system = QuantumMemorySystem::new(config.clone())?;
        println!("   Memory configuration:");
        println!("   - Memory size: {}", config.memory_size);
        println!("   - Associative memory: {}", config.associative_memory);
        println!("   - Episodic memory: {}", config.episodic_memory);
        println!("   - Retrieval mechanism: {:?}", config.retrieval_mechanism);
        println!("   - Quantum compression: {}", config.quantum_compression);

        // Test memory storage and retrieval
        let test_embeddings = Array3::from_shape_fn((2, 10, 128), |(b, s, d)| {
            0.1 * (d as f64).mul_add(0.01, (s as f64).mul_add(0.1, b as f64))
        });

        // Enhance embeddings with memory
        let enhanced = memory_system.enhance_embeddings(&test_embeddings)?;
        println!("   Enhanced embeddings shape: {:?}", enhanced.dim());

        // Measure memory enhancement effect
        let original_variance = test_embeddings.var(0.0);
        let enhanced_variance = enhanced.var(0.0);
        let enhancement_factor = enhanced_variance / original_variance;

        println!("   Memory enhancement factor: {enhancement_factor:.3}");

        // Test memory update
        let input_ids = Array2::from_shape_fn((2, 10), |(b, s)| (b * 10 + s) % 1000);
        memory_system.update_memory(&enhanced, &input_ids)?;

        println!("   Memory updated with new experiences");

        // Test memory retrieval patterns
        test_memory_patterns(&memory_system, &config)?;
    }

    Ok(())
}

Trait Implementations

impl Clone for QuantumMemoryConfig

fn clone(&self) -> QuantumMemoryConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QuantumMemoryConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.