Struct QuantumLanguageModel 

pub struct QuantumLanguageModel {
    pub num_qubits: usize,
    pub embedding_strategy: EmbeddingStrategy,
    pub preprocessor: TextPreprocessor,
    pub embedding: WordEmbedding,
    pub qnn: QuantumNeuralNetwork,
    pub task: NLPTaskType,
    pub labels: Vec<String>,
}

Quantum language model for NLP tasks

Fields

num_qubits: usize

Number of qubits

embedding_strategy: EmbeddingStrategy

Embedding strategy

preprocessor: TextPreprocessor

Text preprocessor

embedding: WordEmbedding

Word embedding

qnn: QuantumNeuralNetwork

Quantum neural network

task: NLPTaskType

Type of NLP task

labels: Vec<String>

Class labels (for classification tasks)

Implementations

impl QuantumLanguageModel

pub fn new( num_qubits: usize, embedding_dimension: usize, strategy: EmbeddingStrategy, task: NLPTaskType, labels: Vec<String>, ) -> Result<Self>

Creates a new quantum language model

Examples found in repository

examples/quantum_nlp.rs (lines 33-44)

fn run_text_classification() -> Result<()> {
    println!("\nText Classification Example");
    println!("--------------------------");

    // Create quantum language model for classification
    let num_qubits = 6;
    let embedding_dim = 16;
    let embedding_strategy = EmbeddingStrategy::from(64); // Was max_seq_length before

    println!("Creating quantum language model with {num_qubits} qubits");
    let mut model = QuantumLanguageModel::new(
        num_qubits,
        embedding_dim,
        embedding_strategy,
        NLPTaskType::Classification,
        vec![
            "technology".to_string(),
            "sports".to_string(),
            "politics".to_string(),
            "entertainment".to_string(),
        ],
    )?;

    // Create training data
    println!("Preparing training data...");
    let training_texts = vec![
        "Latest smartphone features advanced AI capabilities".to_string(),
        "The football team won the championship yesterday".to_string(),
        "New legislation passed regarding climate change".to_string(),
        "The movie premiere attracted numerous celebrities".to_string(),
        "Software engineers developed a new programming language".to_string(),
        "Athletes compete in the international tournament next week".to_string(),
        "Senator announces campaign for presidential election".to_string(),
        "Actor receives award for outstanding performance".to_string(),
    ];

    let training_labels = vec![0, 1, 2, 3, 0, 1, 2, 3];

    // Build vocabulary
    println!("Building vocabulary from training texts...");
    let vocab_size = model.build_vocabulary(&training_texts)?;
    println!("Vocabulary size: {vocab_size}");

    // Train embeddings
    println!("Training word embeddings...");
    model.train_embeddings(&training_texts)?;

    // Train model
    println!("Training quantum language model...");
    let start = Instant::now();
    model.train(&training_texts, &training_labels, 10, 0.05)?;
    println!("Training completed in {:.2?}", start.elapsed());

    // Test classification
    let test_texts = [
        "New computer processor breaks performance records",
        "Basketball player scores winning point in final seconds",
        "Government announces new tax policy",
        "New series premieres with record viewership",
    ];

    println!("\nClassifying test texts:");
    for text in &test_texts {
        let start = Instant::now();
        let (category, confidence) = model.classify(text)?;

        println!("Text: \"{text}\"");
        println!("Classification: {category} (confidence: {confidence:.2})");
        println!("Classification time: {:.2?}\n", start.elapsed());
    }

    Ok(())
}

pub fn fit(&mut self, texts: &[&str], labels: &[usize]) -> Result<()>

Fits the model on a corpus

pub fn predict(&self, text: &str) -> Result<(String, f64)>

Predicts the label for a text

impl QuantumLanguageModel

Implementation of missing methods for QuantumLanguageModel

pub fn build_vocabulary(&mut self, texts: &[String]) -> Result<usize>

Builds vocabulary from a set of texts

Examples found in repository

examples/quantum_nlp.rs (line 63)

fn run_text_classification() -> Result<()> {
    println!("\nText Classification Example");
    println!("--------------------------");

    // Create quantum language model for classification
    let num_qubits = 6;
    let embedding_dim = 16;
    let embedding_strategy = EmbeddingStrategy::from(64); // Was max_seq_length before

    println!("Creating quantum language model with {num_qubits} qubits");
    let mut model = QuantumLanguageModel::new(
        num_qubits,
        embedding_dim,
        embedding_strategy,
        NLPTaskType::Classification,
        vec![
            "technology".to_string(),
            "sports".to_string(),
            "politics".to_string(),
            "entertainment".to_string(),
        ],
    )?;

    // Create training data
    println!("Preparing training data...");
    let training_texts = vec![
        "Latest smartphone features advanced AI capabilities".to_string(),
        "The football team won the championship yesterday".to_string(),
        "New legislation passed regarding climate change".to_string(),
        "The movie premiere attracted numerous celebrities".to_string(),
        "Software engineers developed a new programming language".to_string(),
        "Athletes compete in the international tournament next week".to_string(),
        "Senator announces campaign for presidential election".to_string(),
        "Actor receives award for outstanding performance".to_string(),
    ];

    let training_labels = vec![0, 1, 2, 3, 0, 1, 2, 3];

    // Build vocabulary
    println!("Building vocabulary from training texts...");
    let vocab_size = model.build_vocabulary(&training_texts)?;
    println!("Vocabulary size: {vocab_size}");

    // Train embeddings
    println!("Training word embeddings...");
    model.train_embeddings(&training_texts)?;

    // Train model
    println!("Training quantum language model...");
    let start = Instant::now();
    model.train(&training_texts, &training_labels, 10, 0.05)?;
    println!("Training completed in {:.2?}", start.elapsed());

    // Test classification
    let test_texts = [
        "New computer processor breaks performance records",
        "Basketball player scores winning point in final seconds",
        "Government announces new tax policy",
        "New series premieres with record viewership",
    ];

    println!("\nClassifying test texts:");
    for text in &test_texts {
        let start = Instant::now();
        let (category, confidence) = model.classify(text)?;

        println!("Text: \"{text}\"");
        println!("Classification: {category} (confidence: {confidence:.2})");
        println!("Classification time: {:.2?}\n", start.elapsed());
    }

    Ok(())
}

pub fn train_embeddings(&mut self, texts: &[String]) -> Result<()>

Trains word embeddings

Examples found in repository

examples/quantum_nlp.rs (line 68)

fn run_text_classification() -> Result<()> {
    println!("\nText Classification Example");
    println!("--------------------------");

    // Create quantum language model for classification
    let num_qubits = 6;
    let embedding_dim = 16;
    let embedding_strategy = EmbeddingStrategy::from(64); // Was max_seq_length before

    println!("Creating quantum language model with {num_qubits} qubits");
    let mut model = QuantumLanguageModel::new(
        num_qubits,
        embedding_dim,
        embedding_strategy,
        NLPTaskType::Classification,
        vec![
            "technology".to_string(),
            "sports".to_string(),
            "politics".to_string(),
            "entertainment".to_string(),
        ],
    )?;

    // Create training data
    println!("Preparing training data...");
    let training_texts = vec![
        "Latest smartphone features advanced AI capabilities".to_string(),
        "The football team won the championship yesterday".to_string(),
        "New legislation passed regarding climate change".to_string(),
        "The movie premiere attracted numerous celebrities".to_string(),
        "Software engineers developed a new programming language".to_string(),
        "Athletes compete in the international tournament next week".to_string(),
        "Senator announces campaign for presidential election".to_string(),
        "Actor receives award for outstanding performance".to_string(),
    ];

    let training_labels = vec![0, 1, 2, 3, 0, 1, 2, 3];

    // Build vocabulary
    println!("Building vocabulary from training texts...");
    let vocab_size = model.build_vocabulary(&training_texts)?;
    println!("Vocabulary size: {vocab_size}");

    // Train embeddings
    println!("Training word embeddings...");
    model.train_embeddings(&training_texts)?;

    // Train model
    println!("Training quantum language model...");
    let start = Instant::now();
    model.train(&training_texts, &training_labels, 10, 0.05)?;
    println!("Training completed in {:.2?}", start.elapsed());

    // Test classification
    let test_texts = [
        "New computer processor breaks performance records",
        "Basketball player scores winning point in final seconds",
        "Government announces new tax policy",
        "New series premieres with record viewership",
    ];

    println!("\nClassifying test texts:");
    for text in &test_texts {
        let start = Instant::now();
        let (category, confidence) = model.classify(text)?;

        println!("Text: \"{text}\"");
        println!("Classification: {category} (confidence: {confidence:.2})");
        println!("Classification time: {:.2?}\n", start.elapsed());
    }

    Ok(())
}

pub fn train( &mut self, texts: &[String], labels: &[usize], epochs: usize, learning_rate: f64, ) -> Result<()>

Trains the language model

Examples found in repository

examples/quantum_nlp.rs (line 73)

fn run_text_classification() -> Result<()> {
    println!("\nText Classification Example");
    println!("--------------------------");

    // Create quantum language model for classification
    let num_qubits = 6;
    let embedding_dim = 16;
    let embedding_strategy = EmbeddingStrategy::from(64); // Was max_seq_length before

    println!("Creating quantum language model with {num_qubits} qubits");
    let mut model = QuantumLanguageModel::new(
        num_qubits,
        embedding_dim,
        embedding_strategy,
        NLPTaskType::Classification,
        vec![
            "technology".to_string(),
            "sports".to_string(),
            "politics".to_string(),
            "entertainment".to_string(),
        ],
    )?;

    // Create training data
    println!("Preparing training data...");
    let training_texts = vec![
        "Latest smartphone features advanced AI capabilities".to_string(),
        "The football team won the championship yesterday".to_string(),
        "New legislation passed regarding climate change".to_string(),
        "The movie premiere attracted numerous celebrities".to_string(),
        "Software engineers developed a new programming language".to_string(),
        "Athletes compete in the international tournament next week".to_string(),
        "Senator announces campaign for presidential election".to_string(),
        "Actor receives award for outstanding performance".to_string(),
    ];

    let training_labels = vec![0, 1, 2, 3, 0, 1, 2, 3];

    // Build vocabulary
    println!("Building vocabulary from training texts...");
    let vocab_size = model.build_vocabulary(&training_texts)?;
    println!("Vocabulary size: {vocab_size}");

    // Train embeddings
    println!("Training word embeddings...");
    model.train_embeddings(&training_texts)?;

    // Train model
    println!("Training quantum language model...");
    let start = Instant::now();
    model.train(&training_texts, &training_labels, 10, 0.05)?;
    println!("Training completed in {:.2?}", start.elapsed());

    // Test classification
    let test_texts = [
        "New computer processor breaks performance records",
        "Basketball player scores winning point in final seconds",
        "Government announces new tax policy",
        "New series premieres with record viewership",
    ];

    println!("\nClassifying test texts:");
    for text in &test_texts {
        let start = Instant::now();
        let (category, confidence) = model.classify(text)?;

        println!("Text: \"{text}\"");
        println!("Classification: {category} (confidence: {confidence:.2})");
        println!("Classification time: {:.2?}\n", start.elapsed());
    }

    Ok(())
}

pub fn classify(&self, text: &str) -> Result<(String, f64)>

Classifies a text

Examples found in repository

examples/quantum_nlp.rs (line 87)

fn run_text_classification() -> Result<()> {
    println!("\nText Classification Example");
    println!("--------------------------");

    // Create quantum language model for classification
    let num_qubits = 6;
    let embedding_dim = 16;
    let embedding_strategy = EmbeddingStrategy::from(64); // Was max_seq_length before

    println!("Creating quantum language model with {num_qubits} qubits");
    let mut model = QuantumLanguageModel::new(
        num_qubits,
        embedding_dim,
        embedding_strategy,
        NLPTaskType::Classification,
        vec![
            "technology".to_string(),
            "sports".to_string(),
            "politics".to_string(),
            "entertainment".to_string(),
        ],
    )?;

    // Create training data
    println!("Preparing training data...");
    let training_texts = vec![
        "Latest smartphone features advanced AI capabilities".to_string(),
        "The football team won the championship yesterday".to_string(),
        "New legislation passed regarding climate change".to_string(),
        "The movie premiere attracted numerous celebrities".to_string(),
        "Software engineers developed a new programming language".to_string(),
        "Athletes compete in the international tournament next week".to_string(),
        "Senator announces campaign for presidential election".to_string(),
        "Actor receives award for outstanding performance".to_string(),
    ];

    let training_labels = vec![0, 1, 2, 3, 0, 1, 2, 3];

    // Build vocabulary
    println!("Building vocabulary from training texts...");
    let vocab_size = model.build_vocabulary(&training_texts)?;
    println!("Vocabulary size: {vocab_size}");

    // Train embeddings
    println!("Training word embeddings...");
    model.train_embeddings(&training_texts)?;

    // Train model
    println!("Training quantum language model...");
    let start = Instant::now();
    model.train(&training_texts, &training_labels, 10, 0.05)?;
    println!("Training completed in {:.2?}", start.elapsed());

    // Test classification
    let test_texts = [
        "New computer processor breaks performance records",
        "Basketball player scores winning point in final seconds",
        "Government announces new tax policy",
        "New series premieres with record viewership",
    ];

    println!("\nClassifying test texts:");
    for text in &test_texts {
        let start = Instant::now();
        let (category, confidence) = model.classify(text)?;

        println!("Text: \"{text}\"");
        println!("Classification: {category} (confidence: {confidence:.2})");
        println!("Classification time: {:.2?}\n", start.elapsed());
    }

    Ok(())
}

Trait Implementations

impl Clone for QuantumLanguageModel

fn clone(&self) -> QuantumLanguageModel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QuantumLanguageModel

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

Formats the value using the given formatter.