Struct GenerationConfig 

pub struct GenerationConfig {
    pub max_length: usize,
    pub temperature: f64,
    pub top_k: Option<usize>,
    pub top_p: Option<f64>,
    pub repetition_penalty: f64,
    pub use_quantum_reasoning: bool,
    pub use_memory: bool,
    pub chain_of_thought: bool,
}

Text generation parameters

Fields

max_length: usize

Maximum generation length

temperature: f64

Temperature for sampling

top_k: Option<usize>

Top-k sampling

top_p: Option<f64>

Top-p (nucleus) sampling

repetition_penalty: f64

Repetition penalty

use_quantum_reasoning: bool

Enable quantum reasoning during generation

use_memory: bool

Memory-guided generation

chain_of_thought: bool

Chain-of-thought generation

Implementations

impl GenerationConfig

pub fn default() -> Self

Default generation configuration

Examples found in repository

examples/quantum_llm.rs (line 292)

fn text_generation_demo() -> Result<()> {
    println!("   Testing quantum-enhanced text generation...");

    let config = QuantumLLMConfig::small(10000);
    let mut model = QuantumLLM::new(config)?;

    // Test different generation configurations
    let generation_configs = vec![
        ("Default", GenerationConfig::default()),
        ("Creative", GenerationConfig::creative()),
        ("Precise", GenerationConfig::precise()),
    ];

    let test_prompts = vec![
        "The quantum computer",
        "Artificial intelligence will",
        "In the future, quantum computing",
        "The relationship between quantum mechanics and consciousness",
    ];

    for (config_name, gen_config) in generation_configs {
        println!("\n   --- {} Generation ---", config_name);
        println!("   Configuration:");
        println!("   - Max length: {}", gen_config.max_length);
        println!("   - Temperature: {:.1}", gen_config.temperature);
        println!("   - Top-k: {:?}", gen_config.top_k);
        println!("   - Top-p: {:?}", gen_config.top_p);
        println!(
            "   - Quantum reasoning: {}",
            gen_config.use_quantum_reasoning
        );
        println!("   - Memory usage: {}", gen_config.use_memory);
        println!("   - Chain-of-thought: {}", gen_config.chain_of_thought);

        for (i, prompt) in test_prompts.iter().take(2).enumerate() {
            println!("\n   Prompt {}: \"{}\"", i + 1, prompt);

            let start_time = std::time::Instant::now();
            let generated = model.generate(prompt, gen_config.clone())?;
            let generation_time = start_time.elapsed();

            // Display partial generated text (first 100 chars)
            let display_text = if generated.len() > 100 {
                format!("{}...", &generated[..100])
            } else {
                generated.clone()
            };

            println!("   Generated: \"{}\"", display_text);
            println!("   Generation time: {:.2?}", generation_time);

            // Analyze generation quality
            let quality = analyze_generation_quality(&generated, &gen_config)?;
            println!("   Quality metrics:");
            println!("   - Fluency: {:.2}", quality.fluency);
            println!("   - Coherence: {:.2}", quality.coherence);
            println!("   - Novelty: {:.2}", quality.novelty);
            println!("   - Quantum advantage: {:.3}", quality.quantum_advantage);
        }
    }

    // Display generation statistics
    let stats = model.generation_stats();
    println!("\n   Generation Statistics:");
    println!("   - Total tokens generated: {}", stats.total_tokens);
    println!("   - Quantum coherence: {:.3}", stats.quantum_coherence);
    println!("   - Reasoning steps taken: {}", stats.reasoning_steps);
    println!("   - Memory retrievals: {}", stats.memory_retrievals);

    Ok(())
}

pub fn creative() -> Self

Creative generation configuration

Examples found in repository

examples/quantum_llm.rs (line 293)

fn text_generation_demo() -> Result<()> {
    println!("   Testing quantum-enhanced text generation...");

    let config = QuantumLLMConfig::small(10000);
    let mut model = QuantumLLM::new(config)?;

    // Test different generation configurations
    let generation_configs = vec![
        ("Default", GenerationConfig::default()),
        ("Creative", GenerationConfig::creative()),
        ("Precise", GenerationConfig::precise()),
    ];

    let test_prompts = vec![
        "The quantum computer",
        "Artificial intelligence will",
        "In the future, quantum computing",
        "The relationship between quantum mechanics and consciousness",
    ];

    for (config_name, gen_config) in generation_configs {
        println!("\n   --- {} Generation ---", config_name);
        println!("   Configuration:");
        println!("   - Max length: {}", gen_config.max_length);
        println!("   - Temperature: {:.1}", gen_config.temperature);
        println!("   - Top-k: {:?}", gen_config.top_k);
        println!("   - Top-p: {:?}", gen_config.top_p);
        println!(
            "   - Quantum reasoning: {}",
            gen_config.use_quantum_reasoning
        );
        println!("   - Memory usage: {}", gen_config.use_memory);
        println!("   - Chain-of-thought: {}", gen_config.chain_of_thought);

        for (i, prompt) in test_prompts.iter().take(2).enumerate() {
            println!("\n   Prompt {}: \"{}\"", i + 1, prompt);

            let start_time = std::time::Instant::now();
            let generated = model.generate(prompt, gen_config.clone())?;
            let generation_time = start_time.elapsed();

            // Display partial generated text (first 100 chars)
            let display_text = if generated.len() > 100 {
                format!("{}...", &generated[..100])
            } else {
                generated.clone()
            };

            println!("   Generated: \"{}\"", display_text);
            println!("   Generation time: {:.2?}", generation_time);

            // Analyze generation quality
            let quality = analyze_generation_quality(&generated, &gen_config)?;
            println!("   Quality metrics:");
            println!("   - Fluency: {:.2}", quality.fluency);
            println!("   - Coherence: {:.2}", quality.coherence);
            println!("   - Novelty: {:.2}", quality.novelty);
            println!("   - Quantum advantage: {:.3}", quality.quantum_advantage);
        }
    }

    // Display generation statistics
    let stats = model.generation_stats();
    println!("\n   Generation Statistics:");
    println!("   - Total tokens generated: {}", stats.total_tokens);
    println!("   - Quantum coherence: {:.3}", stats.quantum_coherence);
    println!("   - Reasoning steps taken: {}", stats.reasoning_steps);
    println!("   - Memory retrievals: {}", stats.memory_retrievals);

    Ok(())
}

pub fn precise() -> Self

Precise generation configuration

Examples found in repository

examples/quantum_llm.rs (line 294)

fn text_generation_demo() -> Result<()> {
    println!("   Testing quantum-enhanced text generation...");

    let config = QuantumLLMConfig::small(10000);
    let mut model = QuantumLLM::new(config)?;

    // Test different generation configurations
    let generation_configs = vec![
        ("Default", GenerationConfig::default()),
        ("Creative", GenerationConfig::creative()),
        ("Precise", GenerationConfig::precise()),
    ];

    let test_prompts = vec![
        "The quantum computer",
        "Artificial intelligence will",
        "In the future, quantum computing",
        "The relationship between quantum mechanics and consciousness",
    ];

    for (config_name, gen_config) in generation_configs {
        println!("\n   --- {} Generation ---", config_name);
        println!("   Configuration:");
        println!("   - Max length: {}", gen_config.max_length);
        println!("   - Temperature: {:.1}", gen_config.temperature);
        println!("   - Top-k: {:?}", gen_config.top_k);
        println!("   - Top-p: {:?}", gen_config.top_p);
        println!(
            "   - Quantum reasoning: {}",
            gen_config.use_quantum_reasoning
        );
        println!("   - Memory usage: {}", gen_config.use_memory);
        println!("   - Chain-of-thought: {}", gen_config.chain_of_thought);

        for (i, prompt) in test_prompts.iter().take(2).enumerate() {
            println!("\n   Prompt {}: \"{}\"", i + 1, prompt);

            let start_time = std::time::Instant::now();
            let generated = model.generate(prompt, gen_config.clone())?;
            let generation_time = start_time.elapsed();

            // Display partial generated text (first 100 chars)
            let display_text = if generated.len() > 100 {
                format!("{}...", &generated[..100])
            } else {
                generated.clone()
            };

            println!("   Generated: \"{}\"", display_text);
            println!("   Generation time: {:.2?}", generation_time);

            // Analyze generation quality
            let quality = analyze_generation_quality(&generated, &gen_config)?;
            println!("   Quality metrics:");
            println!("   - Fluency: {:.2}", quality.fluency);
            println!("   - Coherence: {:.2}", quality.coherence);
            println!("   - Novelty: {:.2}", quality.novelty);
            println!("   - Quantum advantage: {:.3}", quality.quantum_advantage);
        }
    }

    // Display generation statistics
    let stats = model.generation_stats();
    println!("\n   Generation Statistics:");
    println!("   - Total tokens generated: {}", stats.total_tokens);
    println!("   - Quantum coherence: {:.3}", stats.quantum_coherence);
    println!("   - Reasoning steps taken: {}", stats.reasoning_steps);
    println!("   - Memory retrievals: {}", stats.memory_retrievals);

    Ok(())
}

Trait Implementations

impl Clone for GenerationConfig

fn clone(&self) -> GenerationConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GenerationConfig

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

Formats the value using the given formatter.