Struct QuantumPositionEncoding 

pub struct QuantumPositionEncoding { /* private fields */ }

Quantum position encoding module

Implementations

impl QuantumPositionEncoding

pub fn new( encoding_type: PositionEncodingType, model_dim: usize, max_seq_len: usize, num_qubits: usize, ) -> Result<Self>

Create new quantum position encoding

Examples found in repository

examples/quantum_transformer.rs (line 211)

fn position_encoding_demo() -> Result<()> {
    println!("   Testing quantum position encoding variants...");

    let encoding_types = vec![
        ("Sinusoidal", PositionEncodingType::Sinusoidal),
        ("Quantum Phase", PositionEncodingType::QuantumPhase),
        ("Learnable Quantum", PositionEncodingType::LearnableQuantum),
        ("Relative", PositionEncodingType::Relative),
        ("Rotary (RoPE)", PositionEncodingType::Rotary),
    ];

    let model_dim = 128;
    let max_seq_len = 64;
    let num_qubits = 8;

    for (name, encoding_type) in encoding_types {
        println!("\n   --- {} Position Encoding ---", name);

        let pos_enc =
            QuantumPositionEncoding::new(encoding_type, model_dim, max_seq_len, num_qubits)?;

        let batch_size = 3;
        let seq_len = 32;

        let encodings = pos_enc.forward(seq_len, batch_size)?;
        println!("   Encoding shape: {:?}", encodings.dim());

        // Analyze position encoding properties
        let encoding_range = {
            let min_val = encodings.iter().cloned().fold(f64::INFINITY, f64::min);
            let max_val = encodings.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
            max_val - min_val
        };

        println!("   Value range: {:.4}", encoding_range);

        // Check position distinguishability
        let pos1 = encodings.slice(ndarray::s![0, 0, ..]).to_owned();
        let pos2 = encodings.slice(ndarray::s![0, seq_len - 1, ..]).to_owned();
        let position_distance = (&pos1 - &pos2).mapv(|x| x * x).sum().sqrt();

        println!(
            "   Distance between first and last position: {:.4}",
            position_distance
        );

        // Analyze periodicity for sinusoidal encodings
        if name == "Sinusoidal" {
            let mut periodicities = Vec::new();
            for d in (0..model_dim).step_by(10) {
                let values: Vec<f64> = (0..seq_len).map(|s| encodings[[0, s, d]]).collect();

                // Simple periodicity check
                let period = find_period(&values);
                if period > 0 {
                    periodicities.push(period);
                }
            }

            if !periodicities.is_empty() {
                let avg_period =
                    periodicities.iter().sum::<usize>() as f64 / periodicities.len() as f64;
                println!("   Average period length: {:.1}", avg_period);
            }
        }

        // Check quantum phase encoding properties
        if name == "Quantum Phase" {
            let phase_variance = encodings.var(0.0);
            println!("   Phase encoding variance: {:.4}", phase_variance);
        }
    }

    Ok(())
}

pub fn forward(&self, seq_len: usize, batch_size: usize) -> Result<Array3<f64>>

Generate position encodings for input sequence

Examples found in repository

examples/quantum_transformer.rs (line 216)

fn position_encoding_demo() -> Result<()> {
    println!("   Testing quantum position encoding variants...");

    let encoding_types = vec![
        ("Sinusoidal", PositionEncodingType::Sinusoidal),
        ("Quantum Phase", PositionEncodingType::QuantumPhase),
        ("Learnable Quantum", PositionEncodingType::LearnableQuantum),
        ("Relative", PositionEncodingType::Relative),
        ("Rotary (RoPE)", PositionEncodingType::Rotary),
    ];

    let model_dim = 128;
    let max_seq_len = 64;
    let num_qubits = 8;

    for (name, encoding_type) in encoding_types {
        println!("\n   --- {} Position Encoding ---", name);

        let pos_enc =
            QuantumPositionEncoding::new(encoding_type, model_dim, max_seq_len, num_qubits)?;

        let batch_size = 3;
        let seq_len = 32;

        let encodings = pos_enc.forward(seq_len, batch_size)?;
        println!("   Encoding shape: {:?}", encodings.dim());

        // Analyze position encoding properties
        let encoding_range = {
            let min_val = encodings.iter().cloned().fold(f64::INFINITY, f64::min);
            let max_val = encodings.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
            max_val - min_val
        };

        println!("   Value range: {:.4}", encoding_range);

        // Check position distinguishability
        let pos1 = encodings.slice(ndarray::s![0, 0, ..]).to_owned();
        let pos2 = encodings.slice(ndarray::s![0, seq_len - 1, ..]).to_owned();
        let position_distance = (&pos1 - &pos2).mapv(|x| x * x).sum().sqrt();

        println!(
            "   Distance between first and last position: {:.4}",
            position_distance
        );

        // Analyze periodicity for sinusoidal encodings
        if name == "Sinusoidal" {
            let mut periodicities = Vec::new();
            for d in (0..model_dim).step_by(10) {
                let values: Vec<f64> = (0..seq_len).map(|s| encodings[[0, s, d]]).collect();

                // Simple periodicity check
                let period = find_period(&values);
                if period > 0 {
                    periodicities.push(period);
                }
            }

            if !periodicities.is_empty() {
                let avg_period =
                    periodicities.iter().sum::<usize>() as f64 / periodicities.len() as f64;
                println!("   Average period length: {:.1}", avg_period);
            }
        }

        // Check quantum phase encoding properties
        if name == "Quantum Phase" {
            let phase_variance = encodings.var(0.0);
            println!("   Phase encoding variance: {:.4}", phase_variance);
        }
    }

    Ok(())
}

Trait Implementations

impl Clone for QuantumPositionEncoding

fn clone(&self) -> QuantumPositionEncoding

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QuantumPositionEncoding

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

Formats the value using the given formatter.