quantrs2_ml/
domain_templates.rs

1//! Domain-specific model templates for QuantRS2-ML
2//!
3//! This module provides ready-to-use model templates for specific application domains,
4//! making it easier for users to get started with quantum ML in their field.
5
6use crate::anneal_integration::{AnnealingParams, QuantumMLQUBO};
7use crate::enhanced_gan::{ConditionalQGAN, WassersteinQGAN};
8use crate::error::{MLError, Result};
9use crate::keras_api::{
10    ActivationFunction, Dense, LossFunction, MetricType, OptimizerType, QuantumAnsatzType,
11    QuantumDense, Sequential,
12};
13use crate::optimization::{OptimizationMethod, Optimizer};
14use crate::pytorch_api::{
15    ActivationType as PyTorchActivationType, QuantumLinear, QuantumSequential,
16};
17use crate::qsvm::{FeatureMapType, QSVMParams, QSVM};
18use crate::vae::{ClassicalAutoencoder, QVAE};
19use ndarray::{s, Array1, Array2, ArrayD, IxDyn};
20use quantrs2_circuit::prelude::*;
21use quantrs2_core::prelude::*;
22use serde::{Deserialize, Serialize};
23use std::collections::HashMap;
24
25/// Domain-specific template manager
26pub struct DomainTemplateManager {
27    /// Available templates by domain
28    templates: HashMap<Domain, Vec<TemplateMetadata>>,
29}
30
31/// Application domains
32#[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize)]
33pub enum Domain {
34    /// Financial services and fintech
35    Finance,
36    /// Chemistry and molecular simulation
37    Chemistry,
38    /// Healthcare and medical applications
39    Healthcare,
40    /// Logistics and supply chain
41    Logistics,
42    /// Energy and utilities
43    Energy,
44    /// Materials science
45    Materials,
46    /// High-energy physics
47    Physics,
48    /// Natural language processing
49    NLP,
50    /// Computer vision
51    Vision,
52    /// Cybersecurity
53    Security,
54    /// Climate modeling
55    Climate,
56    /// Aerospace and defense
57    Aerospace,
58}
59
60/// Template metadata
61#[derive(Debug, Clone, Serialize, Deserialize)]
62pub struct TemplateMetadata {
63    /// Template name
64    pub name: String,
65    /// Template description
66    pub description: String,
67    /// Domain
68    pub domain: Domain,
69    /// Problem type
70    pub problem_type: ProblemType,
71    /// Expected input features
72    pub input_features: Vec<String>,
73    /// Expected output
74    pub output_description: String,
75    /// Recommended dataset size
76    pub recommended_dataset_size: usize,
77    /// Model complexity
78    pub complexity: ModelComplexity,
79    /// Required qubits
80    pub required_qubits: usize,
81    /// Estimated training time
82    pub training_time_estimate: String,
83    /// Performance expectations
84    pub performance_notes: String,
85}
86
87/// Problem types
88#[derive(Debug, Clone, Serialize, Deserialize)]
89pub enum ProblemType {
90    /// Binary classification
91    BinaryClassification,
92    /// Multi-class classification
93    MultiClassification,
94    /// Regression
95    Regression,
96    /// Optimization
97    Optimization,
98    /// Generation
99    Generation,
100    /// Anomaly detection
101    AnomalyDetection,
102    /// Time series forecasting
103    TimeSeriesForecasting,
104    /// Clustering
105    Clustering,
106    /// Dimensionality reduction
107    DimensionalityReduction,
108}
109
110/// Model complexity levels
111#[derive(Debug, Clone, Serialize, Deserialize)]
112pub enum ModelComplexity {
113    /// Simple models for quick prototyping
114    Simple,
115    /// Intermediate models with good balance
116    Intermediate,
117    /// Complex models for advanced use cases
118    Complex,
119    /// Research-grade models
120    Research,
121}
122
123/// Template configuration
124#[derive(Debug, Clone)]
125pub struct TemplateConfig {
126    /// Number of qubits to use
127    pub num_qubits: usize,
128    /// Input dimension
129    pub input_dim: usize,
130    /// Output dimension
131    pub output_dim: usize,
132    /// Additional parameters
133    pub parameters: HashMap<String, f64>,
134}
135
136impl DomainTemplateManager {
137    /// Create new template manager
138    pub fn new() -> Self {
139        let mut manager = Self {
140            templates: HashMap::new(),
141        };
142        manager.register_templates();
143        manager
144    }
145
146    /// Register all domain templates
147    fn register_templates(&mut self) {
148        self.register_finance_templates();
149        self.register_chemistry_templates();
150        self.register_healthcare_templates();
151        self.register_logistics_templates();
152        self.register_energy_templates();
153        self.register_materials_templates();
154        self.register_physics_templates();
155        self.register_nlp_templates();
156        self.register_vision_templates();
157        self.register_security_templates();
158        self.register_climate_templates();
159        self.register_aerospace_templates();
160    }
161
162    /// Register finance domain templates
163    fn register_finance_templates(&mut self) {
164        let mut templates = Vec::new();
165
166        // Portfolio optimization
167        templates.push(TemplateMetadata {
168            name: "Portfolio Optimization".to_string(),
169            description: "Quantum portfolio optimization using QAOA for risk-return optimization"
170                .to_string(),
171            domain: Domain::Finance,
172            problem_type: ProblemType::Optimization,
173            input_features: vec![
174                "asset_returns".to_string(),
175                "risk_matrix".to_string(),
176                "correlation_matrix".to_string(),
177            ],
178            output_description: "Optimal portfolio weights".to_string(),
179            recommended_dataset_size: 500,
180            complexity: ModelComplexity::Intermediate,
181            required_qubits: 10,
182            training_time_estimate: "10-30 minutes".to_string(),
183            performance_notes: "Can outperform classical methods for small portfolios".to_string(),
184        });
185
186        // Credit risk assessment
187        templates.push(TemplateMetadata {
188            name: "Credit Risk Assessment".to_string(),
189            description: "Quantum neural network for credit default prediction".to_string(),
190            domain: Domain::Finance,
191            problem_type: ProblemType::BinaryClassification,
192            input_features: vec![
193                "credit_score".to_string(),
194                "income".to_string(),
195                "debt_ratio".to_string(),
196                "employment_history".to_string(),
197                "loan_amount".to_string(),
198            ],
199            output_description: "Default probability".to_string(),
200            recommended_dataset_size: 10000,
201            complexity: ModelComplexity::Intermediate,
202            required_qubits: 8,
203            training_time_estimate: "1-2 hours".to_string(),
204            performance_notes: "Competitive accuracy with quantum advantage in training speed"
205                .to_string(),
206        });
207
208        // Fraud detection
209        templates.push(TemplateMetadata {
210            name: "Fraud Detection".to_string(),
211            description: "Quantum anomaly detection for financial fraud".to_string(),
212            domain: Domain::Finance,
213            problem_type: ProblemType::AnomalyDetection,
214            input_features: vec![
215                "transaction_amount".to_string(),
216                "transaction_time".to_string(),
217                "merchant_category".to_string(),
218                "location".to_string(),
219                "user_behavior_patterns".to_string(),
220            ],
221            output_description: "Fraud probability".to_string(),
222            recommended_dataset_size: 50000,
223            complexity: ModelComplexity::Complex,
224            required_qubits: 12,
225            training_time_estimate: "2-4 hours".to_string(),
226            performance_notes: "High sensitivity to rare fraud patterns".to_string(),
227        });
228
229        // Algorithmic trading
230        templates.push(TemplateMetadata {
231            name: "Algorithmic Trading".to_string(),
232            description: "Quantum reinforcement learning for trading strategies".to_string(),
233            domain: Domain::Finance,
234            problem_type: ProblemType::TimeSeriesForecasting,
235            input_features: vec![
236                "price_history".to_string(),
237                "volume".to_string(),
238                "technical_indicators".to_string(),
239                "market_sentiment".to_string(),
240            ],
241            output_description: "Trading signals (buy/sell/hold)".to_string(),
242            recommended_dataset_size: 100000,
243            complexity: ModelComplexity::Research,
244            required_qubits: 16,
245            training_time_estimate: "4-8 hours".to_string(),
246            performance_notes: "Potential for discovering novel trading patterns".to_string(),
247        });
248
249        self.templates.insert(Domain::Finance, templates);
250    }
251
252    /// Register chemistry domain templates
253    fn register_chemistry_templates(&mut self) {
254        let mut templates = Vec::new();
255
256        // Molecular property prediction
257        templates.push(TemplateMetadata {
258            name: "Molecular Property Prediction".to_string(),
259            description: "Quantum graph neural networks for predicting molecular properties"
260                .to_string(),
261            domain: Domain::Chemistry,
262            problem_type: ProblemType::Regression,
263            input_features: vec![
264                "molecular_graph".to_string(),
265                "atom_features".to_string(),
266                "bond_features".to_string(),
267                "molecular_descriptors".to_string(),
268            ],
269            output_description: "Property values (e.g., solubility, toxicity)".to_string(),
270            recommended_dataset_size: 5000,
271            complexity: ModelComplexity::Complex,
272            required_qubits: 12,
273            training_time_estimate: "2-6 hours".to_string(),
274            performance_notes: "Superior performance on quantum chemical properties".to_string(),
275        });
276
277        // Drug discovery
278        templates.push(TemplateMetadata {
279            name: "Drug Discovery".to_string(),
280            description: "VQE-based molecular simulation for drug-target interaction".to_string(),
281            domain: Domain::Chemistry,
282            problem_type: ProblemType::BinaryClassification,
283            input_features: vec![
284                "drug_structure".to_string(),
285                "target_structure".to_string(),
286                "binding_site_features".to_string(),
287                "pharmacophore_features".to_string(),
288            ],
289            output_description: "Binding affinity prediction".to_string(),
290            recommended_dataset_size: 10000,
291            complexity: ModelComplexity::Research,
292            required_qubits: 20,
293            training_time_estimate: "6-12 hours".to_string(),
294            performance_notes: "Quantum advantage in modeling molecular interactions".to_string(),
295        });
296
297        // Catalyst design
298        templates.push(TemplateMetadata {
299            name: "Catalyst Design".to_string(),
300            description: "Quantum optimization for catalyst material discovery".to_string(),
301            domain: Domain::Chemistry,
302            problem_type: ProblemType::Optimization,
303            input_features: vec![
304                "material_composition".to_string(),
305                "surface_structure".to_string(),
306                "reaction_conditions".to_string(),
307                "electronic_properties".to_string(),
308            ],
309            output_description: "Optimal catalyst structure".to_string(),
310            recommended_dataset_size: 2000,
311            complexity: ModelComplexity::Research,
312            required_qubits: 16,
313            training_time_estimate: "4-10 hours".to_string(),
314            performance_notes: "Potential for discovering novel catalysts".to_string(),
315        });
316
317        self.templates.insert(Domain::Chemistry, templates);
318    }
319
320    /// Register healthcare domain templates
321    fn register_healthcare_templates(&mut self) {
322        let mut templates = Vec::new();
323
324        // Medical image analysis
325        templates.push(TemplateMetadata {
326            name: "Medical Image Analysis".to_string(),
327            description: "Quantum convolutional networks for medical image classification"
328                .to_string(),
329            domain: Domain::Healthcare,
330            problem_type: ProblemType::MultiClassification,
331            input_features: vec![
332                "image_pixels".to_string(),
333                "image_metadata".to_string(),
334                "patient_demographics".to_string(),
335            ],
336            output_description: "Disease classification or severity score".to_string(),
337            recommended_dataset_size: 20000,
338            complexity: ModelComplexity::Complex,
339            required_qubits: 14,
340            training_time_estimate: "3-8 hours".to_string(),
341            performance_notes: "Improved accuracy on small datasets".to_string(),
342        });
343
344        // Drug interaction prediction
345        templates.push(TemplateMetadata {
346            name: "Drug Interaction Prediction".to_string(),
347            description: "Quantum neural networks for predicting drug-drug interactions"
348                .to_string(),
349            domain: Domain::Healthcare,
350            problem_type: ProblemType::BinaryClassification,
351            input_features: vec![
352                "drug1_features".to_string(),
353                "drug2_features".to_string(),
354                "molecular_similarity".to_string(),
355                "pathway_information".to_string(),
356            ],
357            output_description: "Interaction probability and severity".to_string(),
358            recommended_dataset_size: 15000,
359            complexity: ModelComplexity::Intermediate,
360            required_qubits: 10,
361            training_time_estimate: "1-3 hours".to_string(),
362            performance_notes: "High sensitivity to rare but dangerous interactions".to_string(),
363        });
364
365        // Genomic analysis
366        templates.push(TemplateMetadata {
367            name: "Genomic Analysis".to_string(),
368            description: "Quantum feature selection for genomic data analysis".to_string(),
369            domain: Domain::Healthcare,
370            problem_type: ProblemType::MultiClassification,
371            input_features: vec![
372                "snp_data".to_string(),
373                "gene_expression".to_string(),
374                "epigenetic_markers".to_string(),
375                "clinical_phenotypes".to_string(),
376            ],
377            output_description: "Disease susceptibility prediction".to_string(),
378            recommended_dataset_size: 5000,
379            complexity: ModelComplexity::Research,
380            required_qubits: 18,
381            training_time_estimate: "4-12 hours".to_string(),
382            performance_notes: "Effective handling of high-dimensional genomic data".to_string(),
383        });
384
385        self.templates.insert(Domain::Healthcare, templates);
386    }
387
388    /// Register logistics domain templates
389    fn register_logistics_templates(&mut self) {
390        let mut templates = Vec::new();
391
392        // Vehicle routing optimization
393        templates.push(TemplateMetadata {
394            name: "Vehicle Routing Optimization".to_string(),
395            description: "QAOA-based solution for vehicle routing problems".to_string(),
396            domain: Domain::Logistics,
397            problem_type: ProblemType::Optimization,
398            input_features: vec![
399                "delivery_locations".to_string(),
400                "distance_matrix".to_string(),
401                "vehicle_capacity".to_string(),
402                "time_windows".to_string(),
403                "traffic_patterns".to_string(),
404            ],
405            output_description: "Optimal routes for each vehicle".to_string(),
406            recommended_dataset_size: 1000,
407            complexity: ModelComplexity::Intermediate,
408            required_qubits: 12,
409            training_time_estimate: "30 minutes - 2 hours".to_string(),
410            performance_notes: "Quantum advantage for complex routing constraints".to_string(),
411        });
412
413        // Supply chain optimization
414        templates.push(TemplateMetadata {
415            name: "Supply Chain Optimization".to_string(),
416            description: "Quantum optimization for supply chain network design".to_string(),
417            domain: Domain::Logistics,
418            problem_type: ProblemType::Optimization,
419            input_features: vec![
420                "supplier_locations".to_string(),
421                "demand_forecasts".to_string(),
422                "transportation_costs".to_string(),
423                "capacity_constraints".to_string(),
424                "risk_factors".to_string(),
425            ],
426            output_description: "Optimal supply chain configuration".to_string(),
427            recommended_dataset_size: 2000,
428            complexity: ModelComplexity::Complex,
429            required_qubits: 16,
430            training_time_estimate: "2-6 hours".to_string(),
431            performance_notes: "Handles complex multi-objective optimization".to_string(),
432        });
433
434        // Inventory management
435        templates.push(TemplateMetadata {
436            name: "Inventory Management".to_string(),
437            description: "Quantum time series forecasting for inventory optimization".to_string(),
438            domain: Domain::Logistics,
439            problem_type: ProblemType::TimeSeriesForecasting,
440            input_features: vec![
441                "historical_demand".to_string(),
442                "seasonal_patterns".to_string(),
443                "economic_indicators".to_string(),
444                "promotional_events".to_string(),
445            ],
446            output_description: "Demand forecasts and optimal stock levels".to_string(),
447            recommended_dataset_size: 10000,
448            complexity: ModelComplexity::Intermediate,
449            required_qubits: 8,
450            training_time_estimate: "1-4 hours".to_string(),
451            performance_notes: "Improved accuracy in demand prediction".to_string(),
452        });
453
454        self.templates.insert(Domain::Logistics, templates);
455    }
456
457    /// Register energy domain templates
458    fn register_energy_templates(&mut self) {
459        let mut templates = Vec::new();
460
461        // Smart grid optimization
462        templates.push(TemplateMetadata {
463            name: "Smart Grid Optimization".to_string(),
464            description: "Quantum optimization for smart grid energy distribution".to_string(),
465            domain: Domain::Energy,
466            problem_type: ProblemType::Optimization,
467            input_features: vec![
468                "energy_demand".to_string(),
469                "renewable_generation".to_string(),
470                "grid_topology".to_string(),
471                "storage_capacity".to_string(),
472                "pricing_signals".to_string(),
473            ],
474            output_description: "Optimal energy distribution plan".to_string(),
475            recommended_dataset_size: 5000,
476            complexity: ModelComplexity::Complex,
477            required_qubits: 14,
478            training_time_estimate: "2-6 hours".to_string(),
479            performance_notes: "Real-time optimization capabilities".to_string(),
480        });
481
482        // Renewable energy forecasting
483        templates.push(TemplateMetadata {
484            name: "Renewable Energy Forecasting".to_string(),
485            description: "Quantum time series models for wind/solar power prediction".to_string(),
486            domain: Domain::Energy,
487            problem_type: ProblemType::TimeSeriesForecasting,
488            input_features: vec![
489                "weather_data".to_string(),
490                "historical_generation".to_string(),
491                "satellite_imagery".to_string(),
492                "atmospheric_conditions".to_string(),
493            ],
494            output_description: "Power generation forecasts".to_string(),
495            recommended_dataset_size: 50000,
496            complexity: ModelComplexity::Intermediate,
497            required_qubits: 10,
498            training_time_estimate: "2-5 hours".to_string(),
499            performance_notes: "Better handling of weather uncertainty".to_string(),
500        });
501
502        // Energy trading
503        templates.push(TemplateMetadata {
504            name: "Energy Trading".to_string(),
505            description: "Quantum reinforcement learning for energy market trading".to_string(),
506            domain: Domain::Energy,
507            problem_type: ProblemType::TimeSeriesForecasting,
508            input_features: vec![
509                "energy_prices".to_string(),
510                "demand_patterns".to_string(),
511                "market_fundamentals".to_string(),
512                "regulatory_signals".to_string(),
513            ],
514            output_description: "Trading strategies and price predictions".to_string(),
515            recommended_dataset_size: 20000,
516            complexity: ModelComplexity::Research,
517            required_qubits: 16,
518            training_time_estimate: "4-10 hours".to_string(),
519            performance_notes: "Adaptive to rapidly changing market conditions".to_string(),
520        });
521
522        self.templates.insert(Domain::Energy, templates);
523    }
524
525    /// Register materials science templates
526    fn register_materials_templates(&mut self) {
527        let mut templates = Vec::new();
528
529        // Material property prediction
530        templates.push(TemplateMetadata {
531            name: "Material Property Prediction".to_string(),
532            description: "Quantum neural networks for predicting material properties".to_string(),
533            domain: Domain::Materials,
534            problem_type: ProblemType::Regression,
535            input_features: vec![
536                "crystal_structure".to_string(),
537                "elemental_composition".to_string(),
538                "synthesis_conditions".to_string(),
539                "electronic_structure".to_string(),
540            ],
541            output_description: "Material properties (conductivity, strength, etc.)".to_string(),
542            recommended_dataset_size: 8000,
543            complexity: ModelComplexity::Complex,
544            required_qubits: 12,
545            training_time_estimate: "2-6 hours".to_string(),
546            performance_notes: "Quantum advantage in modeling electronic properties".to_string(),
547        });
548
549        // Battery material discovery
550        templates.push(TemplateMetadata {
551            name: "Battery Material Discovery".to_string(),
552            description: "Quantum optimization for battery electrode materials".to_string(),
553            domain: Domain::Materials,
554            problem_type: ProblemType::Optimization,
555            input_features: vec![
556                "material_composition".to_string(),
557                "electrode_structure".to_string(),
558                "electrolyte_properties".to_string(),
559                "operating_conditions".to_string(),
560            ],
561            output_description: "Optimal material composition and structure".to_string(),
562            recommended_dataset_size: 3000,
563            complexity: ModelComplexity::Research,
564            required_qubits: 18,
565            training_time_estimate: "4-12 hours".to_string(),
566            performance_notes: "Novel materials discovery potential".to_string(),
567        });
568
569        self.templates.insert(Domain::Materials, templates);
570    }
571
572    /// Register physics domain templates
573    fn register_physics_templates(&mut self) {
574        let mut templates = Vec::new();
575
576        // Particle physics event classification
577        templates.push(TemplateMetadata {
578            name: "Particle Physics Event Classification".to_string(),
579            description: "Quantum neural networks for high-energy physics event classification"
580                .to_string(),
581            domain: Domain::Physics,
582            problem_type: ProblemType::MultiClassification,
583            input_features: vec![
584                "detector_hits".to_string(),
585                "particle_tracks".to_string(),
586                "energy_deposits".to_string(),
587                "timing_information".to_string(),
588            ],
589            output_description: "Event type classification".to_string(),
590            recommended_dataset_size: 100000,
591            complexity: ModelComplexity::Research,
592            required_qubits: 16,
593            training_time_estimate: "4-12 hours".to_string(),
594            performance_notes: "Potential quantum advantage in pattern recognition".to_string(),
595        });
596
597        self.templates.insert(Domain::Physics, templates);
598    }
599
600    /// Register NLP domain templates
601    fn register_nlp_templates(&mut self) {
602        let mut templates = Vec::new();
603
604        // Quantum text classification
605        templates.push(TemplateMetadata {
606            name: "Quantum Text Classification".to_string(),
607            description: "Quantum neural networks for text classification tasks".to_string(),
608            domain: Domain::NLP,
609            problem_type: ProblemType::MultiClassification,
610            input_features: vec![
611                "text_embeddings".to_string(),
612                "linguistic_features".to_string(),
613                "semantic_features".to_string(),
614            ],
615            output_description: "Text category classification".to_string(),
616            recommended_dataset_size: 25000,
617            complexity: ModelComplexity::Intermediate,
618            required_qubits: 10,
619            training_time_estimate: "2-5 hours".to_string(),
620            performance_notes: "Effective for small to medium vocabulary".to_string(),
621        });
622
623        self.templates.insert(Domain::NLP, templates);
624    }
625
626    /// Register vision domain templates
627    fn register_vision_templates(&mut self) {
628        let mut templates = Vec::new();
629
630        // Quantum image classification
631        templates.push(TemplateMetadata {
632            name: "Quantum Image Classification".to_string(),
633            description: "Quantum convolutional networks for image classification".to_string(),
634            domain: Domain::Vision,
635            problem_type: ProblemType::MultiClassification,
636            input_features: vec![
637                "image_pixels".to_string(),
638                "texture_features".to_string(),
639                "edge_features".to_string(),
640            ],
641            output_description: "Image class prediction".to_string(),
642            recommended_dataset_size: 30000,
643            complexity: ModelComplexity::Complex,
644            required_qubits: 12,
645            training_time_estimate: "3-8 hours".to_string(),
646            performance_notes: "Quantum advantage on small image datasets".to_string(),
647        });
648
649        self.templates.insert(Domain::Vision, templates);
650    }
651
652    /// Register security domain templates
653    fn register_security_templates(&mut self) {
654        let mut templates = Vec::new();
655
656        // Intrusion detection
657        templates.push(TemplateMetadata {
658            name: "Network Intrusion Detection".to_string(),
659            description: "Quantum anomaly detection for cybersecurity".to_string(),
660            domain: Domain::Security,
661            problem_type: ProblemType::AnomalyDetection,
662            input_features: vec![
663                "network_traffic".to_string(),
664                "connection_patterns".to_string(),
665                "payload_features".to_string(),
666                "temporal_patterns".to_string(),
667            ],
668            output_description: "Intrusion probability and attack type".to_string(),
669            recommended_dataset_size: 40000,
670            complexity: ModelComplexity::Complex,
671            required_qubits: 14,
672            training_time_estimate: "3-7 hours".to_string(),
673            performance_notes: "High sensitivity to novel attack patterns".to_string(),
674        });
675
676        self.templates.insert(Domain::Security, templates);
677    }
678
679    /// Register climate domain templates
680    fn register_climate_templates(&mut self) {
681        let mut templates = Vec::new();
682
683        // Climate modeling
684        templates.push(TemplateMetadata {
685            name: "Climate Pattern Recognition".to_string(),
686            description: "Quantum neural networks for climate pattern analysis".to_string(),
687            domain: Domain::Climate,
688            problem_type: ProblemType::TimeSeriesForecasting,
689            input_features: vec![
690                "temperature_data".to_string(),
691                "precipitation_data".to_string(),
692                "atmospheric_pressure".to_string(),
693                "ocean_temperatures".to_string(),
694            ],
695            output_description: "Climate pattern predictions".to_string(),
696            recommended_dataset_size: 50000,
697            complexity: ModelComplexity::Research,
698            required_qubits: 16,
699            training_time_estimate: "6-15 hours".to_string(),
700            performance_notes: "Enhanced modeling of complex climate interactions".to_string(),
701        });
702
703        self.templates.insert(Domain::Climate, templates);
704    }
705
706    /// Register aerospace domain templates
707    fn register_aerospace_templates(&mut self) {
708        let mut templates = Vec::new();
709
710        // Trajectory optimization
711        templates.push(TemplateMetadata {
712            name: "Spacecraft Trajectory Optimization".to_string(),
713            description: "Quantum optimization for spacecraft trajectory planning".to_string(),
714            domain: Domain::Aerospace,
715            problem_type: ProblemType::Optimization,
716            input_features: vec![
717                "initial_conditions".to_string(),
718                "target_orbit".to_string(),
719                "gravitational_fields".to_string(),
720                "fuel_constraints".to_string(),
721            ],
722            output_description: "Optimal trajectory and control inputs".to_string(),
723            recommended_dataset_size: 1000,
724            complexity: ModelComplexity::Research,
725            required_qubits: 20,
726            training_time_estimate: "2-8 hours".to_string(),
727            performance_notes: "Potential for discovering novel trajectory solutions".to_string(),
728        });
729
730        self.templates.insert(Domain::Aerospace, templates);
731    }
732
733    /// Get templates for a specific domain
734    pub fn get_domain_templates(&self, domain: &Domain) -> Option<&Vec<TemplateMetadata>> {
735        self.templates.get(domain)
736    }
737
738    /// Get all available domains
739    pub fn get_available_domains(&self) -> Vec<Domain> {
740        self.templates.keys().cloned().collect()
741    }
742
743    /// Get a specific template by name
744    pub fn get_template(&self, template_name: &str) -> Result<&TemplateMetadata> {
745        self.templates
746            .values()
747            .flatten()
748            .find(|t| t.name == template_name)
749            .ok_or_else(|| {
750                MLError::InvalidConfiguration(format!("Template not found: {}", template_name))
751            })
752    }
753
754    /// Search templates by problem type
755    pub fn search_by_problem_type(&self, problem_type: &ProblemType) -> Vec<&TemplateMetadata> {
756        self.templates
757            .values()
758            .flatten()
759            .filter(|template| {
760                std::mem::discriminant(&template.problem_type)
761                    == std::mem::discriminant(problem_type)
762            })
763            .collect()
764    }
765
766    /// Search templates by complexity
767    pub fn search_by_complexity(&self, complexity: &ModelComplexity) -> Vec<&TemplateMetadata> {
768        self.templates
769            .values()
770            .flatten()
771            .filter(|template| {
772                std::mem::discriminant(&template.complexity) == std::mem::discriminant(complexity)
773            })
774            .collect()
775    }
776
777    /// Search templates by qubit requirements
778    pub fn search_by_qubits(&self, max_qubits: usize) -> Vec<&TemplateMetadata> {
779        self.templates
780            .values()
781            .flatten()
782            .filter(|template| template.required_qubits <= max_qubits)
783            .collect()
784    }
785
786    /// Get template recommendations
787    pub fn recommend_templates(
788        &self,
789        domain: Option<&Domain>,
790        problem_type: Option<&ProblemType>,
791        max_qubits: Option<usize>,
792        complexity: Option<&ModelComplexity>,
793    ) -> Vec<&TemplateMetadata> {
794        let mut candidates: Vec<&TemplateMetadata> = self.templates.values().flatten().collect();
795
796        // Filter by domain
797        if let Some(domain) = domain {
798            candidates.retain(|template| &template.domain == domain);
799        }
800
801        // Filter by problem type
802        if let Some(problem_type) = problem_type {
803            candidates.retain(|template| {
804                std::mem::discriminant(&template.problem_type)
805                    == std::mem::discriminant(problem_type)
806            });
807        }
808
809        // Filter by qubit requirements
810        if let Some(max_qubits) = max_qubits {
811            candidates.retain(|template| template.required_qubits <= max_qubits);
812        }
813
814        // Filter by complexity
815        if let Some(complexity) = complexity {
816            candidates.retain(|template| {
817                std::mem::discriminant(&template.complexity) == std::mem::discriminant(complexity)
818            });
819        }
820
821        // Sort by complexity (simpler first)
822        candidates.sort_by(|a, b| {
823            use ModelComplexity::*;
824            let order_a = match a.complexity {
825                Simple => 0,
826                Intermediate => 1,
827                Complex => 2,
828                Research => 3,
829            };
830            let order_b = match b.complexity {
831                Simple => 0,
832                Intermediate => 1,
833                Complex => 2,
834                Research => 3,
835            };
836            order_a.cmp(&order_b)
837        });
838
839        candidates
840    }
841
842    /// Create a model from a template
843    pub fn create_model_from_template(
844        &self,
845        template_name: &str,
846        config: TemplateConfig,
847    ) -> Result<Box<dyn DomainModel>> {
848        // Find the template
849        let template = self
850            .templates
851            .values()
852            .flatten()
853            .find(|t| t.name == template_name)
854            .ok_or_else(|| {
855                MLError::InvalidConfiguration(format!("Template not found: {}", template_name))
856            })?;
857
858        match template.domain {
859            Domain::Finance => self.create_finance_model(template, config),
860            Domain::Chemistry => self.create_chemistry_model(template, config),
861            Domain::Healthcare => self.create_healthcare_model(template, config),
862            Domain::Logistics => self.create_logistics_model(template, config),
863            Domain::Energy => self.create_energy_model(template, config),
864            Domain::Materials => self.create_materials_model(template, config),
865            Domain::Physics => self.create_physics_model(template, config),
866            Domain::NLP => self.create_nlp_model(template, config),
867            Domain::Vision => self.create_vision_model(template, config),
868            Domain::Security => self.create_security_model(template, config),
869            Domain::Climate => self.create_climate_model(template, config),
870            Domain::Aerospace => self.create_aerospace_model(template, config),
871        }
872    }
873
874    /// Create finance domain model
875    fn create_finance_model(
876        &self,
877        template: &TemplateMetadata,
878        config: TemplateConfig,
879    ) -> Result<Box<dyn DomainModel>> {
880        match template.name.as_str() {
881            "Portfolio Optimization" => Ok(Box::new(PortfolioOptimizationModel::new(config)?)),
882            "Credit Risk Assessment" => Ok(Box::new(CreditRiskModel::new(config)?)),
883            "Fraud Detection" => Ok(Box::new(FraudDetectionModel::new(config)?)),
884            "Algorithmic Trading" => Ok(Box::new(AlgorithmicTradingModel::new(config)?)),
885            _ => Err(MLError::InvalidConfiguration(format!(
886                "Unknown finance template: {}",
887                template.name
888            ))),
889        }
890    }
891
892    /// Create chemistry domain model
893    fn create_chemistry_model(
894        &self,
895        template: &TemplateMetadata,
896        config: TemplateConfig,
897    ) -> Result<Box<dyn DomainModel>> {
898        match template.name.as_str() {
899            "Molecular Property Prediction" => Ok(Box::new(MolecularPropertyModel::new(config)?)),
900            "Drug Discovery" => Ok(Box::new(DrugDiscoveryModel::new(config)?)),
901            "Catalyst Design" => Ok(Box::new(CatalystDesignModel::new(config)?)),
902            _ => Err(MLError::InvalidConfiguration(format!(
903                "Unknown chemistry template: {}",
904                template.name
905            ))),
906        }
907    }
908
909    /// Create healthcare domain model
910    fn create_healthcare_model(
911        &self,
912        template: &TemplateMetadata,
913        config: TemplateConfig,
914    ) -> Result<Box<dyn DomainModel>> {
915        match template.name.as_str() {
916            "Medical Image Analysis" => Ok(Box::new(MedicalImageModel::new(config)?)),
917            "Drug Interaction Prediction" => Ok(Box::new(DrugInteractionModel::new(config)?)),
918            "Genomic Analysis" => Ok(Box::new(GenomicAnalysisModel::new(config)?)),
919            _ => Err(MLError::InvalidConfiguration(format!(
920                "Unknown healthcare template: {}",
921                template.name
922            ))),
923        }
924    }
925
926    /// Create logistics domain model
927    fn create_logistics_model(
928        &self,
929        template: &TemplateMetadata,
930        config: TemplateConfig,
931    ) -> Result<Box<dyn DomainModel>> {
932        match template.name.as_str() {
933            "Vehicle Routing Optimization" => Ok(Box::new(VehicleRoutingModel::new(config)?)),
934            "Supply Chain Optimization" => Ok(Box::new(SupplyChainModel::new(config)?)),
935            "Inventory Management" => Ok(Box::new(InventoryManagementModel::new(config)?)),
936            _ => Err(MLError::InvalidConfiguration(format!(
937                "Unknown logistics template: {}",
938                template.name
939            ))),
940        }
941    }
942
943    /// Create energy domain model
944    fn create_energy_model(
945        &self,
946        template: &TemplateMetadata,
947        config: TemplateConfig,
948    ) -> Result<Box<dyn DomainModel>> {
949        match template.name.as_str() {
950            "Smart Grid Optimization" => Ok(Box::new(SmartGridModel::new(config)?)),
951            "Renewable Energy Forecasting" => Ok(Box::new(RenewableEnergyModel::new(config)?)),
952            "Energy Trading" => Ok(Box::new(EnergyTradingModel::new(config)?)),
953            _ => Err(MLError::InvalidConfiguration(format!(
954                "Unknown energy template: {}",
955                template.name
956            ))),
957        }
958    }
959
960    /// Create materials domain model
961    fn create_materials_model(
962        &self,
963        template: &TemplateMetadata,
964        config: TemplateConfig,
965    ) -> Result<Box<dyn DomainModel>> {
966        match template.name.as_str() {
967            "Material Property Prediction" => Ok(Box::new(MaterialPropertyModel::new(config)?)),
968            "Battery Material Discovery" => Ok(Box::new(BatteryMaterialModel::new(config)?)),
969            _ => Err(MLError::InvalidConfiguration(format!(
970                "Unknown materials template: {}",
971                template.name
972            ))),
973        }
974    }
975
976    /// Create physics domain model
977    fn create_physics_model(
978        &self,
979        template: &TemplateMetadata,
980        config: TemplateConfig,
981    ) -> Result<Box<dyn DomainModel>> {
982        match template.name.as_str() {
983            "Particle Physics Event Classification" => {
984                Ok(Box::new(ParticlePhysicsModel::new(config)?))
985            }
986            _ => Err(MLError::InvalidConfiguration(format!(
987                "Unknown physics template: {}",
988                template.name
989            ))),
990        }
991    }
992
993    /// Create NLP domain model
994    fn create_nlp_model(
995        &self,
996        template: &TemplateMetadata,
997        config: TemplateConfig,
998    ) -> Result<Box<dyn DomainModel>> {
999        match template.name.as_str() {
1000            "Quantum Text Classification" => Ok(Box::new(QuantumTextModel::new(config)?)),
1001            _ => Err(MLError::InvalidConfiguration(format!(
1002                "Unknown NLP template: {}",
1003                template.name
1004            ))),
1005        }
1006    }
1007
1008    /// Create vision domain model
1009    fn create_vision_model(
1010        &self,
1011        template: &TemplateMetadata,
1012        config: TemplateConfig,
1013    ) -> Result<Box<dyn DomainModel>> {
1014        match template.name.as_str() {
1015            "Quantum Image Classification" => Ok(Box::new(QuantumImageModel::new(config)?)),
1016            _ => Err(MLError::InvalidConfiguration(format!(
1017                "Unknown vision template: {}",
1018                template.name
1019            ))),
1020        }
1021    }
1022
1023    /// Create security domain model
1024    fn create_security_model(
1025        &self,
1026        template: &TemplateMetadata,
1027        config: TemplateConfig,
1028    ) -> Result<Box<dyn DomainModel>> {
1029        match template.name.as_str() {
1030            "Network Intrusion Detection" => Ok(Box::new(IntrusionDetectionModel::new(config)?)),
1031            _ => Err(MLError::InvalidConfiguration(format!(
1032                "Unknown security template: {}",
1033                template.name
1034            ))),
1035        }
1036    }
1037
1038    /// Create climate domain model
1039    fn create_climate_model(
1040        &self,
1041        template: &TemplateMetadata,
1042        config: TemplateConfig,
1043    ) -> Result<Box<dyn DomainModel>> {
1044        match template.name.as_str() {
1045            "Climate Pattern Recognition" => Ok(Box::new(ClimatePatternModel::new(config)?)),
1046            _ => Err(MLError::InvalidConfiguration(format!(
1047                "Unknown climate template: {}",
1048                template.name
1049            ))),
1050        }
1051    }
1052
1053    /// Create aerospace domain model
1054    fn create_aerospace_model(
1055        &self,
1056        template: &TemplateMetadata,
1057        config: TemplateConfig,
1058    ) -> Result<Box<dyn DomainModel>> {
1059        match template.name.as_str() {
1060            "Spacecraft Trajectory Optimization" => {
1061                Ok(Box::new(TrajectoryOptimizationModel::new(config)?))
1062            }
1063            _ => Err(MLError::InvalidConfiguration(format!(
1064                "Unknown aerospace template: {}",
1065                template.name
1066            ))),
1067        }
1068    }
1069}
1070
1071/// Trait for domain-specific models
1072pub trait DomainModel: Send + Sync {
1073    /// Model name
1074    fn name(&self) -> &str;
1075
1076    /// Domain
1077    fn domain(&self) -> Domain;
1078
1079    /// Make prediction
1080    fn predict(&self, input: &ArrayD<f64>) -> Result<ArrayD<f64>>;
1081
1082    /// Train the model
1083    fn train(&mut self, X: &ArrayD<f64>, y: &ArrayD<f64>) -> Result<()>;
1084
1085    /// Get model configuration
1086    fn config(&self) -> &TemplateConfig;
1087
1088    /// Get training suggestions
1089    fn training_suggestions(&self) -> Vec<String>;
1090
1091    /// Get preprocessing requirements
1092    fn preprocessing_requirements(&self) -> Vec<String>;
1093}
1094
1095// Concrete domain model implementations (simplified for brevity)
1096
1097/// Portfolio optimization model
1098pub struct PortfolioOptimizationModel {
1099    config: TemplateConfig,
1100    qaoa_params: Vec<f64>,
1101}
1102
1103impl PortfolioOptimizationModel {
1104    pub fn new(config: TemplateConfig) -> Result<Self> {
1105        let qaoa_params = vec![0.5; config.num_qubits * 2]; // Beta and gamma parameters
1106        Ok(Self {
1107            config,
1108            qaoa_params,
1109        })
1110    }
1111}
1112
1113impl DomainModel for PortfolioOptimizationModel {
1114    fn name(&self) -> &str {
1115        "Portfolio Optimization"
1116    }
1117    fn domain(&self) -> Domain {
1118        Domain::Finance
1119    }
1120
1121    fn predict(&self, input: &ArrayD<f64>) -> Result<ArrayD<f64>> {
1122        // Simplified portfolio optimization
1123        let returns = input.slice(s![..self.config.output_dim]);
1124        let weights = returns.mapv(|x| if x > 0.0 { 1.0 } else { 0.0 });
1125        let normalized_weights = &weights / weights.sum();
1126        Ok(normalized_weights.to_owned().into_dyn())
1127    }
1128
1129    fn train(&mut self, _X: &ArrayD<f64>, _y: &ArrayD<f64>) -> Result<()> {
1130        // Placeholder for QAOA training
1131        Ok(())
1132    }
1133
1134    fn config(&self) -> &TemplateConfig {
1135        &self.config
1136    }
1137
1138    fn training_suggestions(&self) -> Vec<String> {
1139        vec![
1140            "Use historical return data with at least 252 trading days".to_string(),
1141            "Include risk-free rate and market volatility data".to_string(),
1142            "Consider transaction costs in the optimization".to_string(),
1143        ]
1144    }
1145
1146    fn preprocessing_requirements(&self) -> Vec<String> {
1147        vec![
1148            "Normalize returns to [-1, 1] range".to_string(),
1149            "Remove outliers beyond 3 standard deviations".to_string(),
1150            "Fill missing data with forward fill method".to_string(),
1151        ]
1152    }
1153}
1154
1155// Placeholder implementations for other domain models
1156macro_rules! impl_domain_model {
1157    ($model_name:ident, $domain:expr, $display_name:expr) => {
1158        pub struct $model_name {
1159            config: TemplateConfig,
1160        }
1161
1162        impl $model_name {
1163            pub fn new(config: TemplateConfig) -> Result<Self> {
1164                Ok(Self { config })
1165            }
1166        }
1167
1168        impl DomainModel for $model_name {
1169            fn name(&self) -> &str {
1170                $display_name
1171            }
1172            fn domain(&self) -> Domain {
1173                $domain
1174            }
1175
1176            fn predict(&self, input: &ArrayD<f64>) -> Result<ArrayD<f64>> {
1177                // Placeholder implementation
1178                Ok(ArrayD::zeros(IxDyn(&[self.config.output_dim])))
1179            }
1180
1181            fn train(&mut self, _X: &ArrayD<f64>, _y: &ArrayD<f64>) -> Result<()> {
1182                Ok(())
1183            }
1184
1185            fn config(&self) -> &TemplateConfig {
1186                &self.config
1187            }
1188
1189            fn training_suggestions(&self) -> Vec<String> {
1190                vec!["Domain-specific training suggestions".to_string()]
1191            }
1192
1193            fn preprocessing_requirements(&self) -> Vec<String> {
1194                vec!["Domain-specific preprocessing requirements".to_string()]
1195            }
1196        }
1197    };
1198}
1199
1200// Generate placeholder implementations for all domain models
1201impl_domain_model!(CreditRiskModel, Domain::Finance, "Credit Risk Assessment");
1202impl_domain_model!(FraudDetectionModel, Domain::Finance, "Fraud Detection");
1203impl_domain_model!(
1204    AlgorithmicTradingModel,
1205    Domain::Finance,
1206    "Algorithmic Trading"
1207);
1208impl_domain_model!(
1209    MolecularPropertyModel,
1210    Domain::Chemistry,
1211    "Molecular Property Prediction"
1212);
1213impl_domain_model!(DrugDiscoveryModel, Domain::Chemistry, "Drug Discovery");
1214impl_domain_model!(CatalystDesignModel, Domain::Chemistry, "Catalyst Design");
1215impl_domain_model!(
1216    MedicalImageModel,
1217    Domain::Healthcare,
1218    "Medical Image Analysis"
1219);
1220impl_domain_model!(
1221    DrugInteractionModel,
1222    Domain::Healthcare,
1223    "Drug Interaction Prediction"
1224);
1225impl_domain_model!(GenomicAnalysisModel, Domain::Healthcare, "Genomic Analysis");
1226impl_domain_model!(
1227    VehicleRoutingModel,
1228    Domain::Logistics,
1229    "Vehicle Routing Optimization"
1230);
1231impl_domain_model!(
1232    SupplyChainModel,
1233    Domain::Logistics,
1234    "Supply Chain Optimization"
1235);
1236impl_domain_model!(
1237    InventoryManagementModel,
1238    Domain::Logistics,
1239    "Inventory Management"
1240);
1241impl_domain_model!(SmartGridModel, Domain::Energy, "Smart Grid Optimization");
1242impl_domain_model!(
1243    RenewableEnergyModel,
1244    Domain::Energy,
1245    "Renewable Energy Forecasting"
1246);
1247impl_domain_model!(EnergyTradingModel, Domain::Energy, "Energy Trading");
1248impl_domain_model!(
1249    MaterialPropertyModel,
1250    Domain::Materials,
1251    "Material Property Prediction"
1252);
1253impl_domain_model!(
1254    BatteryMaterialModel,
1255    Domain::Materials,
1256    "Battery Material Discovery"
1257);
1258impl_domain_model!(
1259    ParticlePhysicsModel,
1260    Domain::Physics,
1261    "Particle Physics Event Classification"
1262);
1263impl_domain_model!(QuantumTextModel, Domain::NLP, "Quantum Text Classification");
1264impl_domain_model!(
1265    QuantumImageModel,
1266    Domain::Vision,
1267    "Quantum Image Classification"
1268);
1269impl_domain_model!(
1270    IntrusionDetectionModel,
1271    Domain::Security,
1272    "Network Intrusion Detection"
1273);
1274impl_domain_model!(
1275    ClimatePatternModel,
1276    Domain::Climate,
1277    "Climate Pattern Recognition"
1278);
1279impl_domain_model!(
1280    TrajectoryOptimizationModel,
1281    Domain::Aerospace,
1282    "Spacecraft Trajectory Optimization"
1283);
1284
1285/// Utility functions for domain templates
1286pub mod utils {
1287    use super::*;
1288
1289    /// Get the default template manager
1290    pub fn get_default_template_manager() -> DomainTemplateManager {
1291        DomainTemplateManager::new()
1292    }
1293
1294    /// Print template information
1295    pub fn print_template_info(template: &TemplateMetadata) {
1296        println!("Template: {}", template.name);
1297        println!("Domain: {:?}", template.domain);
1298        println!("Description: {}", template.description);
1299        println!("Problem Type: {:?}", template.problem_type);
1300        println!("Complexity: {:?}", template.complexity);
1301        println!("Required Qubits: {}", template.required_qubits);
1302        println!("Input Features: {:?}", template.input_features);
1303        println!("Output: {}", template.output_description);
1304        println!(
1305            "Recommended Dataset Size: {}",
1306            template.recommended_dataset_size
1307        );
1308        println!("Training Time: {}", template.training_time_estimate);
1309        println!("Performance Notes: {}", template.performance_notes);
1310        println!();
1311    }
1312
1313    /// Generate domain template report
1314    pub fn generate_domain_report(manager: &DomainTemplateManager) -> String {
1315        let mut report = String::new();
1316        report.push_str("Domain Template Report\n");
1317        report.push_str("=====================\n\n");
1318
1319        for domain in manager.get_available_domains() {
1320            if let Some(templates) = manager.get_domain_templates(&domain) {
1321                report.push_str(&format!(
1322                    "{:?} Domain ({} templates):\n",
1323                    domain,
1324                    templates.len()
1325                ));
1326                for template in templates {
1327                    report.push_str(&format!(
1328                        "  - {}: {} qubits, {:?} complexity\n",
1329                        template.name, template.required_qubits, template.complexity
1330                    ));
1331                }
1332                report.push_str("\n");
1333            }
1334        }
1335
1336        report
1337    }
1338
1339    /// Check template compatibility with available resources
1340    pub fn check_template_feasibility(
1341        template: &TemplateMetadata,
1342        available_qubits: usize,
1343        available_time_hours: f64,
1344    ) -> (bool, Vec<String>) {
1345        let mut feasible = true;
1346        let mut issues = Vec::new();
1347
1348        if template.required_qubits > available_qubits {
1349            feasible = false;
1350            issues.push(format!(
1351                "Requires {} qubits but only {} available",
1352                template.required_qubits, available_qubits
1353            ));
1354        }
1355
1356        // Parse training time estimate
1357        let estimated_hours = if template.training_time_estimate.contains("minutes") {
1358            0.5 // Assume 30 minutes average
1359        } else if template.training_time_estimate.contains("hour") {
1360            if template.training_time_estimate.contains("-") {
1361                4.0 // Average of range
1362            } else {
1363                2.0 // Default
1364            }
1365        } else {
1366            2.0 // Default
1367        };
1368
1369        if estimated_hours > available_time_hours {
1370            issues.push(format!(
1371                "Estimated training time {} exceeds available time {:.1} hours",
1372                template.training_time_estimate, available_time_hours
1373            ));
1374        }
1375
1376        (feasible, issues)
1377    }
1378}
1379
1380#[cfg(test)]
1381mod tests {
1382    use super::*;
1383
1384    #[test]
1385    fn test_template_manager_creation() {
1386        let manager = DomainTemplateManager::new();
1387        assert!(!manager.get_available_domains().is_empty());
1388    }
1389
1390    #[test]
1391    fn test_domain_templates() {
1392        let manager = DomainTemplateManager::new();
1393        let finance_templates = manager.get_domain_templates(&Domain::Finance);
1394        assert!(finance_templates.is_some());
1395        assert!(!finance_templates.unwrap().is_empty());
1396    }
1397
1398    #[test]
1399    fn test_template_search() {
1400        let manager = DomainTemplateManager::new();
1401
1402        let classification_templates =
1403            manager.search_by_problem_type(&ProblemType::BinaryClassification);
1404        assert!(!classification_templates.is_empty());
1405
1406        let simple_templates = manager.search_by_complexity(&ModelComplexity::Simple);
1407        // May be empty if no simple templates exist
1408
1409        let low_qubit_templates = manager.search_by_qubits(8);
1410        assert!(!low_qubit_templates.is_empty());
1411    }
1412
1413    #[test]
1414    fn test_template_recommendations() {
1415        let manager = DomainTemplateManager::new();
1416
1417        let recommendations = manager.recommend_templates(
1418            Some(&Domain::Finance),
1419            Some(&ProblemType::BinaryClassification),
1420            Some(10),
1421            Some(&ModelComplexity::Intermediate),
1422        );
1423
1424        for template in recommendations {
1425            assert_eq!(template.domain, Domain::Finance);
1426            assert!(matches!(
1427                template.problem_type,
1428                ProblemType::BinaryClassification
1429            ));
1430            assert!(template.required_qubits <= 10);
1431        }
1432    }
1433
1434    #[test]
1435    fn test_model_creation() {
1436        let manager = DomainTemplateManager::new();
1437        let config = TemplateConfig {
1438            num_qubits: 10,
1439            input_dim: 5,
1440            output_dim: 3,
1441            parameters: HashMap::new(),
1442        };
1443
1444        let model = manager.create_model_from_template("Portfolio Optimization", config);
1445        assert!(model.is_ok());
1446
1447        let model = model.unwrap();
1448        assert_eq!(model.name(), "Portfolio Optimization");
1449        assert_eq!(model.domain(), Domain::Finance);
1450    }
1451
1452    #[test]
1453    fn test_template_feasibility() {
1454        let manager = DomainTemplateManager::new();
1455        let finance_templates = manager.get_domain_templates(&Domain::Finance).unwrap();
1456        let template = &finance_templates[0];
1457
1458        let (feasible, issues) = utils::check_template_feasibility(template, 20, 10.0);
1459        assert!(feasible || !issues.is_empty());
1460    }
1461}
quantrs2_ml/domain_templates.rs

quantrs2_ml/
domain_templates.rs
