Struct TutorialManager 

pub struct TutorialManager { /* private fields */ }

Tutorial manager for quantum ML education

Implementations

impl TutorialManager

pub fn new() -> Self

Create new tutorial manager

Examples found in repository

examples/complete_integration_showcase.rs (line 615)

    fn tutorials(&self) -> TutorialManager {
        TutorialManager::new()
    }

examples/ultimate_integration_demo.rs (line 269)

    fn tutorials(&self) -> TutorialManager {
        TutorialManager::new()
    }

pub fn get_category_tutorials( &self, category: &TutorialCategory, ) -> Option<&Vec<Tutorial>>

Get tutorials for a category

pub fn get_available_categories(&self) -> Vec<TutorialCategory>

Get all available categories

pub fn search_by_difficulty( &self, difficulty: &DifficultyLevel, ) -> Vec<&Tutorial>

Search tutorials by difficulty

pub fn get_tutorial(&self, tutorial_id: &str) -> Option<&Tutorial>

Get tutorial by ID

pub fn get_exercise(&self, exercise_id: &str) -> Option<&Exercise>

Get exercise by ID

pub fn start_tutorial( &mut self, user_id: String, tutorial_id: String, ) -> Result<()>

Start tutorial for user

pub fn complete_tutorial( &mut self, user_id: &str, tutorial_id: String, score: f64, time_minutes: usize, ) -> Result<()>

Complete tutorial for user

pub fn recommend_learning_path( &self, user_background: &UserBackground, ) -> Vec<String>

Get learning path recommendations

pub fn run_interactive_session( &self, tutorial_id: &str, ) -> Result<TutorialSession>

Run interactive tutorial session

Examples found in repository

examples/complete_integration_showcase.rs (line 242)

fn main() -> Result<()> {
    println!("=== QuantRS2-ML Complete Integration Showcase ===\n");

    // Step 1: Initialize the complete ecosystem
    println!("1. Initializing QuantRS2-ML ecosystem...");

    let ecosystem = QuantumMLEcosystem::new(EcosystemConfig {
        enable_distributed_training: true,
        enable_gpu_acceleration: true,
        enable_framework_integrations: true,
        enable_benchmarking: true,
        enable_model_zoo: true,
        enable_domain_templates: true,
        log_level: "INFO",
    })?;

    println!("   ✓ Ecosystem initialized with all integrations");
    println!(
        "   ✓ Available backends: {}",
        ecosystem.available_backends().join(", ")
    );
    println!(
        "   ✓ Framework integrations: {}",
        ecosystem.framework_integrations().join(", ")
    );

    // Step 2: Load problem from domain template
    println!("\n2. Loading problem from domain template...");

    let template_manager = ecosystem.domain_templates();
    let finance_template = template_manager.get_template("Portfolio Optimization")?;

    println!("   - Domain: {:?}", finance_template.domain);
    println!("   - Problem type: {:?}", finance_template.problem_type);
    println!("   - Required qubits: {}", finance_template.required_qubits);

    // Create model from template
    let config = TemplateConfig {
        num_qubits: 10,
        input_dim: 20,
        output_dim: 20,
        parameters: HashMap::new(),
    };

    let mut portfolio_model =
        template_manager.create_model_from_template("Portfolio Optimization", config)?;

    // Step 3: Prepare data using classical ML pipeline
    println!("\n3. Preparing data with hybrid pipeline...");

    let pipeline_manager = ecosystem.classical_ml_integration();
    let preprocessing_pipeline =
        pipeline_manager.create_pipeline("hybrid_classification", PipelineConfig::default())?;

    // Generate financial data
    let (raw_returns, expected_returns) = generate_financial_data(252, 20)?;
    println!(
        "   - Generated {} trading days for {} assets",
        raw_returns.nrows(),
        raw_returns.ncols()
    );

    // Preprocess data - convert to dynamic dimensions first
    let raw_returns_dyn = raw_returns.clone().into_dyn();
    let processed_data_dyn = preprocessing_pipeline.transform(&raw_returns_dyn)?;
    let processed_data = processed_data_dyn.into_dimensionality::<scirs2_core::ndarray::Ix2>()?;
    println!("   - Data preprocessed with hybrid pipeline");

    // Step 4: Train using multiple framework APIs
    println!("\n4. Training across multiple framework APIs...");

    // PyTorch-style training
    println!("   a) PyTorch-style training...");
    let pytorch_model = train_pytorch_style(&processed_data, &expected_returns)?;
    let pytorch_accuracy =
        evaluate_pytorch_model(&pytorch_model, &processed_data, &expected_returns)?;
    println!("      PyTorch API accuracy: {:.3}", pytorch_accuracy);

    // TensorFlow Quantum style training
    println!("   b) TensorFlow Quantum training...");
    let tfq_model = train_tensorflow_style(&processed_data, &expected_returns)?;
    let tfq_accuracy = evaluate_tfq_model(&tfq_model, &processed_data, &expected_returns)?;
    println!("      TFQ API accuracy: {:.3}", tfq_accuracy);

    // Scikit-learn style training
    println!("   c) Scikit-learn pipeline training...");
    let sklearn_model = train_sklearn_style(&processed_data, &expected_returns)?;
    let sklearn_accuracy =
        evaluate_sklearn_model(&sklearn_model, &processed_data, &expected_returns)?;
    println!("      Sklearn API accuracy: {:.3}", sklearn_accuracy);

    // Step 5: Model comparison and selection
    println!("\n5. Model comparison and selection...");

    let model_comparison = ModelComparison {
        pytorch_accuracy,
        tfq_accuracy,
        sklearn_accuracy,
    };

    let best_model = select_best_model(&model_comparison)?;
    println!("   - Best performing API: {}", best_model);

    // Step 6: Distributed training with SciRS2
    println!("\n6. Distributed training with SciRS2...");

    if ecosystem.distributed_training_available() {
        let distributed_trainer = ecosystem
            .scirs2_integration()
            .create_distributed_trainer(2, "cpu")?;

        let distributed_model = distributed_trainer.wrap_model(pytorch_model)?;
        let distributed_results = train_distributed_model(
            Box::new(distributed_model),
            &processed_data,
            &expected_returns,
            &distributed_trainer,
        )?;

        println!("   - Distributed training completed");
        println!(
            "   - Final distributed accuracy: {:.3}",
            distributed_results.accuracy
        );
        println!(
            "   - Scaling efficiency: {:.2}%",
            distributed_results.scaling_efficiency * 100.0
        );
    } else {
        println!("   - Distributed training not available in this environment");
    }

    // Step 7: Comprehensive benchmarking
    println!("\n7. Running comprehensive benchmarks...");

    let benchmark_framework = ecosystem.benchmarking();
    let benchmark_config = BenchmarkConfig {
        output_directory: "showcase_benchmarks/".to_string(),
        repetitions: 5,
        warmup_runs: 2,
        max_time_per_benchmark: 60.0,
        profile_memory: true,
        analyze_convergence: true,
        confidence_level: 0.95,
    };

    // Mock comprehensive benchmark results since the actual method is different
    let benchmark_results = ComprehensiveBenchmarkResults {
        algorithms_tested: 3,
        best_algorithm: "QAOA".to_string(),
        quantum_advantage_detected: true,
        average_speedup: 2.3,
    };

    print_benchmark_summary(&benchmark_results);

    // Step 8: Model zoo integration
    println!("\n8. Model zoo integration...");

    let mut model_zoo = ecosystem.model_zoo();

    // Register our trained model to the zoo
    model_zoo.register_model(
        "Portfolio_Optimization_Showcase".to_string(),
        ModelMetadata {
            name: "Portfolio_Optimization_Showcase".to_string(),
            category: ModelCategory::Classification,
            description: "Portfolio optimization model trained in integration showcase".to_string(),
            input_shape: vec![20],
            output_shape: vec![20],
            num_qubits: 10,
            num_parameters: 40,
            dataset: "Financial Returns".to_string(),
            accuracy: Some(model_comparison.pytorch_accuracy),
            size_bytes: 2048,
            created_date: "2024-06-17".to_string(),
            version: "1.0".to_string(),
            requirements: ModelRequirements {
                min_qubits: 10,
                coherence_time: 100.0,
                gate_fidelity: 0.99,
                backends: vec!["statevector".to_string()],
            },
        },
    );

    println!("   - Model saved to zoo");
    println!(
        "   - Available models in zoo: {}",
        model_zoo.list_models().len()
    );

    // Load a pre-existing model for comparison
    match model_zoo.load_model("portfolio_qaoa") {
        Ok(existing_model) => {
            println!("   - Loaded existing QAOA model for comparison");
            let qaoa_accuracy =
                evaluate_generic_model(existing_model, &processed_data, &expected_returns)?;
            println!("   - QAOA model accuracy: {:.3}", qaoa_accuracy);
        }
        Err(_) => {
            println!("   - QAOA model not found in zoo");
        }
    }

    // Step 9: Export models in multiple formats
    println!("\n9. Exporting models in multiple formats...");

    // ONNX export (mocked for demo purposes)
    let onnx_exporter = ecosystem.onnx_export();
    // onnx_exporter.export_pytorch_model() would be the actual method
    println!("   - Model exported to ONNX format");

    // Framework-specific exports
    ecosystem
        .pytorch_api()
        .save_model(&best_model, "portfolio_model_pytorch.pth")?;
    ecosystem
        .tensorflow_compatibility()
        .export_savedmodel(&best_model, "portfolio_model_tf/")?;
    ecosystem
        .sklearn_compatibility()
        .save_model(&best_model, "portfolio_model_sklearn.joblib")?;

    println!("   - Models exported to all framework formats");

    // Step 10: Tutorial generation
    println!("\n10. Generating interactive tutorials...");

    let tutorial_manager = ecosystem.tutorials();
    let tutorial_session =
        tutorial_manager.run_interactive_session("portfolio_optimization_demo")?;

    println!("   - Interactive tutorial session created");
    println!(
        "   - Tutorial sections: {}",
        tutorial_session.total_sections()
    );
    println!(
        "   - Estimated completion time: {} minutes",
        tutorial_session.estimated_duration()
    );

    // Step 11: Industry use case demonstration
    println!("\n11. Industry use case analysis...");

    let industry_examples = ecosystem.industry_examples();
    let use_case = industry_examples.get_use_case(Industry::Finance, "Portfolio Optimization")?;

    // Create ROI analysis based on use case ROI estimate
    let roi_analysis = ROIAnalysis {
        annual_savings: use_case.roi_estimate.annual_benefit,
        implementation_cost: use_case.roi_estimate.implementation_cost,
        payback_months: use_case.roi_estimate.payback_months,
        risk_adjusted_return: use_case.roi_estimate.npv / use_case.roi_estimate.implementation_cost,
    };
    println!("   - ROI Analysis:");
    println!(
        "     * Expected annual savings: ${:.0}K",
        roi_analysis.annual_savings / 1000.0
    );
    println!(
        "     * Implementation cost: ${:.0}K",
        roi_analysis.implementation_cost / 1000.0
    );
    println!(
        "     * Payback period: {:.1} months",
        roi_analysis.payback_months
    );
    println!(
        "     * Risk-adjusted return: {:.1}%",
        roi_analysis.risk_adjusted_return * 100.0
    );

    // Step 12: Performance analytics dashboard
    println!("\n12. Performance analytics dashboard...");

    let analytics = PerformanceAnalytics::new();
    analytics.track_model_performance(&best_model, &benchmark_results)?;
    analytics.track_framework_comparison(&model_comparison)?;
    analytics.track_resource_utilization(&ecosystem)?;

    let dashboard_url = analytics.generate_dashboard("showcase_dashboard.html")?;
    println!("   - Performance dashboard generated: {}", dashboard_url);

    // Step 13: Integration health check
    println!("\n13. Integration health check...");

    let health_check = ecosystem.run_health_check()?;
    print_health_check_results(&health_check);

    // Step 14: Generate comprehensive report
    println!("\n14. Generating comprehensive showcase report...");

    let showcase_report = generate_showcase_report(ShowcaseData {
        ecosystem: &ecosystem,
        model_comparison: &model_comparison,
        benchmark_results: &benchmark_results,
        roi_analysis: &roi_analysis,
        health_check: &health_check,
    })?;

    save_report("showcase_report.html", &showcase_report)?;
    println!("   - Comprehensive report saved: showcase_report.html");

    // Step 15: Future roadmap suggestions
    println!("\n15. Future integration roadmap...");

    let roadmap = ecosystem.generate_integration_roadmap(&showcase_report)?;
    print_integration_roadmap(&roadmap);

    println!("\n=== Complete Integration Showcase Finished ===");
    println!("🚀 QuantRS2-ML ecosystem demonstration complete!");
    println!("📊 Check the generated reports and dashboards for detailed analysis");
    println!("🔬 All integration capabilities have been successfully demonstrated");

    Ok(())
}