Struct QuantumDataset 

pub struct QuantumDataset { /* private fields */ }

TensorFlow Quantum-style quantum dataset utilities

Implementations

impl QuantumDataset

pub fn new( circuits: Vec<Circuit<8>>, parameters: Array2<f64>, labels: Array1<f64>, batch_size: usize, ) -> Result<Self>

Create new quantum dataset

Examples found in repository

examples/tensorflow_quantum_demo.rs (lines 328-333)

fn create_tfq_quantum_dataset() -> Result<QuantumDataset> {
    let num_samples = 1000;
    let num_features = 4;

    // Create classical data
    let classical_data = Array2::from_shape_fn((num_samples, num_features), |(i, j)| {
        let noise = fastrand::f64() * 0.1;
        ((i as f64 * 0.01) + (j as f64 * 0.1)).sin() + noise
    });

    // Create labels (binary classification)
    let labels = Array1::from_shape_fn(num_samples, |i| {
        let sum = (0..num_features)
            .map(|j| classical_data[[i, j]])
            .sum::<f64>();
        if sum > 0.0 {
            1.0
        } else {
            0.0
        }
    });

    // Create quantum circuits for the dataset
    let circuits =
        vec![tfq_utils::create_data_encoding_circuit(4, DataEncodingType::Angle)?; num_samples]
            .into_iter()
            .map(|dc| match dc {
                DynamicCircuit::Circuit8(c) => c,
                _ => panic!("Expected Circuit8"),
            })
            .collect();

    // Create quantum dataset with angle encoding
    QuantumDataset::new(
        circuits,
        classical_data,
        labels,
        32, // batch_size
    )
}

fn create_tfq_test_dataset() -> Result<QuantumDataset> {
    let num_samples = 200;
    let num_features = 4;

    let test_data = Array2::from_shape_fn((num_samples, num_features), |(i, j)| {
        let noise = fastrand::f64() * 0.1;
        ((i as f64 * 0.015) + (j as f64 * 0.12)).sin() + noise
    });

    let test_labels = Array1::from_shape_fn(num_samples, |i| {
        let sum = (0..num_features).map(|j| test_data[[i, j]]).sum::<f64>();
        if sum > 0.0 {
            1.0
        } else {
            0.0
        }
    });

    // Create quantum circuits for the test dataset
    let test_circuits =
        vec![tfq_utils::create_data_encoding_circuit(4, DataEncodingType::Angle)?; num_samples]
            .into_iter()
            .map(|dc| match dc {
                DynamicCircuit::Circuit8(c) => c,
                _ => panic!("Expected Circuit8"),
            })
            .collect();

    QuantumDataset::new(test_circuits, test_data, test_labels, 32)
}

pub fn batches(&self) -> QuantumDatasetIterator<'_>

Get batch iterator

pub fn shuffle(&mut self)

Shuffle dataset