sklears_compose/
lib.rs

1#![allow(dead_code)]
2#![allow(non_snake_case)]
3#![allow(missing_docs)]
4#![allow(deprecated)]
5#![allow(unused_imports)]
6#![allow(unused_variables)]
7#![allow(unused_mut)]
8#![allow(unused_assignments)]
9#![allow(unused_doc_comments)]
10#![allow(unused_parens)]
11#![allow(unused_comparisons)]
12#![allow(clippy::all)]
13#![allow(clippy::pedantic)]
14#![allow(clippy::nursery)]
15//! Composite estimators and transformers
16//!
17//! This module provides meta-estimators for composing other estimators.
18//! It includes tools for applying different transformers to different
19//! subsets of features and for transforming target variables.
20
21// #![warn(missing_docs)]
22
23// Re-export core modules
24pub mod advanced_debugging;
25pub mod advanced_pipeline;
26pub mod api_consistency;
27pub mod automated_alerting;
28pub mod automl;
29pub mod benchmarking;
30pub mod boosting;
31pub mod circuit_breaker;
32pub mod column_transformer;
33pub mod error;
34// pub mod composable_execution;  // Migrated to execution module
35pub mod config_management;
36pub mod configuration_validation;
37pub mod continual_learning;
38// TODO: Temporarily disabled until ndarray 0.17 HRTB trait bound issues are resolved
39// pub mod cross_validation;
40pub mod cv_pipelines;
41pub mod dag_pipeline;
42pub mod debugging;
43pub mod debugging_utilities;
44pub mod developer_experience;
45pub mod differentiable;
46pub mod distributed;
47pub mod distributed_tracing;
48pub mod enhanced_compile_time_validation;
49pub mod enhanced_error_messages;
50pub mod enhanced_errors;
51pub mod ensemble;
52pub mod execution;
53pub mod execution_config;
54pub mod execution_core;
55pub mod execution_hooks;
56pub mod execution_strategies;
57pub mod execution_types;
58pub mod external_integration;
59pub mod fault_core;
60pub mod feature_engineering;
61pub mod few_shot;
62pub mod fluent_api;
63pub mod memory_optimization;
64pub mod meta_learning;
65pub mod middleware;
66pub mod mock;
67pub mod modular_framework;
68pub mod monitoring;
69pub mod nlp_pipelines;
70pub mod optimization;
71pub mod parallel_execution;
72// pub mod pattern_optimization; // Temporarily disabled - needs rand_distr dependency and type fixes
73pub mod performance_optimization;
74pub mod performance_profiler;
75pub mod performance_testing;
76pub mod pipeline;
77pub mod pipeline_visualization;
78pub mod plugin_architecture;
79pub mod profile_guided_optimization;
80pub mod property_testing;
81pub mod quality_assurance;
82pub mod quantum;
83pub mod resource_management;
84// pub mod retry; // Temporarily disabled - needs missing type imports and context fixes
85pub mod enhanced_wasm_integration;
86pub mod scheduling;
87pub mod simd_optimizations;
88pub mod state_management;
89pub mod streaming;
90pub mod stress_testing;
91pub mod task_definitions;
92pub mod task_scheduling;
93pub mod time_series_pipelines;
94pub mod transfer_learning;
95pub mod type_safety;
96pub mod validation;
97pub mod wasm_integration;
98#[cfg(feature = "workflow")]
99pub mod workflow_language;
100pub mod zero_cost;
101
102// Re-export main types and traits
103pub use advanced_debugging::{
104    AdvancedPipelineDebugger, AdvancedProfiler, Breakpoint, BreakpointCondition, CallStackFrame,
105    CpuSample, DebugConfig, DebugEvent, DebugSession, DebugSessionHandle, DebugSessionState,
106    DebugStatistics, ExecutionStep, MemorySample, StepResult, VariableInspector, VariableValue,
107    WatchExpression, WatchResult,
108};
109pub use advanced_pipeline::{
110    BranchConfig, BranchingPipeline, BranchingPipelineBuilder, BranchingPipelineTrained,
111    ConditionalPipeline, ConditionalPipelineBuilder, ConditionalPipelineTrained, DataCondition,
112    FeatureCountCondition,
113};
114pub use api_consistency::{
115    ApiConsistencyChecker, ApiRecommendation, ConfigSummary, ConfigValue, ConsistencyIssue,
116    ConsistencyReport, ExecutionMetadata, FittedModelSummary, FittedTransformerSummary,
117    IssueCategory, IssueSeverity, MetadataProvider, ModelSummary, PipelineConsistencyReport,
118    RecommendationCategory, RecommendationPriority, StandardBuilder, StandardConfig,
119    StandardEstimator, StandardFittedEstimator, StandardFittedTransformer, StandardResult,
120    StandardTransformer,
121};
122pub use automated_alerting::{
123    ActiveAlert, AlertChannel, AlertCondition, AlertConfig, AlertEvent, AlertSeverity, AlertStatus,
124    AutomatedAlerter, ConsoleAlertChannel, EmailAlertChannel, EscalationLevel, LogicalOperator,
125    PatternField, SilencePeriod, SlackAlertChannel, ThresholdOperator, WebhookAlertChannel,
126};
127pub use automl::{
128    ActivationFunction, AlgorithmChoice, AlgorithmType, AutoMLConfig, AutoMLOptimizer, LayerType,
129    NASStrategy, NeuralArchitecture, NeuralArchitectureSearch, NeuralSearchSpace,
130    OptimizationHistory, OptimizationMetric, OptimizationReport, ParameterRange,
131    ParameterValue as AutoMLParameterValue, SearchSpace, SearchStrategy as AutoMLSearchStrategy,
132    TrialResult, TrialStatus,
133};
134pub use benchmarking::{
135    BenchmarkConfig, BenchmarkReport, BenchmarkResult, BenchmarkSuite, ComplexityClass,
136    MemoryUsage as BenchmarkMemoryUsage, ScalabilityMetrics, UseCase,
137};
138pub use boosting::{
139    AdaBoostAlgorithm, AdaBoostClassifier, AdaBoostTrained, GradientBoostingRegressor,
140    GradientBoostingTrained, LossFunction,
141};
142pub use circuit_breaker::{
143    AdvancedCircuitBreaker, AnalyticsInsight, AnalyticsProcessor, AnalyticsRecommendation,
144    AnalyticsResult, CircuitBreaker, CircuitBreakerAnalytics, CircuitBreakerBuilder,
145    CircuitBreakerError, CircuitBreakerEvent, CircuitBreakerEventRecorder, CircuitBreakerEventType,
146    CircuitBreakerFailureDetector, CircuitBreakerRecoveryManager, CircuitBreakerStatsAggregator,
147    CircuitBreakerStatsTracker, ConsoleEventPublisher, ErrorTracker, EventPublisher,
148    FileEventPublisher, HealthCheckResult, HealthMetrics, RecoveryContext, RecoveryResult,
149    RecoveryStrategy as CircuitBreakerRecoveryStrategy, RequestCounters, ResponseTimeTracker,
150    SlidingWindow, ValidationResult as CircuitBreakerValidationResult,
151};
152pub use column_transformer::{
153    ColumnTransformer, ColumnTransformerBuilder, ColumnTransformerOutput, ColumnTransformerTrained,
154};
155pub use config_management::{
156    ConfigManager, ConfigValue as ConfigManagementConfigValue, EnvironmentConfig, EstimatorConfig,
157    ExecutionConfig, PipelineConfig, ResourceConfig, StepConfig,
158    ValidationRule as ConfigValidationRule,
159};
160pub use configuration_validation::{
161    CompileTimeValidator, ConfigurationValidator, Constraint, CustomValidationRule,
162    DependencyConstraint, FieldConstraints, FieldType, PipelineConfigValidator, RuleType,
163    RuntimeValidator, ValidationBuilder, ValidationReport, ValidationResult, ValidationSchema,
164    ValidationSeverity, ValidationStatus, ValidationSummary,
165};
166pub use continual_learning::{
167    ContinualLearningPipeline, ContinualLearningPipelineTrained, ContinualLearningStrategy,
168    MemoryBuffer, MemorySample as ContinualMemorySample, SamplingStrategy, Task, TaskStatistics,
169};
170// TODO: Temporarily disabled until ndarray 0.17 HRTB trait bound issues are resolved
171// pub use cross_validation::{
172//     CVStrategy, CVSummary, ComposedModelCrossValidator, CrossValidationConfig,
173//     CrossValidationResults, FoldResult, NestedCVResults, OuterFoldResult, ScoringConfig,
174//     ScoringMetric as CVScoringMetric, TimeSeriesConfig,
175// };
176pub use cv_pipelines::{
177    AdaptationAlgorithm, AdaptationMetric, AdaptiveQualityConfig, BoundingBox,
178    BufferManagementConfig, CVConfig, CVMetrics, CVModel, CVPipeline, CVPipelineState,
179    CVPrediction, CacheEvictionPolicy, CachingStrategy, CameraInfo, CameraIntrinsics,
180    CameraSettings, ColorSpace, CompressionAlgorithm, CompressionConfig, ComputeDevice,
181    ConfidenceScores, ContrastiveLearningConfig, CrossModalLearningConfig, CrossModalStrategy,
182    DenoisingAlgorithm, Detection, DetectionMetadata, DistillationConfig, EncodingConfig,
183    ErrorResilienceConfig, ExifData, ExtractorConfig, ExtractorType, FeatureExtractor,
184    FeatureMetadata, FeatureQuality, FeatureStatistics, FeatureVector,
185    FusionStrategy as CVFusionStrategy, GPSInfo, ImageData, ImageDataType, ImageFormat,
186    ImageMetadata, ImageSpecification, ImageTransform, InterpolationMethod, LensInfo,
187    LoadBalancingAlgorithm, MemoryOptimizationLevel, Modality, ModelConfig, ModelMetadata,
188    ModelPerformance, ModelType, MultiModalConfig, NetworkOptimizationConfig, NoiseReductionConfig,
189    NormalizationSpec, ObjectDetectionResult, ParallelProcessingConfig,
190    ParallelStrategy as CVParallelStrategy, PerformanceConfig, PerformanceMetrics,
191    PostProcessor as CVPostProcessor, PredictionMetadata, PredictionResult, PredictionType,
192    ProcessedResult, ProcessingComplexity, ProcessingMode, ProcessingStatistics, ProcessorConfig,
193    ProcessorType, QualityEnhancementConfig, QualityLevel, QualityMetrics as CVQualityMetrics,
194    QualitySettings, RateControlMethod, RealTimeProcessingConfig,
195    RecoveryStrategy as CVRecoveryStrategy, ResourceUtilization, SharpeningConfig, StreamingConfig,
196    StreamingProtocol, SyncMethod, TemporalAlignmentConfig, TransformParameter, VideoCodec,
197};
198pub use dag_pipeline::{
199    BranchCondition, ComparisonOp, DAGNode, DAGPipeline, DAGPipelineTrained,
200    ExecutionRecord as DAGExecutionRecord, ExecutionStats, MergeStrategy, NodeComponent,
201    NodeConfig, NodeOutput,
202};
203pub use debugging::{
204    Bottleneck as DebuggingBottleneck, BottleneckDetector,
205    BottleneckSeverity as DebuggingBottleneckSeverity, BottleneckType,
206    Breakpoint as DebuggingBreakpoint, BreakpointCondition as DebuggingBreakpointCondition,
207    BreakpointFrequency, ComparisonOperator, DataSnapshot, DataSummary,
208    DebugConfig as DebuggingConfig, DebugLogLevel, DebugOutputFormat,
209    DebugSession as DebuggingSession, ErrorAnalysis, ErrorPattern, ErrorResolutionStatus,
210    ErrorStatistics, ErrorTracker as DebuggingErrorTracker, ExecutionState,
211    ExecutionStep as EnhancedExecutionStep, InteractiveDebugger, IoStatistics,
212    MemoryUsage as DebuggingMemoryUsage, PerformanceAnalysis as DebuggingPerformanceAnalysis,
213    PerformanceMeasurement, PerformanceMetric, PerformanceProfiler, PipelineDebugger, SessionState,
214    StatisticalSummary, StepError, TrackedError,
215};
216// Temporarily commented out to avoid import conflicts
217// pub use debugging_utilities::{
218//     BottleneckAnalysis, BreakpointCondition as UtilsBreakpointCondition, CacheStatistics,
219//     ContextValue, DataFlowAnalysis, DataInspector, DataLineageNode, DataMetadata,
220//     DataSnapshot as UtilsDataSnapshot, DataStatistics, DebugCommand, DebugReport,
221//     DebugSession as UtilsDebugSession, DebugState, DebuggingConfig, ErrorContext,
222//     ErrorContextManager, ErrorInfo, ErrorSuggestion, ExecutionContext as UtilsExecutionContext,
223//     ExecutionState as UtilsExecutionState, ExecutionStatistics,
224//     ExecutionStep as UtilsExecutionStep, ExecutionTracer, ExportFormat, InspectionConfig,
225//     InteractiveConfig, InteractiveDebugger as UtilsInteractiveDebugger, MeasurementSession,
226//     PerformanceMetrics as UtilsPerformanceMetrics, PerformanceProfiler as UtilsPerformanceProfiler,
227//     PipelineDebugger as UtilsPipelineDebugger, ProfilingConfig, QualityMetric, StepStatus,
228//     StepType as UtilsStepType, TracingConfig, TransformationGraph, TransformationNode,
229//     TransformationSummary, WatchExpression as UtilsWatchExpression,
230// };
231pub use developer_experience::{
232    Breakpoint as DeveloperBreakpoint, CodeExample, DebugState, DebugSummary,
233    DeveloperFriendlyError, ErrorMessageEnhancer, ExecutionContext, FixSuggestion,
234    PipelineDebugger as DeveloperPipelineDebugger, StepType, SuggestionPriority, TraceEntry,
235    WatchExpression as DeveloperWatchExpression,
236};
237pub use differentiable::{
238    ActivationFunction as DiffActivationFunction, AutoDiffConfig, AutoDiffEngine, ComputationGraph,
239    ComputationNode, DifferentiableOperation, DifferentiablePipeline, DifferentiableStage,
240    DifferentiationMode, DualNumber, GradientAccumulation, GradientContext, GradientRecord,
241    LearningRateSchedule as DiffLearningRateSchedule, NeuralPipelineController,
242    OptimizationConfig as DiffOptimizationConfig, OptimizerState,
243    OptimizerType as DiffOptimizerType, Parameter as DiffParameter,
244    ParameterConfig as DiffParameterConfig, PipelineComponent, TrainingMetrics, TrainingState,
245};
246pub use distributed::TaskPriority as DistributedTaskPriority;
247pub use distributed::{
248    ClusterManager, ClusterNode, DataShard, DistributedTask, FaultDetector, LoadBalancer,
249    MapReducePipeline, NodeStatus, ResourceRequirements, TaskResult as DistributedTaskResult,
250    TaskStatus as DistributedTaskStatus,
251};
252pub use distributed_tracing::{
253    Bottleneck, BottleneckSeverity as TracingBottleneckSeverity, ConsoleTraceExporter,
254    DistributedTracer, JsonFileTraceExporter, LogEntry, LogLevel as TracingLogLevel,
255    ServiceAnalysis, ServiceInfo, SpanStatus, Trace, TraceAnalysis, TraceExporter, TraceHandle,
256    TraceSpan, TraceStatistics, TracingConfig,
257};
258pub use enhanced_compile_time_validation::{
259    BuilderConfig, CompileTimeValidator as EnhancedCompileTimeValidator, ConfigType,
260    ConfigValue as EnhancedConfigValue, ConfigurationLocation, ConstraintValidator,
261    CrossReferenceRule, CrossReferenceValidator, CustomValidator, DependencyValidator,
262    FieldDefinition, ParameterConstraintValidator, PipelineConfigurationSchema,
263    PipelineSchemaValidator, ReferenceType, SchemaConstraint, SchemaConstraintType,
264    SchemaValidator, SuggestionAction, SuggestionPriority as ValidationSuggestionPriority,
265    TypeConstraint, TypeSafeConfigBuilder, Unbuilt, Unvalidated, Validated,
266    ValidatedPipelineConfig, ValidationConfig, ValidationError, ValidationErrorCategory,
267    ValidationMetrics, ValidationProof, ValidationResult as EnhancedValidationResult,
268    ValidationRule, ValidationSeverity as EnhancedValidationSeverity,
269    ValidationStatus as EnhancedValidationStatus, ValidationSuggestion, ValidationWarning,
270    ValueConstraint, WarningCategory,
271};
272pub use enhanced_error_messages::{
273    ActionableSuggestion, AutoRecoveryHandler, CodeExample as EnhancedCodeExample,
274    ConfigurationContext, ContextProvider, ContextType, DataContext, DataQualityMetrics,
275    DataStatistics, DifficultyLevel, DocumentationLink, EnhancedErrorContext, EnhancedErrorMessage,
276    EnvironmentContext, ErrorCategory, ErrorClassification, ErrorContextCollector,
277    ErrorEnhancementConfig, ErrorEnhancementStatistics, ErrorFormatter, ErrorFrequency,
278    ErrorMessageEnhancer as EnhancedErrorMessageEnhancer, ErrorPattern as EnhancedErrorPattern,
279    ErrorPatternAnalyzer, ExpertiseLevel, ImplementationStep, IssueRelationship, MissingValueInfo,
280    OutputFormat, PerformanceBottleneck, PerformanceContext as EnhancedPerformanceContext,
281    PipelineContext as EnhancedPipelineContext, QualityIssue, RecoveryAdvisor,
282    RecoveryStrategy as EnhancedRecoveryStrategy, RelatedIssue, ResolutionStep, ResolutionStrategy,
283    SeverityLevel, SimilarIssue, StackFrame, SuggestionEngine, SuggestionGenerator,
284};
285pub use enhanced_errors::{
286    DataShape, EnhancedErrorBuilder, ErrorContext, ImpactLevel,
287    PerformanceMetrics as EnhancedPerformanceMetrics, PerformanceWarningType, PipelineError,
288    ResourceType, StructureErrorType, TypeViolationType,
289};
290pub use ensemble::{
291    CompetenceEstimation, DynamicEnsembleSelector, DynamicEnsembleSelectorBuilder,
292    DynamicEnsembleSelectorTrained, FusionStrategy, HierarchicalComposition,
293    HierarchicalCompositionBuilder, HierarchicalCompositionTrained, HierarchicalNode,
294    HierarchicalStrategy, ModelFusion, ModelFusionBuilder, ModelFusionTrained, SelectionStrategy,
295    VotingClassifier, VotingClassifierBuilder, VotingClassifierTrained, VotingRegressor,
296    VotingRegressorBuilder, VotingRegressorTrained,
297};
298pub use execution::{
299    ExecutionEngineConfig, ExecutionStrategy, ExecutionTask,
300    ParameterValue as ComposableParameterValue, PerformanceGoals, ResourceConstraints,
301    StrategyConfig, StrategyMetrics, TaskHandle, TaskPriority, TaskResult, TaskScheduler,
302    TaskStatus, TaskType,
303};
304pub use execution_hooks::{
305    CustomHook, CustomHookBuilder, ExecutionContext as HookExecutionContext, ExecutionHook,
306    HookData, HookManager, HookPhase, HookResult, LogLevel as HookLogLevel, LoggingHook,
307    MemoryUsage as HookMemoryUsage, PerformanceHook, PerformanceMetrics as HookPerformanceMetrics,
308    ValidationHook,
309};
310pub use external_integration::{
311    AuthConfig, AuthCredentials, AuthType, BackoffStrategy, CircuitBreakerConfig,
312    CircuitBreakerState, CircuitState, ConnectionConfig, DatabaseIntegration, ExternalIntegration,
313    ExternalIntegrationManager, HealthCheckConfig, HealthStatus, IntegrationConfig,
314    IntegrationData, IntegrationRequest, IntegrationResponse, IntegrationType, Operation,
315    OperationResult, RateLimitConfig, RefreshConfig, RestApiIntegration, RetryCondition,
316    RetryPolicy, TimeoutConfig, TlsConfig,
317};
318pub use feature_engineering::{
319    AutoFeatureEngineer, ColumnType, ColumnTypeDetector, DetectionMethod, FeatureInteraction,
320    FeatureInteractionDetector, InteractionType,
321};
322pub use few_shot::{
323    DistanceMetric, FewShotLearnerType, FewShotPipeline, FewShotPipelineTrained, MAMLLearner,
324    MAMLLearnerTrained, MetaLearnerWrapper, PrototypicalNetwork, PrototypicalNetworkTrained,
325    SupportSet,
326};
327pub use fluent_api::{
328    CacheStrategy, CachingConfiguration, DebugConfiguration, FeatureEngineeringChain,
329    FeatureUnionBuilder, FluentPipelineBuilder, ImputationStrategy, LogLevel, MemoryConfiguration,
330    PipelineConfiguration, PipelinePresets, PreprocessingChain, ValidationConfiguration,
331    ValidationLevel,
332};
333pub use memory_optimization::{
334    MemoryEfficientOps, MemoryMonitor, MemoryMonitorConfig, MemoryPool, MemoryStatistics,
335    MemoryUsage as MemoryOptimizationUsage, PoolStatistics, StreamingBuffer,
336};
337pub use meta_learning::{
338    AdaptationStrategy, Experience, ExperienceStorage, MetaLearningPipeline,
339    MetaLearningPipelineTrained,
340};
341pub use middleware::{
342    AlertManager, AlertRule, AlertSeverity as MiddlewareAlertSeverity, AuthenticationCredentials,
343    AuthenticationMethod as MiddlewareAuthMethod, AuthenticationMiddleware, AuthenticationProvider,
344    AuthorizationConfig as MiddlewareAuthConfig, AuthorizationMiddleware, CacheConfig, CacheEntry,
345    CachingMiddleware, ErrorAction, MiddlewareChain, MiddlewareChainConfig, MiddlewareContext,
346    MiddlewareStats, MonitoringMiddleware, PipelineMiddleware, TransformationMiddleware,
347    UserInfo as MiddlewareUserInfo, ValidationMiddleware,
348};
349pub use mock::{MockPredictor, MockTransformer};
350pub use modular_framework::{
351    CapabilityMismatch, CompatibilityReport, ComponentCapability, ComponentConfig,
352    ComponentDependency, ComponentFactory, ComponentInfo, ComponentMetadata, ComponentNode,
353    ComponentRegistry, ComponentStatus, CompositionContext, ConfigValue as ModularConfigValue,
354    DependencyGraph, EnvironmentSettings, ErrorHandlingStrategy, ExecutionCondition,
355    ExecutionMetadata as ModularExecutionMetadata, ExecutionStrategy as ModularExecutionStrategy,
356    LogLevel as ModularLogLevel, MissingDependency, ModularPipeline, ModularPipelineBuilder,
357    PipelineConfig as ModularPipelineConfig, PipelineStep as ModularPipelineStep,
358    PluggableComponent, ResourceLimits, ResourceManager, VersionConflict,
359};
360pub use monitoring::{
361    Anomaly, AnomalySeverity, AnomalyType, ExecutionContext as MonitoringExecutionContext,
362    ExecutionHandle, ExecutionStatus, Metric, MetricsSnapshot, MonitorConfig, PerformanceAnalysis,
363    PerformanceBaseline, PerformanceTrends, PipelineMonitor, StagePerformance, Trend,
364};
365pub use nlp_pipelines::{
366    AnalysisResult, BagOfWordsExtractor, ContextManager, ConversationResponse, ConversationTurn,
367    ConversationalAI, DocumentParser, DocumentProcessor, Entity, EvaluationConfig,
368    EvaluationMetric, FeatureExtractionConfig, FeatureExtractor as NLPFeatureExtractor,
369    LanguageDetector, LanguageModel, ModelConfig as NLPModelConfig, ModelPrediction,
370    ModelType as NLPModelType, MultiLanguageSupport, NERAnalyzer, NLPPipeline, NLPPipelineConfig,
371    OutputFormatter, PreprocessingConfig, ProcessingResult, ProcessingStats,
372    QuestionAnsweringModel, SentimentAnalyzer, SimpleLanguageModel, SummarizationStrategy,
373    TextAnalyzer, TextClassifier, TextNormalizer, TextPreprocessor, TextSummarizationModel,
374    TfIdfExtractor, TopicModelingAnalyzer, TrainingConfig as NLPTrainingConfig, TranslationModel,
375    WordEmbeddingExtractor,
376};
377pub use optimization::{
378    ErrorHandlingStrategy as OptimizationErrorHandlingStrategy, FallbackStrategy,
379    MultiObjectiveResult, OptimizationResults, ParameterSpace, ParameterType, ParetoFront,
380    PipelineOptimizer, PipelineValidator, RobustPipelineExecutor, ScoringMetric, SearchStrategy,
381};
382// pub use pattern_optimization::{
383//     MultiObjectiveOptimizer, MOOAlgorithm, ParetoFrontManager,
384//     ScalarizationMethod, ScalarizationType, PreferenceModel, PreferenceModelType,
385//     PreferenceStructure, PreferenceRelation, RelationType, IterationResult,
386//     SolutionSelector, DiversityMaintainer, MOOConvergenceDetector,
387//     MOOPerformanceIndicators, ArchiveManager, DominationAnalyzer,
388//     FrontExtractor, FrontQualityAssessor, FrontVisualizer,
389// };
390pub use parallel_execution::{
391    AsyncTask, LoadBalancingStrategy, ParallelConfig, ParallelExecutionStrategy, ParallelExecutor,
392    ParallelPipeline, ParallelTask, TaskResult as ParallelTaskResult, WorkerStatistics,
393};
394pub use performance_profiler::{
395    BottleneckMetrics, BottleneckSeverity as ProfilerBottleneckSeverity,
396    BottleneckType as ProfilerBottleneckType, ComparativeAnalysis, CpuSample as ProfilerCpuSample,
397    GpuSample, ImplementationDifficulty, MemorySample as ProfilerMemorySample,
398    OptimizationCategory, OptimizationHint, OptimizationPriority, OverallMetrics,
399    PerformanceProfiler as ProfilerPerformanceProfiler,
400    PerformanceReport as ProfilerPerformanceReport, ProfileSession, ProfilerConfig, StageProfile,
401    SummaryMetrics, TrendDirection as ProfilerTrendDirection,
402};
403pub use performance_testing::{
404    BenchmarkContext, BenchmarkResult as PerformanceBenchmarkResult, BenchmarkStorage,
405    CpuStatistics, EnvironmentConfig as PerformanceEnvironmentConfig, EnvironmentMetadata,
406    MemoryStatistics as PerformanceMemoryStatistics, OutlierDetection,
407    PerformanceMetrics as PerformanceTestingMetrics, PerformanceRegressionTester,
408    PerformanceReport, ProfilingConfig, RegressionAnalysis, RegressionSeverity,
409    RegressionThresholds, StatisticalAnalysisConfig, StatisticalTest, SystemInfo,
410    ThroughputMetrics, TimeStatistics, TrendAnalysis,
411};
412pub use pipeline::{Pipeline, PipelineBuilder, PipelinePredictor, PipelineStep, PipelineTrained};
413pub use pipeline_visualization::{
414    DataSpecification, DataType as VisualizationDataType, EdgeProperties, EdgeStyle, ExportFormat,
415    FontProperties, FontWeight, GraphEdge, GraphNode, IoSpecification, LayoutAlgorithm, NodeShape,
416    NodeSize, ParameterValue as VisualizationParameterValue, PipelineGraph, PipelineVisualizer,
417    ShapeSpecification, VisualProperties, VisualizationConfig,
418};
419pub use plugin_architecture::{
420    ComponentConfig as PluginComponentConfig, ComponentContext,
421    ComponentFactory as PluginComponentFactory, ComponentSchema, ConfigValue as PluginConfigValue,
422    ParameterConstraint, ParameterSchema, ParameterType as PluginParameterType, Plugin,
423    PluginCapability, PluginComponent, PluginConfig, PluginContext, PluginEstimator, PluginLoader,
424    PluginMetadata, PluginRegistry, PluginTransformer,
425};
426pub use profile_guided_optimization::{
427    AccessPattern, CacheOptimizationHints, DataCharacteristics, ExecutionMetrics, HardwareContext,
428    MLPerformancePredictor, MemoryLayout, OptimizationLevel, OptimizationStats,
429    OptimizationStrategy, OptimizerConfig, ParallelStrategy, PerformancePredictor,
430    PerformanceProfile, ProfileGuidedOptimizer, SimdFeature,
431};
432pub use property_testing::{
433    PipelinePropertyTester, PropertyTestCase, PropertyTestGenerator, PropertyTestResult,
434    StatisticalValidator, TestSuiteResult, TestSuiteRunner,
435    ValidationResult as PropertyValidationResult, ValidationStatistics,
436};
437pub use quality_assurance::{
438    AutomatedQualityAssurance, ComplianceStatus, ExecutiveSummary,
439    IssueCategory as QAIssueCategory, IssueSeverity as QAIssueSeverity, QAConfig,
440    QualityAssessment, QualityGates, QualityIssue as QAQualityIssue, QualityMetrics, QualityReport,
441    QualityStandards, RecommendationCategory as QARecommendationCategory,
442    RecommendationPriority as QARecommendationPriority, TrendDirection as QATrendDirection,
443};
444pub use quantum::{
445    QuantumBackend, QuantumEnsemble, QuantumGate, QuantumPipeline, QuantumPipelineBuilder,
446    QuantumPipelineStep, QuantumTransformer,
447};
448// pub use retry::{
449//     AdaptiveLearningSystem, BackoffAlgorithm, ExponentialBackoffAlgorithm, RetryManager,
450//     RetryStrategy, RetryContext, RetryConfig as RetryConfiguration, RetryError, RetryMetrics,
451//     AdaptiveStrategy, CircuitBreakerStrategy, LinearBackoffStrategy, FeatureEngineering,
452//     PolicyEvaluator, RetryPolicyEngine, ConfigurationManager, GlobalRetryConfig,
453//     AlertingSystem, RetryMetricsCollector, ModelPerformanceMetrics, SystemStatistics,
454// };
455pub use scheduling::{
456    ResourcePool, RetryConfig, ScheduledTask, SchedulerStatistics, SchedulingStrategy,
457    TaskScheduler as SchedulingTaskScheduler, TaskState, Workflow, WorkflowManager,
458};
459pub use simd_optimizations::{SimdConfig, SimdDataLayout, SimdFeatureOps, SimdOps};
460pub use state_management::{
461    CheckpointConfig, ExecutionStatistics, PersistenceStrategy, PipelineVersionControl, StateData,
462    StateManager, StateSnapshot, StateSynchronizer,
463};
464pub use streaming::{
465    StateManagement, StreamConfig, StreamDataPoint, StreamStats, StreamWindow, StreamingPipeline,
466    StreamingPipelineTrained, UpdateStrategy, WindowingStrategy,
467};
468pub use stress_testing::{
469    ComputationType, EdgeCase, MemoryPattern, ResourceMonitor, ResourceStats, ResourceUsageStats,
470    StressTestConfig, StressTestIssue, StressTestReport, StressTestResult, StressTestScenario,
471    StressTester,
472};
473// TODO: Enable once time_series_pipelines modules are implemented
474// pub use time_series_pipelines::{
475//     AnomalyDetector, AnomalyType as TimeSeriesAnomalyType, DataStream, EdgeNode, FeatureEngineer,
476//     IoTConfig, IoTDataPipeline, IoTDevice, MessageBroker, PostProcessor as TSPostProcessor,
477//     QualityControlConfig, RealTimeConfig, SamplingFrequency, SeasonalPattern,
478//     TimeSeriesCharacteristics, TimeSeriesConfig as TSConfig, TimeSeriesMetrics, TimeSeriesModel,
479//     TimeSeriesPipeline, TimeSeriesTransform, TrendType,
480// };
481pub use enhanced_wasm_integration::{
482    BrowserFeature, BrowserFeatureDetection, BrowserInfo,
483    BrowserIntegration as EnhancedBrowserIntegration, CompilationTarget, CompiledWasmModule,
484    CpuIntensity, ExecutionContext as WasmExecutionContext, ExecutionProfile,
485    FeatureDetectionStrategy, FunctionHandle, FunctionSignature, GeneratedBinding, IoProfile,
486    JsBindingsGenerator, JsType, LoadedWasmModule, MemoryConstraints,
487    MemoryLayout as WasmMemoryLayout, MemoryPermissions, MemoryProfile, MemoryRegion, ModuleLoader,
488    ModuleSource, OptimizationPass, OptimizationResult,
489    OptimizationStrategy as WasmOptimizationStrategy, PerformanceHints,
490    PerformanceProfile as WasmPerformanceProfile, PerformanceRequirements, ProfilingSession,
491    ScalingProfile, TaskData, TaskPriority as WasmTaskPriority, TaskType as WasmTaskType,
492    TypedArrayType, WasmArchitecture, WasmCompiler as EnhancedWasmCompiler, WasmExport,
493    WasmExportValue, WasmImport, WasmInstance, WasmIntegrationConfig, WasmIntegrationManager,
494    WasmMemoryView, WasmModuleManager, WasmModuleMetadata, WasmPerformanceOptimizer, WasmProfiler,
495    WasmType, WasmValue as EnhancedWasmValue, WebApiIntegration,
496    WorkerStatistics as WasmWorkerStatistics, WorkerStatus, WorkerTask, WorkerThread,
497    WorkerThreadManager,
498};
499pub use transfer_learning::{
500    domain_adaptation::{
501        DomainAdaptationPipeline, DomainAdaptationPipelineTrained, DomainAdaptationStrategy,
502    },
503    AdaptationConfig, LearningRateSchedule, PretrainedModel, TransferLearningPipeline,
504    TransferLearningPipelineTrained, TransferStrategy,
505};
506pub use type_safety::{
507    CategoricalInput, ClassificationOutput, DataFlowValidation, DataFlowValidator, DenseOutput,
508    Input, MixedInput, NumericInput, Output, PipelineValidation, PipelineValidationError,
509    RegressionOutput, SparseOutput, StructureValidation, TypeCompatible, TypedEstimator,
510    TypedFeatureUnion, TypedPipelineBuilder, TypedPipelineStage, TypedTransformer,
511};
512pub use validation::{
513    ComprehensivePipelineValidator, CrossValidationResult, CrossValidator, DataValidationResult,
514    DataValidator, MessageLevel, PerformanceValidationResult, PerformanceValidator,
515    RobustnessTestResult, RobustnessTester, StatisticalValidationResult,
516    StatisticalValidator as ComprehensiveStatisticalValidator, StructureValidationResult,
517    StructureValidator, ValidationMessage, ValidationReport as ComprehensiveValidationReport,
518};
519pub use wasm_integration::{
520    BrowserIntegration, DataSchema, OptimizationLevel as WasmOptimizationLevel, PipelineMetadata,
521    WasmCompiler, WasmConfig, WasmDataType, WasmModule, WasmOptimization, WasmPipeline, WasmStep,
522    WasmStepType, WasmValue,
523};
524#[cfg(feature = "workflow")]
525pub use workflow_language::{
526    CodeLanguage, ComponentRegistry as WorkflowComponentRegistry, DataType, DslError, DslLexer,
527    DslParser, ExecutionConfig as WorkflowExecutionConfig, ExecutionMode, FileFormat,
528    ParameterValue, PipelineDSL, StepDefinition, StepType as WorkflowStepType, Token,
529    VisualPipelineBuilder, WorkflowDefinition, WorkflowMetadata,
530};
531pub use zero_cost::{
532    AllocationInfo, Arena, AtomicRcData, ConcurrencyStats, CowData, LockFreeQueue,
533    MemoryLeakConfig, MemoryLeakDetector, MemoryPool as ZeroCostMemoryPool, MemoryStats,
534    PooledBuffer, QueueStats, SafeConcurrentData, SharedData, TrackedAllocation, WeakRcData,
535    WorkStealingDeque, WorkStealingStats, ZeroCopySlice, ZeroCopyView, ZeroCostBuffer,
536    ZeroCostBuilder, ZeroCostCompose, ZeroCostComposition, ZeroCostConditional, ZeroCostEstimator,
537    ZeroCostFeatureSelector, ZeroCostFeatureUnion, ZeroCostLayout, ZeroCostParallel,
538    ZeroCostPipeline, ZeroCostStep,
539};
540
541use scirs2_core::ndarray::{Array1, Array2, ArrayView1, ArrayView2};
542use sklears_core::types::Float;
543use sklears_core::{
544    error::Result as SklResult,
545    prelude::{Fit as CoreFit, Predict, SklearsError, Transform},
546    traits::{Estimator, Fit, Untrained},
547};
548use std::collections::HashMap;
549
550/// Transformed Target Regressor
551///
552/// Meta-estimator that transforms the target y before fitting a regression model.
553/// The predictions are mapped back to the original space via an inverse transform.
554///
555/// # Parameters
556///
557/// * `regressor` - The regressor to use for prediction
558/// * `transformer` - The transformer to apply to the target
559/// * `func` - Function to transform the target
560/// * `inverse_func` - Function to inverse transform the predictions
561/// * `check_inverse` - Whether to check the inverse transform
562///
563// Type aliases to reduce complexity
564type TransformBox = Box<dyn for<'a> Transform<ArrayView1<'a, Float>, Array1<f64>> + Send + Sync>;
565type TransformFunc = fn(&ArrayView1<'_, Float>) -> Array1<f64>;
566
567/// # Examples
568///
569/// ```
570/// use sklears_compose::TransformedTargetRegressor;
571/// use scirs2_core::ndarray::array;
572///
573/// let X = array![[1.0], [2.0], [3.0]];
574/// let y = array![1.0, 4.0, 9.0];
575/// ```
576pub struct TransformedTargetRegressor<S = Untrained> {
577    state: S,
578    regressor: Option<Box<dyn PipelinePredictor>>,
579    transformer: Option<TransformBox>,
580    func: Option<TransformFunc>,
581    inverse_func: Option<TransformFunc>,
582    check_inverse: bool,
583}
584
585/// Trained state for `TransformedTargetRegressor`
586pub struct TransformedTargetRegressorTrained {
587    fitted_regressor: Box<dyn PipelinePredictor>,
588    fitted_transformer: Option<TransformBox>,
589    func: Option<TransformFunc>,
590    inverse_func: Option<TransformFunc>,
591    n_features_in: usize,
592    feature_names_in: Option<Vec<String>>,
593}
594
595impl TransformedTargetRegressor<Untrained> {
596    /// Create a new `TransformedTargetRegressor`
597    #[must_use]
598    pub fn new(regressor: Box<dyn PipelinePredictor>) -> Self {
599        Self {
600            state: Untrained,
601            regressor: Some(regressor),
602            transformer: None,
603            func: None,
604            inverse_func: None,
605            check_inverse: true,
606        }
607    }
608
609    /// Set the transformer
610    #[must_use]
611    pub fn transformer(
612        mut self,
613        transformer: Box<dyn for<'a> Transform<ArrayView1<'a, Float>, Array1<f64>> + Send + Sync>,
614    ) -> Self {
615        self.transformer = Some(transformer);
616        self
617    }
618
619    /// Set transformation function
620    pub fn func(mut self, func: fn(&ArrayView1<'_, Float>) -> Array1<f64>) -> Self {
621        self.func = Some(func);
622        self
623    }
624
625    /// Set inverse transformation function
626    pub fn inverse_func(mut self, inverse_func: fn(&ArrayView1<'_, Float>) -> Array1<f64>) -> Self {
627        self.inverse_func = Some(inverse_func);
628        self
629    }
630
631    /// Set whether to check inverse transform
632    #[must_use]
633    pub fn check_inverse(mut self, check: bool) -> Self {
634        self.check_inverse = check;
635        self
636    }
637}
638
639impl Estimator for TransformedTargetRegressor<Untrained> {
640    type Config = ();
641    type Error = SklearsError;
642    type Float = Float;
643
644    fn config(&self) -> &Self::Config {
645        &()
646    }
647}
648
649impl Fit<ArrayView2<'_, Float>, Option<&ArrayView1<'_, Float>>>
650    for TransformedTargetRegressor<Untrained>
651{
652    type Fitted = TransformedTargetRegressor<TransformedTargetRegressorTrained>;
653
654    fn fit(
655        self,
656        x: &ArrayView2<'_, Float>,
657        y: &Option<&ArrayView1<'_, Float>>,
658    ) -> SklResult<Self::Fitted> {
659        if let Some(y_values) = y.as_ref() {
660            let mut regressor = self.regressor.ok_or_else(|| SklearsError::InvalidData {
661                reason: "No regressor provided".to_string(),
662            })?;
663
664            // Transform the target if transformer or function is provided
665            let transformed_y = if let Some(ref transformer) = self.transformer {
666                transformer.transform(y_values)?
667            } else if let Some(func) = self.func {
668                func(y_values)
669            } else {
670                y_values.mapv(|v| v)
671            };
672
673            // Fit the regressor on transformed target
674            regressor.fit(x, &transformed_y.view())?;
675
676            Ok(TransformedTargetRegressor {
677                state: TransformedTargetRegressorTrained {
678                    fitted_regressor: regressor,
679                    fitted_transformer: self.transformer,
680                    func: self.func,
681                    inverse_func: self.inverse_func,
682                    n_features_in: x.ncols(),
683                    feature_names_in: None,
684                },
685                regressor: None,
686                transformer: None,
687                func: None,
688                inverse_func: None,
689                check_inverse: self.check_inverse,
690            })
691        } else {
692            Err(SklearsError::InvalidInput(
693                "Target values required for fitting".to_string(),
694            ))
695        }
696    }
697}
698
699impl TransformedTargetRegressor<TransformedTargetRegressorTrained> {
700    /// Predict using the fitted regressor and inverse transform
701    pub fn predict(&self, x: &ArrayView2<'_, Float>) -> SklResult<Array1<f64>> {
702        // Get predictions from the fitted regressor
703        let transformed_predictions = self.state.fitted_regressor.predict(x)?;
704
705        // Apply inverse transformation
706        let predictions = if let Some(inverse_func) = self.state.inverse_func {
707            inverse_func(&transformed_predictions.view())
708        } else if let Some(ref transformer) = self.state.fitted_transformer {
709            // Note: This assumes the transformer has an inverse_transform method
710            // In a real implementation, you'd need a proper inverse transformer trait
711            transformed_predictions
712        } else {
713            transformed_predictions
714        };
715
716        Ok(predictions)
717    }
718
719    /// Get the fitted regressor
720    #[must_use]
721    pub fn regressor(&self) -> &dyn PipelinePredictor {
722        &*self.state.fitted_regressor
723    }
724}
725
726/// Feature Union for parallel feature extraction
727///
728/// Applies multiple transformers in parallel and concatenates their results.
729///
730/// # Examples
731///
732/// ```ignore
733/// use sklears_compose::FeatureUnion;
734/// use scirs2_core::ndarray::array;
735///
736/// let data = array![[1.0, 2.0], [3.0, 4.0]];
737/// let union = FeatureUnion::new()
738///     .transformer("trans1", Box::new(MockTransformer::new()))
739///     .transformer("trans2", Box::new(MockTransformer::new()));
740/// ```
741#[derive(Debug)]
742pub struct FeatureUnion<S = Untrained> {
743    state: S,
744    transformers: Vec<(String, Box<dyn PipelineStep>)>,
745    n_jobs: Option<i32>,
746    transformer_weights: Option<HashMap<String, f64>>,
747    preserve_dataframe: bool,
748}
749
750/// Trained state for `FeatureUnion`
751#[derive(Debug)]
752pub struct FeatureUnionTrained {
753    fitted_transformers: Vec<(String, Box<dyn PipelineStep>)>,
754    n_features_in: usize,
755    feature_names_in: Option<Vec<String>>,
756}
757
758impl FeatureUnion<Untrained> {
759    /// Create a new `FeatureUnion`
760    #[must_use]
761    pub fn new() -> Self {
762        Self {
763            state: Untrained,
764            transformers: Vec::new(),
765            n_jobs: None,
766            transformer_weights: None,
767            preserve_dataframe: false,
768        }
769    }
770
771    /// Add a transformer
772    #[must_use]
773    pub fn transformer(mut self, name: &str, transformer: Box<dyn PipelineStep>) -> Self {
774        self.transformers.push((name.to_string(), transformer));
775        self
776    }
777
778    /// Set number of jobs
779    #[must_use]
780    pub fn n_jobs(mut self, n_jobs: Option<i32>) -> Self {
781        self.n_jobs = n_jobs;
782        self
783    }
784
785    /// Set transformer weights
786    #[must_use]
787    pub fn transformer_weights(mut self, weights: HashMap<String, f64>) -> Self {
788        self.transformer_weights = Some(weights);
789        self
790    }
791
792    /// Set preserve dataframe option
793    #[must_use]
794    pub fn preserve_dataframe(mut self, preserve: bool) -> Self {
795        self.preserve_dataframe = preserve;
796        self
797    }
798}
799
800impl Default for FeatureUnion<Untrained> {
801    fn default() -> Self {
802        Self::new()
803    }
804}
805
806impl Estimator for FeatureUnion<Untrained> {
807    type Config = ();
808    type Error = SklearsError;
809    type Float = Float;
810
811    fn config(&self) -> &Self::Config {
812        &()
813    }
814}
815
816impl Fit<ArrayView2<'_, Float>, Option<&ArrayView1<'_, Float>>> for FeatureUnion<Untrained> {
817    type Fitted = FeatureUnion<FeatureUnionTrained>;
818
819    fn fit(
820        self,
821        x: &ArrayView2<'_, Float>,
822        y: &Option<&ArrayView1<'_, Float>>,
823    ) -> SklResult<Self::Fitted> {
824        let mut fitted_transformers = Vec::new();
825
826        for (name, mut transformer) in self.transformers {
827            transformer.fit(x, y.as_ref().copied())?;
828            fitted_transformers.push((name, transformer));
829        }
830
831        Ok(FeatureUnion {
832            state: FeatureUnionTrained {
833                fitted_transformers,
834                n_features_in: x.ncols(),
835                feature_names_in: None,
836            },
837            transformers: Vec::new(),
838            n_jobs: self.n_jobs,
839            transformer_weights: self.transformer_weights,
840            preserve_dataframe: self.preserve_dataframe,
841        })
842    }
843}
844
845impl FeatureUnion<FeatureUnionTrained> {
846    /// Transform data using all fitted transformers and concatenate results
847    pub fn transform(&self, x: &ArrayView2<'_, Float>) -> SklResult<Array2<f64>> {
848        if self.state.fitted_transformers.is_empty() {
849            return Ok(x.mapv(|v| v));
850        }
851
852        let mut results = Vec::new();
853
854        for (name, transformer) in &self.state.fitted_transformers {
855            let mut transformed = transformer.transform(x)?;
856
857            // Apply weights if specified
858            if let Some(ref weights) = self.transformer_weights {
859                if let Some(&weight) = weights.get(name) {
860                    transformed.mapv_inplace(|v| v * weight);
861                }
862            }
863
864            results.push(transformed);
865        }
866
867        // Concatenate all results along the feature axis
868        if results.len() == 1 {
869            Ok(results.into_iter().next().unwrap())
870        } else {
871            let total_features: usize = results
872                .iter()
873                .map(scirs2_core::ndarray::ArrayBase::ncols)
874                .sum();
875            let n_samples = results[0].nrows();
876
877            let mut concatenated = Array2::zeros((n_samples, total_features));
878            let mut col_idx = 0;
879
880            for result in results {
881                let end_idx = col_idx + result.ncols();
882                concatenated
883                    .slice_mut(s![.., col_idx..end_idx])
884                    .assign(&result);
885                col_idx = end_idx;
886            }
887
888            Ok(concatenated)
889        }
890    }
891
892    /// Get the fitted transformers
893    #[must_use]
894    pub fn transformers(&self) -> &[(String, Box<dyn PipelineStep>)] {
895        &self.state.fitted_transformers
896    }
897}
898
899// Import ndarray slice macro
900use scirs2_core::ndarray::s;
901
902#[allow(non_snake_case)]
903#[cfg(test)]
904mod tests {
905    use super::*;
906    use scirs2_core::ndarray::array;
907
908    #[test]
909    fn test_mock_transformer() {
910        let transformer = MockTransformer::new();
911        let x = array![[1.0, 2.0], [3.0, 4.0]];
912        let result = crate::PipelineStep::transform(&transformer, &x.view()).unwrap();
913        assert_eq!(result, x.mapv(|v| v as f64));
914    }
915
916    #[test]
917    fn test_mock_predictor() {
918        let mut predictor = MockPredictor::new();
919        let x = array![[1.0, 2.0], [3.0, 4.0]];
920        let y = array![1.0, 2.0];
921
922        predictor.fit(&x.view(), &y.view()).unwrap();
923        assert!(predictor.is_fitted());
924
925        let predictions = predictor.predict(&x.view()).unwrap();
926        assert_eq!(predictions.len(), x.nrows());
927    }
928
929    #[test]
930    fn test_feature_union() {
931        let x = array![[1.0, 2.0], [3.0, 4.0]];
932
933        let union = FeatureUnion::new()
934            .transformer("trans1", Box::new(MockTransformer::new()))
935            .transformer("trans2", Box::new(MockTransformer::with_scale(2.0)));
936
937        let fitted_union = union.fit(&x.view(), &None).unwrap();
938        let result = fitted_union.transform(&x.view()).unwrap();
939
940        // Should concatenate results from both transformers
941        assert_eq!(result.ncols(), 4); // 2 features * 2 transformers
942        assert_eq!(result.nrows(), 2); // Same number of samples
943    }
944
945    #[test]
946    fn test_pipeline_basic() {
947        let x = array![[1.0, 2.0], [3.0, 4.0]];
948        let y = array![1.0, 2.0];
949
950        let pipeline = Pipeline::builder()
951            .step("scaler", Box::new(MockTransformer::new()))
952            .estimator(Box::new(MockPredictor::new()))
953            .build();
954
955        let fitted_pipeline = pipeline.fit(&x.view(), &Some(&y.view())).unwrap();
956        let predictions = fitted_pipeline.predict(&x.view()).unwrap();
957
958        assert_eq!(predictions.len(), x.nrows());
959    }
960}
sklears_compose/lib.rs

sklears_compose/
lib.rs
