optirs_nas/nas_engine/
config.rs

1// Neural Architecture Search Configuration
2//
3// This module contains all configuration types, enums, and parameter definitions
4// for the Neural Architecture Search system.
5
6use crate::EvaluationMetric;
7use scirs2_core::numeric::Float;
8use std::collections::HashMap;
9use std::fmt::Debug;
10use std::time::Duration;
11
12/// Neural Architecture Search configuration for optimizers
13#[derive(Debug, Clone)]
14pub struct NASConfig<T: Float + Debug + Send + Sync + 'static> {
15    /// Search strategy to use
16    pub search_strategy: SearchStrategyType,
17
18    /// Architecture search space
19    pub search_space: SearchSpaceConfig,
20
21    /// Performance evaluation configuration
22    pub evaluation_config: EvaluationConfig<T>,
23
24    /// Multi-objective optimization settings
25    pub multi_objective_config: MultiObjectiveConfig<T>,
26
27    /// Search budget (number of architectures to evaluate)
28    pub search_budget: usize,
29
30    /// Early stopping criteria
31    pub early_stopping: EarlyStoppingConfig<T>,
32
33    /// Enable progressive search
34    pub progressive_search: bool,
35
36    /// Population size for evolutionary/genetic algorithms
37    pub population_size: usize,
38
39    /// Enable architecture transfer learning
40    pub enable_transfer_learning: bool,
41
42    /// Architecture encoding strategy
43    pub encoding_strategy: ArchitectureEncodingStrategy,
44
45    /// Enable performance prediction
46    pub enable_performance_prediction: bool,
47
48    /// Search parallelization factor
49    pub parallelization_factor: usize,
50
51    /// Enable automated hyperparameter tuning
52    pub auto_hyperparameter_tuning: bool,
53
54    /// Resource constraints
55    pub resource_constraints: ResourceConstraints<T>,
56}
57
58/// Search strategy types
59#[derive(Debug, Clone)]
60pub enum SearchStrategyType {
61    /// Random search baseline
62    Random,
63
64    /// Evolutionary/genetic algorithm search
65    Evolutionary,
66
67    /// Reinforcement learning-based search
68    ReinforcementLearning,
69
70    /// Differentiable architecture search (DARTS)
71    Differentiable,
72
73    /// Bayesian optimization
74    BayesianOptimization,
75
76    /// Progressive search
77    Progressive,
78
79    /// Multi-objective evolutionary algorithm
80    MultiObjectiveEvolutionary,
81
82    /// Neural predictor-based search
83    NeuralPredictorBased,
84}
85
86/// Search space configuration
87#[derive(Debug, Clone)]
88pub struct SearchSpaceConfig {
89    /// Available optimizer components
90    pub components: Vec<OptimizerComponentConfig>,
91
92    /// Connection patterns between components
93    pub connection_patterns: Vec<ConnectionPatternType>,
94
95    /// Learning rate schedule search space
96    pub learning_rate_schedules: LearningRateScheduleSpace,
97
98    /// Regularization technique search space
99    pub regularization_techniques: RegularizationSpace,
100
101    /// Adaptive mechanism search space
102    pub adaptive_mechanisms: AdaptiveMechanismSpace,
103
104    /// Memory usage constraints
105    pub memory_constraints: MemoryConstraints,
106
107    /// Computation constraints
108    pub computation_constraints: ComputationConstraints,
109
110    /// Component types to include in search
111    pub component_types: Vec<ComponentType>,
112
113    /// Maximum number of components
114    pub max_components: usize,
115
116    /// Minimum number of components
117    pub min_components: usize,
118
119    /// Maximum number of connections
120    pub max_connections: usize,
121}
122
123/// Optimizer component configuration for search
124#[derive(Debug, Clone)]
125pub struct OptimizerComponentConfig {
126    /// Component type
127    pub component_type: ComponentType,
128
129    /// Hyperparameter search ranges
130    pub hyperparameter_ranges: HashMap<String, ParameterRange>,
131
132    /// Component complexity score
133    pub complexity_score: f64,
134
135    /// Memory requirement estimate
136    pub memory_requirement: usize,
137
138    /// Computational cost estimate
139    pub computational_cost: f64,
140
141    /// Compatibility constraints
142    pub compatibility_constraints: Vec<CompatibilityConstraint>,
143}
144
145/// Architecture constraints for components
146#[derive(Debug, Clone, Default)]
147pub struct ArchitectureConstraints {
148    /// Minimum parameter count
149    pub min_parameters: Option<usize>,
150    /// Maximum parameter count
151    pub max_parameters: Option<usize>,
152    /// Required input dimensions
153    pub input_dimensions: Vec<usize>,
154    /// Output dimension constraints
155    pub output_dimensions: Vec<usize>,
156    /// Compatibility rules
157    pub compatibility_rules: Vec<String>,
158}
159
160/// Component type configuration
161#[derive(Debug, Clone)]
162pub struct ComponentTypeConfig {
163    /// Component type name
164    pub name: String,
165    /// Available parameters
166    pub parameters: Vec<String>,
167    /// Default configuration
168    pub defaults: HashMap<String, String>,
169    /// Whether this component type is enabled
170    pub enabled: bool,
171    /// Probability of selection during search
172    pub probability: f64,
173    /// Hyperparameter ranges for this component
174    pub hyperparameter_ranges: HashMap<String, ParameterRange>,
175    /// Dependencies on other components
176    pub dependencies: Vec<String>,
177    /// Component type
178    pub component_type: ComponentType,
179    /// Architecture constraints
180    pub constraints: ArchitectureConstraints,
181}
182
183/// Component types for optimizers
184#[derive(Debug, Clone, PartialEq, Eq, Hash)]
185pub enum ComponentType {
186    /// Gradient computation methods
187    GradientComputation,
188
189    /// Momentum techniques
190    Momentum,
191
192    /// Adaptive learning rate methods
193    AdaptiveLearningRate,
194
195    /// Regularization techniques
196    Regularization,
197
198    /// Normalization methods
199    Normalization,
200
201    /// Second-order methods
202    SecondOrder,
203
204    /// Preconditioning techniques
205    Preconditioning,
206
207    /// Learning rate scheduling
208    LearningRateScheduling,
209
210    /// Gradient clipping methods
211    GradientClipping,
212
213    /// Memory management
214    MemoryManagement,
215
216    /// Convergence acceleration
217    ConvergenceAcceleration,
218
219    /// Specific optimizer types
220    SGD,
221    Adam,
222    AdamW,
223    RMSprop,
224    AdaGrad,
225    AdaDelta,
226    Nesterov,
227    LRScheduler,
228    BatchNorm,
229    Dropout,
230    LAMB,
231    LARS,
232    Lion,
233    RAdam,
234    Lookahead,
235    SAM,
236    LBFGS,
237    SparseAdam,
238    GroupedAdam,
239    MAML,
240    Reptile,
241    MetaSGD,
242    ConstantLR,
243    ExponentialLR,
244    StepLR,
245    CosineAnnealingLR,
246    OneCycleLR,
247    CyclicLR,
248    L1Regularizer,
249    L2Regularizer,
250    ElasticNetRegularizer,
251    DropoutRegularizer,
252    WeightDecay,
253    AdaptiveLR,
254    AdaptiveMomentum,
255    AdaptiveRegularization,
256    LSTMOptimizer,
257    TransformerOptimizer,
258    AttentionOptimizer,
259
260    /// Custom components
261    Custom(String),
262}
263
264/// Parameter range for hyperparameter search
265#[derive(Debug, Clone)]
266pub enum ParameterRange {
267    /// Continuous range [min, max]
268    Continuous(f64, f64),
269
270    /// Discrete set of values
271    Discrete(Vec<f64>),
272
273    /// Integer range [min, max]
274    Integer(i32, i32),
275
276    /// Boolean choice
277    Boolean,
278
279    /// Categorical choice
280    Categorical(Vec<String>),
281
282    /// Log-uniform distribution
283    LogUniform(f64, f64),
284}
285
286/// Connection pattern types
287#[derive(Debug, Clone)]
288pub enum ConnectionPatternType {
289    /// Sequential connection
290    Sequential,
291
292    /// Parallel branches
293    Parallel,
294
295    /// Skip connections
296    SkipConnection,
297
298    /// Dense connections
299    DenseConnection,
300
301    /// Residual connections
302    ResidualConnection,
303
304    /// Attention-based connections
305    AttentionConnection,
306
307    /// Highway connections
308    HighwayConnection,
309
310    /// Squeeze-and-excitation connections
311    SqueezeExcitationConnection,
312
313    /// Custom connection patterns
314    Custom(String),
315}
316
317/// Learning rate schedule search space
318#[derive(Debug, Clone)]
319pub struct LearningRateScheduleSpace {
320    /// Available schedule types
321    pub schedule_types: Vec<ScheduleType>,
322
323    /// Initial learning rate range
324    pub initial_lr_range: ParameterRange,
325
326    /// Schedule-specific parameters
327    pub schedule_parameters: HashMap<ScheduleType, HashMap<String, ParameterRange>>,
328}
329
330/// Schedule types for learning rate
331#[derive(Debug, Clone, PartialEq, Eq, Hash)]
332pub enum ScheduleType {
333    Constant,
334    StepDecay,
335    ExponentialDecay,
336    CosineAnnealing,
337    CyclicalLR,
338    OneCycleLR,
339    ReduceOnPlateau,
340    WarmupLinear,
341    WarmupCosine,
342    Custom(String),
343}
344
345/// Regularization search space
346#[derive(Debug, Clone)]
347pub struct RegularizationSpace {
348    /// Available regularization techniques
349    pub techniques: Vec<RegularizationTechnique>,
350
351    /// Regularization strength ranges
352    pub strength_ranges: HashMap<RegularizationTechnique, ParameterRange>,
353
354    /// Combination strategies
355    pub combination_strategies: Vec<String>,
356}
357
358/// Regularization techniques
359#[derive(Debug, Clone, PartialEq, Eq, Hash)]
360pub enum RegularizationTechnique {
361    L1,
362    L2,
363    Dropout,
364    DropConnect,
365    BatchNormalization,
366    LayerNormalization,
367    GroupNormalization,
368    SpectralNormalization,
369    WeightDecay,
370    EarlyStopping,
371    Custom(String),
372}
373
374/// Adaptive mechanism search space
375#[derive(Debug, Clone)]
376pub struct AdaptiveMechanismSpace {
377    /// Available adaptation strategies
378    pub adaptation_strategies: Vec<AdaptationStrategy>,
379
380    /// Adaptation parameters
381    pub adaptation_parameters: HashMap<AdaptationStrategy, HashMap<String, ParameterRange>>,
382
383    /// Adaptation frequency options
384    pub adaptation_frequencies: Vec<usize>,
385}
386
387/// Adaptation strategies
388#[derive(Debug, Clone, PartialEq, Eq, Hash)]
389pub enum AdaptationStrategy {
390    PerformanceBased,
391    GradientBased,
392    LossBased,
393    TimeBased,
394    HybridAdaptation,
395    Custom(String),
396}
397
398/// Memory constraints for architecture search
399#[derive(Debug, Clone)]
400pub struct MemoryConstraints {
401    /// Maximum memory usage (bytes)
402    pub max_memory_bytes: usize,
403
404    /// Memory usage per component limits
405    pub component_memory_limits: HashMap<ComponentType, usize>,
406
407    /// Enable memory optimization
408    pub enable_memory_optimization: bool,
409
410    /// Memory allocation strategy
411    pub allocation_strategy: MemoryAllocationStrategy,
412}
413
414/// Memory allocation strategies
415#[derive(Debug, Clone)]
416pub enum MemoryAllocationStrategy {
417    Static,
418    Dynamic,
419    Adaptive,
420    Lazy,
421}
422
423/// Computation constraints
424#[derive(Debug, Clone)]
425pub struct ComputationConstraints {
426    /// Maximum computational cost
427    pub max_computational_cost: f64,
428
429    /// Cost per component limits
430    pub component_cost_limits: HashMap<ComponentType, f64>,
431
432    /// Enable computation optimization
433    pub enable_computation_optimization: bool,
434
435    /// Parallelization constraints
436    pub parallelization_constraints: ParallelizationConstraints,
437}
438
439/// Parallelization constraints
440#[derive(Debug, Clone)]
441pub struct ParallelizationConstraints {
442    /// Maximum parallel workers
443    pub max_workers: usize,
444
445    /// Minimum batch size for parallelization
446    pub min_batch_size: usize,
447
448    /// Enable SIMD optimization
449    pub enable_simd: bool,
450
451    /// Enable GPU acceleration
452    pub enable_gpu: bool,
453}
454
455/// Compatibility constraint between components
456#[derive(Debug, Clone)]
457pub struct CompatibilityConstraint {
458    /// Constraint type
459    pub constraint_type: CompatibilityType,
460
461    /// Target components
462    pub target_components: Vec<ComponentType>,
463
464    /// Constraint condition
465    pub condition: ConstraintCondition,
466}
467
468/// Compatibility constraint types
469#[derive(Debug, Clone)]
470pub enum CompatibilityType {
471    /// Components must be used together
472    Requires,
473
474    /// Components cannot be used together
475    Excludes,
476
477    /// Components have conditional compatibility
478    Conditional,
479
480    /// Components have version requirements
481    VersionRequirement,
482
483    /// Components have parameter constraints
484    ParameterConstraint,
485
486    /// Custom compatibility rules
487    Custom(String),
488}
489
490/// Constraint conditions
491#[derive(Debug, Clone)]
492pub enum ConstraintCondition {
493    /// Always applies
494    Always,
495
496    /// Never applies
497    Never,
498
499    /// Applies under certain parameter conditions
500    ParameterCondition(ParameterCondition),
501
502    /// Applies based on architecture properties
503    ArchitectureCondition(String),
504
505    /// Custom condition logic
506    Custom(String),
507}
508
509/// Parameter-based constraint conditions
510#[derive(Debug, Clone)]
511pub enum ParameterCondition {
512    /// Parameter equals specific value
513    Equals(String, f64),
514
515    /// Parameter is greater than value
516    GreaterThan(String, f64),
517
518    /// Parameter is less than value
519    LessThan(String, f64),
520
521    /// Parameter is within range
522    InRange(String, f64, f64),
523
524    /// Parameter is in set of values
525    InSet(String, Vec<f64>),
526
527    /// Complex boolean conditions
528    BooleanExpression(String),
529}
530
531/// Performance evaluation configuration
532#[derive(Debug, Clone)]
533pub struct EvaluationConfig<T: Float + Debug + Send + Sync + 'static> {
534    /// Evaluation metrics to use
535    pub metrics: Vec<EvaluationMetric>,
536
537    /// Benchmark datasets
538    pub benchmark_datasets: Vec<BenchmarkDataset>,
539
540    /// Evaluation budget (time/iterations)
541    pub evaluation_budget: EvaluationBudget,
542
543    /// Statistical testing configuration
544    pub statistical_testing: StatisticalTestingConfig,
545
546    /// Cross-validation settings
547    pub cross_validation_folds: usize,
548
549    /// Enable early stopping during evaluation
550    pub enable_early_stopping: bool,
551
552    /// Evaluation parallelization
553    pub parallelization_factor: usize,
554
555    /// Problem domain specification
556    pub problem_domains: Vec<ProblemDomain>,
557
558    /// Resource limits for evaluation
559    pub resource_limits: HashMap<ResourceType, T>,
560}
561
562/// Problem domains for evaluation
563#[derive(Debug, Clone)]
564pub enum ProblemDomain {
565    Classification,
566    Regression,
567    Reinforcement,
568    GenerativeModeling,
569    SequenceModeling,
570    ComputerVision,
571    NaturalLanguageProcessing,
572    TimeSeriesForecasting,
573    Custom(String),
574}
575
576/// Resource types for evaluation limits
577#[derive(Debug, Clone, PartialEq, Eq, Hash)]
578pub enum ResourceType {
579    Memory,
580    CPUTime,
581    GPUTime,
582    NetworkBandwidth,
583    StorageSpace,
584}
585
586/// Benchmark dataset configuration
587#[derive(Debug, Clone)]
588pub struct BenchmarkDataset {
589    /// Dataset name
590    pub name: String,
591
592    /// Dataset path or URL
593    pub path: String,
594
595    /// Dataset characteristics
596    pub characteristics: DatasetCharacteristics,
597
598    /// Problem type
599    pub problem_type: ProblemType,
600
601    /// Evaluation weight
602    pub weight: f64,
603
604    /// Enable data augmentation
605    pub enable_augmentation: bool,
606}
607
608/// Dataset characteristics
609#[derive(Debug, Clone)]
610pub struct DatasetCharacteristics {
611    /// Number of samples
612    pub num_samples: usize,
613
614    /// Number of features
615    pub num_features: usize,
616
617    /// Number of classes (for classification)
618    pub num_classes: Option<usize>,
619
620    /// Dataset size category
621    pub size_category: DatasetSizeCategory,
622
623    /// Feature correlation structure
624    pub correlation_structure: CorrelationStructure,
625
626    /// Noise level estimate
627    pub noise_level: f64,
628
629    /// Imbalance ratio (for classification)
630    pub imbalance_ratio: Option<f64>,
631}
632
633/// Problem types for evaluation
634#[derive(Debug, Clone)]
635pub enum ProblemType {
636    BinaryClassification,
637    MultiClassClassification,
638    Regression,
639    MultiTaskLearning,
640    MetaLearning,
641    TransferLearning,
642    FewShotLearning,
643    Custom(String),
644}
645
646/// Dataset size categories
647#[derive(Debug, Clone)]
648pub enum DatasetSizeCategory {
649    Small,     // < 1K samples
650    Medium,    // 1K - 100K samples
651    Large,     // 100K - 1M samples
652    VeryLarge, // > 1M samples
653}
654
655/// Correlation structure in datasets
656#[derive(Debug, Clone)]
657pub enum CorrelationStructure {
658    Independent,
659    LowCorrelation,
660    ModerateCorrelation,
661    HighCorrelation,
662    BlockStructure,
663    Hierarchical,
664}
665
666/// Evaluation budget configuration
667#[derive(Debug, Clone)]
668pub struct EvaluationBudget {
669    /// Maximum evaluation time per architecture
670    pub max_time_per_architecture: Duration,
671
672    /// Maximum number of training epochs
673    pub max_epochs: usize,
674
675    /// Maximum number of function evaluations
676    pub max_function_evaluations: usize,
677
678    /// Early stopping patience
679    pub early_stopping_patience: usize,
680
681    /// Resource allocation per evaluation
682    pub resource_allocation: ResourceAllocation,
683}
684
685/// Resource allocation for evaluations
686#[derive(Debug, Clone)]
687pub struct ResourceAllocation {
688    /// CPU cores allocated
689    pub cpu_cores: usize,
690
691    /// Memory allocated (GB)
692    pub memory_gb: f64,
693
694    /// GPU devices allocated
695    pub gpu_devices: usize,
696
697    /// Storage space allocated (GB)
698    pub storage_gb: f64,
699}
700
701/// Statistical testing configuration
702#[derive(Debug, Clone)]
703pub struct StatisticalTestingConfig {
704    /// Significance level (alpha)
705    pub significance_level: f64,
706
707    /// Statistical test type
708    pub test_type: StatisticalTestType,
709
710    /// Multiple comparison correction
711    pub multiple_comparison_correction: MultipleComparisonCorrection,
712
713    /// Minimum effect size
714    pub min_effect_size: f64,
715
716    /// Bootstrap samples for confidence intervals
717    pub bootstrap_samples: usize,
718}
719
720/// Statistical test types
721#[derive(Debug, Clone)]
722pub enum StatisticalTestType {
723    TTest,
724    WilcoxonRankSum,
725    KruskalWallis,
726    FriedmanTest,
727    Bootstrap,
728}
729
730/// Multiple comparison correction methods
731#[derive(Debug, Clone)]
732pub enum MultipleComparisonCorrection {
733    None,
734    Bonferroni,
735    BenjaminiHochberg,
736    BenjaminiYekutieli,
737    Holm,
738}
739
740/// Multi-objective optimization configuration
741#[derive(Debug, Clone)]
742pub struct MultiObjectiveConfig<T: Float + Debug + Send + Sync + 'static> {
743    /// List of objectives to optimize
744    pub objectives: Vec<ObjectiveConfig<T>>,
745
746    /// Multi-objective algorithm to use
747    pub algorithm: MultiObjectiveAlgorithm,
748
749    /// User preferences for trade-offs.
750    ///
751    /// **Not yet consulted by any optimizer.** Interactive / a-priori preference
752    /// articulation is not implemented: `NSGA2`, `NSGA3`, `MOEADOptimizer` and
753    /// `WeightedSum` all ignore this field. Per-objective trade-offs that *are*
754    /// honoured must be expressed through [`ObjectiveConfig::weight`] and
755    /// [`ObjectiveConfig::direction`], which the weighted-sum scalarizer and the
756    /// dominance comparisons do read.
757    pub user_preferences: Option<UserPreferences<T>>,
758
759    /// Diversity promotion strategy
760    pub diversity_strategy: DiversityStrategy,
761
762    /// Constraint handling method.
763    ///
764    /// **Not yet consulted by any optimizer.** Constrained multi-objective search
765    /// (penalty functions, feasibility rules, epsilon-constraint) is not
766    /// implemented; every optimizer in [`crate::multi_objective`] treats all
767    /// candidates as feasible and leaves `ParetoSolution::constraint_violations`
768    /// empty. Hard resource limits are enforced separately, by
769    /// [`crate::nas_engine::resources::ResourceMonitor`].
770    pub constraint_handling: ConstraintHandlingMethod,
771}
772
773/// Objective configuration
774#[derive(Debug, Clone)]
775pub struct ObjectiveConfig<T: Float + Debug + Send + Sync + 'static> {
776    /// Objective name
777    pub name: String,
778
779    /// Objective type
780    pub objective_type: ObjectiveType,
781
782    /// Optimization direction
783    pub direction: OptimizationDirection,
784
785    /// Objective weight
786    pub weight: T,
787
788    /// Objective priority
789    pub priority: ObjectivePriority,
790
791    /// Normalization bounds
792    pub normalization_bounds: Option<(T, T)>,
793}
794
795/// Objective types
796#[derive(Debug, Clone)]
797pub enum ObjectiveType {
798    Accuracy,
799    Loss,
800    TrainingTime,
801    InferenceTime,
802    MemoryUsage,
803    EnergyConsumption,
804    ModelSize,
805    Robustness,
806    Fairness,
807    Performance,
808    Efficiency,
809    Interpretability,
810    Privacy,
811    Sustainability,
812    Cost,
813    Custom(String),
814}
815
816/// Optimization directions
817#[derive(Debug, Clone)]
818pub enum OptimizationDirection {
819    Minimize,
820    Maximize,
821}
822
823/// Objective priorities
824#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
825pub enum ObjectivePriority {
826    Low,
827    Medium,
828    High,
829    Critical,
830}
831
832/// Multi-objective algorithms
833#[derive(Debug, Clone)]
834pub enum MultiObjectiveAlgorithm {
835    NSGA2,
836    NSGA3,
837    MOEAD,
838    SPEA2,
839    PAES,
840    WeightedSum,
841    EpsilonConstraint,
842    GoalProgramming,
843    Custom(String),
844}
845
846/// User preferences for multi-objective optimization
847#[derive(Debug, Clone)]
848pub struct UserPreferences<T: Float + Debug + Send + Sync + 'static> {
849    /// Preference type
850    pub preference_type: PreferenceType<T>,
851
852    /// Reference point (for reference point methods)
853    pub reference_point: Option<Vec<T>>,
854
855    /// Aspiration levels
856    pub aspiration_levels: Option<Vec<T>>,
857
858    /// Reservation levels
859    pub reservation_levels: Option<Vec<T>>,
860}
861
862/// Preference specification types
863#[derive(Debug, Clone)]
864pub enum PreferenceType<T: Float + Debug + Send + Sync + 'static> {
865    WeightVector(Vec<T>),
866    ReferencePoint(Vec<T>),
867    GoalVector(Vec<T>),
868    RankingOrder(Vec<usize>),
869    PairwiseComparison(Vec<(usize, usize)>),
870}
871
872/// Diversity promotion strategies
873#[derive(Debug, Clone)]
874pub enum DiversityStrategy {
875    Crowding,
876    Sharing,
877    Clearing,
878    Clustering,
879    Novelty,
880    Custom(String),
881}
882
883/// Constraint handling methods
884#[derive(Debug, Clone)]
885pub enum ConstraintHandlingMethod {
886    PenaltyFunction,
887    DeathPenalty,
888    Repair,
889    Decoder,
890    PreserveFeasibility,
891    Custom(String),
892}
893
894/// Early stopping configuration
895#[derive(Debug, Clone)]
896pub struct EarlyStoppingConfig<T: Float + Debug + Send + Sync + 'static> {
897    /// Enable early stopping
898    pub enabled: bool,
899
900    /// Patience (number of generations without improvement)
901    pub patience: usize,
902
903    /// Minimum improvement threshold
904    pub min_improvement: T,
905
906    /// Convergence detection strategy
907    pub convergence_strategy: ConvergenceDetectionStrategy,
908
909    /// Minimum number of generations before stopping
910    pub min_generations: usize,
911
912    /// Metric to monitor for early stopping
913    pub metric: EvaluationMetric,
914
915    /// Target performance value
916    pub target_performance: Option<T>,
917
918    /// Convergence detection strategy
919    pub convergence_detection: ConvergenceDetectionStrategy,
920}
921
922/// Convergence detection strategies
923#[derive(Debug, Clone)]
924pub enum ConvergenceDetectionStrategy {
925    BestScore,
926    AverageScore,
927    PopulationDiversity,
928    ParetoFrontStability,
929    NoImprovement,
930    Custom(String),
931}
932
933/// Architecture encoding strategies
934#[derive(Debug, Clone)]
935pub enum ArchitectureEncodingStrategy {
936    /// Direct parameter encoding
937    Direct,
938
939    /// Graph-based encoding
940    Graph,
941
942    /// String-based encoding
943    String,
944
945    /// Binary encoding
946    Binary,
947
948    /// Real-valued encoding
949    RealValued,
950
951    /// Hierarchical encoding
952    Hierarchical,
953
954    /// Neural encoding (using neural networks)
955    Neural,
956
957    /// Hybrid encoding strategies
958    Hybrid,
959
960    /// Custom encoding
961    Custom(String),
962}
963
964/// Resource constraints for NAS
965#[derive(Debug, Clone)]
966pub struct ResourceConstraints<T: Float + Debug + Send + Sync + 'static> {
967    /// Hardware resource limits
968    pub hardware_resources: HardwareResources,
969
970    /// Time constraints
971    pub time_constraints: TimeConstraints,
972
973    /// Energy constraints
974    pub energy_constraints: Option<T>,
975
976    /// Cost constraints
977    pub cost_constraints: Option<T>,
978
979    /// Resource violation handling
980    pub violation_handling: ResourceViolationHandling,
981
982    /// Maximum memory in GB
983    pub max_memory_gb: T,
984
985    /// Maximum computation hours
986    pub max_computation_hours: T,
987
988    /// Maximum energy in kWh
989    pub max_energy_kwh: T,
990
991    /// Maximum cost in USD
992    pub max_cost_usd: T,
993
994    /// Enable resource monitoring
995    pub enable_monitoring: bool,
996}
997
998/// Hardware resource specifications
999#[derive(Debug, Clone)]
1000pub struct HardwareResources {
1001    /// Maximum memory usage (GB)
1002    pub max_memory_gb: f64,
1003
1004    /// Maximum CPU cores
1005    pub max_cpu_cores: usize,
1006
1007    /// Maximum GPU devices
1008    pub max_gpu_devices: usize,
1009
1010    /// Maximum storage space (GB)
1011    pub max_storage_gb: f64,
1012
1013    /// Network bandwidth limits (MB/s)
1014    pub max_network_bandwidth: f64,
1015
1016    /// Enable cloud resource scaling
1017    pub enable_cloud_scaling: bool,
1018
1019    /// Cloud resource budget
1020    pub cloud_budget: Option<f64>,
1021
1022    /// CPU cores available
1023    pub cpu_cores: usize,
1024
1025    /// RAM in GB
1026    pub ram_gb: u32,
1027
1028    /// Number of GPUs
1029    pub num_gpus: usize,
1030
1031    /// GPU memory in GB
1032    pub gpu_memory_gb: u32,
1033
1034    /// Storage in GB
1035    pub storage_gb: u32,
1036
1037    /// Network bandwidth in Mbps
1038    pub network_bandwidth_mbps: f32,
1039}
1040
1041/// Time constraints for search
1042#[derive(Debug, Clone)]
1043pub struct TimeConstraints {
1044    /// Maximum total search time
1045    pub max_search_time: Duration,
1046
1047    /// Maximum time per architecture evaluation
1048    pub max_evaluation_time: Duration,
1049
1050    /// Search deadline
1051    pub search_deadline: Option<std::time::Instant>,
1052
1053    /// Time budget allocation strategy
1054    pub budget_allocation: TimeBudgetAllocation,
1055}
1056
1057/// Time budget allocation strategies
1058#[derive(Debug, Clone)]
1059pub enum TimeBudgetAllocation {
1060    Uniform,
1061    AdaptiveByComplexity,
1062    AdaptiveByPerformance,
1063    PriorityBased,
1064    Custom(String),
1065}
1066
1067/// Resource violation handling strategies
1068#[derive(Debug, Clone)]
1069pub enum ResourceViolationHandling {
1070    /// Stop search immediately
1071    Abort,
1072
1073    /// Skip violating architectures
1074    Skip,
1075
1076    /// Scale down resources
1077    ScaleDown,
1078
1079    /// Use approximation methods
1080    Approximate,
1081
1082    /// Dynamic resource allocation
1083    Dynamic,
1084
1085    /// Apply penalty to objective function
1086    Penalty,
1087
1088    /// Custom handling
1089    Custom(String),
1090}
1091
1092// Default implementations
1093impl<T: Float + Debug + Send + Sync + 'static> Default for NASConfig<T> {
1094    fn default() -> Self {
1095        Self {
1096            search_strategy: SearchStrategyType::Evolutionary,
1097            search_space: SearchSpaceConfig::default(),
1098            evaluation_config: EvaluationConfig::default(),
1099            multi_objective_config: MultiObjectiveConfig::default(),
1100            search_budget: 100,
1101            early_stopping: EarlyStoppingConfig::default(),
1102            progressive_search: false,
1103            population_size: 20,
1104            enable_transfer_learning: false,
1105            encoding_strategy: ArchitectureEncodingStrategy::Graph,
1106            enable_performance_prediction: false,
1107            parallelization_factor: 1,
1108            auto_hyperparameter_tuning: false,
1109            resource_constraints: ResourceConstraints::default(),
1110        }
1111    }
1112}
1113
1114impl Default for SearchSpaceConfig {
1115    fn default() -> Self {
1116        Self {
1117            components: Vec::new(),
1118            connection_patterns: vec![
1119                ConnectionPatternType::Sequential,
1120                ConnectionPatternType::Parallel,
1121                ConnectionPatternType::SkipConnection,
1122            ],
1123            learning_rate_schedules: LearningRateScheduleSpace::default(),
1124            regularization_techniques: RegularizationSpace::default(),
1125            adaptive_mechanisms: AdaptiveMechanismSpace::default(),
1126            memory_constraints: MemoryConstraints::default(),
1127            computation_constraints: ComputationConstraints::default(),
1128            component_types: vec![ComponentType::SGD, ComponentType::Adam],
1129            max_components: 10,
1130            min_components: 1,
1131            max_connections: 20,
1132        }
1133    }
1134}
1135
1136impl Default for LearningRateScheduleSpace {
1137    fn default() -> Self {
1138        Self {
1139            schedule_types: vec![
1140                ScheduleType::Constant,
1141                ScheduleType::StepDecay,
1142                ScheduleType::ExponentialDecay,
1143                ScheduleType::CosineAnnealing,
1144            ],
1145            initial_lr_range: ParameterRange::LogUniform(1e-5, 1e-1),
1146            schedule_parameters: HashMap::new(),
1147        }
1148    }
1149}
1150
1151impl Default for RegularizationSpace {
1152    fn default() -> Self {
1153        Self {
1154            techniques: vec![
1155                RegularizationTechnique::L1,
1156                RegularizationTechnique::L2,
1157                RegularizationTechnique::Dropout,
1158                RegularizationTechnique::WeightDecay,
1159            ],
1160            strength_ranges: HashMap::new(),
1161            combination_strategies: Vec::new(),
1162        }
1163    }
1164}
1165
1166impl Default for AdaptiveMechanismSpace {
1167    fn default() -> Self {
1168        Self {
1169            adaptation_strategies: vec![
1170                AdaptationStrategy::PerformanceBased,
1171                AdaptationStrategy::GradientBased,
1172                AdaptationStrategy::LossBased,
1173            ],
1174            adaptation_parameters: HashMap::new(),
1175            adaptation_frequencies: vec![1, 5, 10, 25, 50, 100],
1176        }
1177    }
1178}
1179
1180impl Default for MemoryConstraints {
1181    fn default() -> Self {
1182        Self {
1183            max_memory_bytes: 32 * 1024 * 1024 * 1024, // 32GB
1184            component_memory_limits: HashMap::new(),
1185            enable_memory_optimization: true,
1186            allocation_strategy: MemoryAllocationStrategy::Dynamic,
1187        }
1188    }
1189}
1190
1191impl Default for ComputationConstraints {
1192    fn default() -> Self {
1193        Self {
1194            max_computational_cost: 1000.0,
1195            component_cost_limits: HashMap::new(),
1196            enable_computation_optimization: true,
1197            parallelization_constraints: ParallelizationConstraints::default(),
1198        }
1199    }
1200}
1201
1202impl Default for ParallelizationConstraints {
1203    fn default() -> Self {
1204        Self {
1205            max_workers: num_cpus::get(),
1206            min_batch_size: 32,
1207            enable_simd: true,
1208            enable_gpu: true,
1209        }
1210    }
1211}
1212
1213impl<T: Float + Debug + Send + Sync + 'static> Default for EvaluationConfig<T> {
1214    fn default() -> Self {
1215        Self {
1216            metrics: vec![EvaluationMetric::Accuracy, EvaluationMetric::TrainingTime],
1217            benchmark_datasets: Vec::new(),
1218            evaluation_budget: EvaluationBudget::default(),
1219            statistical_testing: StatisticalTestingConfig::default(),
1220            cross_validation_folds: 5,
1221            enable_early_stopping: true,
1222            parallelization_factor: 1,
1223            problem_domains: vec![ProblemDomain::Classification],
1224            resource_limits: HashMap::new(),
1225        }
1226    }
1227}
1228
1229impl Default for EvaluationBudget {
1230    fn default() -> Self {
1231        Self {
1232            max_time_per_architecture: Duration::from_secs(300),
1233            max_epochs: 100,
1234            max_function_evaluations: 1000,
1235            early_stopping_patience: 10,
1236            resource_allocation: ResourceAllocation::default(),
1237        }
1238    }
1239}
1240
1241impl Default for ResourceAllocation {
1242    fn default() -> Self {
1243        Self {
1244            cpu_cores: 4,
1245            memory_gb: 8.0,
1246            gpu_devices: 1,
1247            storage_gb: 10.0,
1248        }
1249    }
1250}
1251
1252impl Default for StatisticalTestingConfig {
1253    fn default() -> Self {
1254        Self {
1255            significance_level: 0.05,
1256            test_type: StatisticalTestType::TTest,
1257            multiple_comparison_correction: MultipleComparisonCorrection::BenjaminiHochberg,
1258            min_effect_size: 0.1,
1259            bootstrap_samples: 1000,
1260        }
1261    }
1262}
1263
1264impl<T: Float + Debug + Send + Sync + 'static> Default for MultiObjectiveConfig<T> {
1265    fn default() -> Self {
1266        Self {
1267            objectives: Vec::new(),
1268            algorithm: MultiObjectiveAlgorithm::NSGA2,
1269            user_preferences: None,
1270            diversity_strategy: DiversityStrategy::Crowding,
1271            constraint_handling: ConstraintHandlingMethod::PenaltyFunction,
1272        }
1273    }
1274}
1275
1276impl<T: Float + Debug + Send + Sync + 'static> Default for EarlyStoppingConfig<T> {
1277    fn default() -> Self {
1278        Self {
1279            enabled: true,
1280            patience: 20,
1281            min_improvement: scirs2_core::numeric::NumCast::from(0.001)
1282                .unwrap_or_else(|| T::zero()),
1283            convergence_strategy: ConvergenceDetectionStrategy::BestScore,
1284            min_generations: 10,
1285            metric: EvaluationMetric::Accuracy,
1286            target_performance: None,
1287            convergence_detection: ConvergenceDetectionStrategy::NoImprovement,
1288        }
1289    }
1290}
1291
1292impl<T: Float + Debug + Send + Sync + 'static> Default for ResourceConstraints<T> {
1293    fn default() -> Self {
1294        Self {
1295            hardware_resources: HardwareResources::default(),
1296            time_constraints: TimeConstraints::default(),
1297            energy_constraints: None,
1298            cost_constraints: None,
1299            violation_handling: ResourceViolationHandling::Skip,
1300            max_memory_gb: scirs2_core::numeric::NumCast::from(32.0).unwrap_or_else(|| T::zero()),
1301            max_computation_hours: scirs2_core::numeric::NumCast::from(24.0)
1302                .unwrap_or_else(|| T::zero()),
1303            max_energy_kwh: scirs2_core::numeric::NumCast::from(100.0).unwrap_or_else(|| T::zero()),
1304            max_cost_usd: scirs2_core::numeric::NumCast::from(1000.0).unwrap_or_else(|| T::zero()),
1305            enable_monitoring: true,
1306        }
1307    }
1308}
1309
1310impl Default for HardwareResources {
1311    fn default() -> Self {
1312        Self {
1313            max_memory_gb: 32.0,
1314            max_cpu_cores: num_cpus::get(),
1315            max_gpu_devices: 4,
1316            max_storage_gb: 100.0,
1317            max_network_bandwidth: 1000.0, // 1 GB/s
1318            enable_cloud_scaling: false,
1319            cloud_budget: None,
1320            cpu_cores: num_cpus::get(),
1321            ram_gb: 32,
1322            num_gpus: 1,
1323            gpu_memory_gb: 8,
1324            storage_gb: 100,
1325            network_bandwidth_mbps: 1000.0,
1326        }
1327    }
1328}
1329
1330impl Default for TimeConstraints {
1331    fn default() -> Self {
1332        Self {
1333            max_search_time: Duration::from_secs(3600),    // 1 hour
1334            max_evaluation_time: Duration::from_secs(300), // 5 minutes
1335            search_deadline: None,
1336            budget_allocation: TimeBudgetAllocation::Uniform,
1337        }
1338    }
1339}
1340
1341#[cfg(test)]
1342mod tests {
1343    use super::*;
1344
1345    #[test]
1346    fn test_nas_config_default() {
1347        let config = NASConfig::<f32>::default();
1348        assert_eq!(config.search_budget, 100);
1349        assert_eq!(config.population_size, 20);
1350        assert!(!config.progressive_search);
1351    }
1352
1353    #[test]
1354    fn test_search_space_config_default() {
1355        let config = SearchSpaceConfig::default();
1356        assert!(!config.connection_patterns.is_empty());
1357        assert_eq!(config.connection_patterns.len(), 3);
1358    }
1359
1360    #[test]
1361    fn test_parameter_range_variants() {
1362        let continuous = ParameterRange::Continuous(0.0, 1.0);
1363        let discrete = ParameterRange::Discrete(vec![0.1, 0.5, 0.9]);
1364        let integer = ParameterRange::Integer(1, 10);
1365
1366        match continuous {
1367            ParameterRange::Continuous(min, max) => {
1368                assert_eq!(min, 0.0);
1369                assert_eq!(max, 1.0);
1370            }
1371            _ => panic!("Expected continuous range"),
1372        }
1373
1374        match discrete {
1375            ParameterRange::Discrete(values) => {
1376                assert_eq!(values.len(), 3);
1377            }
1378            _ => panic!("Expected discrete range"),
1379        }
1380
1381        match integer {
1382            ParameterRange::Integer(min, max) => {
1383                assert_eq!(min, 1);
1384                assert_eq!(max, 10);
1385            }
1386            _ => panic!("Expected integer range"),
1387        }
1388    }
1389}
optirs_nas/nas_engine/config.rs

optirs_nas/nas_engine/
config.rs
