Struct QMLAccelerator 

pub struct QMLAccelerator {
    pub device: Arc<RwLock<dyn QuantumDevice + Send + Sync>>,
    pub config: QMLConfig,
    pub training_history: Vec<TrainingEpoch>,
    pub model_registry: ModelRegistry,
    pub hardware_manager: HardwareAccelerationManager,
    pub is_connected: bool,
}

Quantum Machine Learning Accelerator

Fields

device: Arc<RwLock<dyn QuantumDevice + Send + Sync>>

Quantum device backend

config: QMLConfig

QML configuration

training_history: Vec<TrainingEpoch>

Training history

model_registry: ModelRegistry

Model registry

hardware_manager: HardwareAccelerationManager

Hardware acceleration manager

is_connected: bool

Connection status

Implementations

impl QMLAccelerator

pub fn new( device: Arc<RwLock<dyn QuantumDevice + Send + Sync>>, config: QMLConfig, ) -> DeviceResult<Self>

Create a new QML accelerator

pub async fn connect(&mut self) -> DeviceResult<()>

Connect to quantum hardware

pub async fn disconnect(&mut self) -> DeviceResult<()>

Disconnect from hardware

pub async fn train_model( &mut self, model_type: QMLModelType, training_data: TrainingData, validation_data: Option<TrainingData>, ) -> DeviceResult<TrainingResult>

Train a quantum machine learning model

pub async fn inference( &self, model_id: &str, input_data: InferenceData, ) -> DeviceResult<InferenceResult>

Perform inference with a trained model

pub async fn optimize_parameters( &mut self, initial_parameters: Vec<f64>, objective_function: Box<dyn ObjectiveFunction + Send + Sync>, ) -> DeviceResult<OptimizationResult>

Optimize quantum circuit parameters

pub async fn compute_gradients( &self, circuit: ParameterizedQuantumCircuit, parameters: Vec<f64>, ) -> DeviceResult<Vec<f64>>

Compute gradients using quantum methods

pub fn get_training_statistics(&self) -> TrainingStatistics

Get training statistics

pub async fn export_model( &self, model_id: &str, format: ModelExportFormat, ) -> DeviceResult<Vec<u8>>

Export trained model

pub async fn import_model( &mut self, model_data: Vec<u8>, format: ModelExportFormat, ) -> DeviceResult<String>

Import trained model

pub async fn get_acceleration_metrics(&self) -> HardwareAccelerationMetrics

Get hardware acceleration metrics

pub async fn benchmark_performance( &self, model_type: QMLModelType, problem_size: usize, ) -> DeviceResult<PerformanceBenchmark>

Benchmark quantum vs classical performance

pub async fn get_diagnostics(&self) -> QMLDiagnostics

Get QML accelerator diagnostics