Add AdaBoost classifier to linfa-ensemble (#427)

* feat: Add AdaBoost (Adaptive Boosting) to linfa-ensemble

Implements SAMME (Stagewise Additive Modeling using a Multiclass Exponential
loss function) algorithm for multi-class classification using ensemble learning.

## Features
- Sequential boosting with adaptive sample weighting
- Multi-class classification support (SAMME algorithm)
- Weighted voting for final predictions using model alpha values
- Automatic convergence handling and early stopping
- Resampling-based approach compatible with any base learner

## Implementation Details
- AdaBoost struct with model weights (alpha values) tracking
- AdaBoostParams following ParamGuard pattern for validation
- Configurable n_estimators and learning_rate hyperparameters
- Full trait implementations: Fit, Predict, PredictInplace
- Comprehensive error handling with proper error types

## Testing
- 12 unit tests covering parameter validation and model training
- 6 doc tests for API documentation
- Achieves 90-93% accuracy on Iris dataset with decision stumps
- Tests for different learning rates and tree depths

## Documentation
- Extensive inline documentation with algorithm explanation
- Working example (adaboost_iris.rs) with multiple configurations
- References to original AdaBoost paper (Freund & Schapire, 1997)
- Comparison with scikit-learn implementation

## Performance
- Successfully trains on Iris dataset (150 samples, 3 classes)
- Supports decision stumps (depth=1) and shallow trees
- Model weights properly reflect learner performance

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* fix: remove redundant explicit link target in rustdoc

Fixes rustdoc warning about redundant explicit links.
Changed [AdaBoost](AdaBoost) to [AdaBoost] as recommended by rustdoc linter.

* test: add tests for edge cases to improve coverage

Adds three new tests to improve code coverage:
- test_adaboost_early_stopping_on_perfect_fit: Tests early stopping on linearly separable data
- test_adaboost_single_class_error: Tests error handling for single-class datasets
- test_adaboost_classes_method: Tests that classes are properly identified

This should improve patch coverage from 81.69% to ~85%+

* style: apply rustfmt formatting

Fix import ordering and line wrapping to match rustfmt standards.

* fix: address code review feedback for AdaBoost implementation

Implements all requested changes from PR review:

1. Replace rand:: imports with ndarray_rand::rand:: for consistency
2. Change sample_weights from f32 to f64 for better precision
3. Fix learning_rate cancellation bug in weight update formula
   - Previously: weight *= ((alpha / learning_rate) as f32).exp()
   - Now: weight *= alpha.exp()
   - This ensures learning_rate actually affects sample weight updates
4. Fix classes field to store actual labels (T::Elem) instead of usize
   - Made AdaBoost struct generic over label type L
   - Stores original class labels for proper type safety
5. Remove duplicate y_array definition in predict_inplace
6. Add base learner error details to error message for better debugging
7. Add test_adaboost_different_learning_rates to verify learning_rate
   effects on model weights

All tests passing with no warnings or clippy issues.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* Cleanup f64

* No tie breaking

* Avoid magic number

---------

Co-authored-by: Deep Rathi <deeprathi222@gmail.com>
Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: 3 people

algorithms/linfa-ensemble/examples/adaboost_iris.rs

@@ -0,0 +1,134 @@
+use linfa::prelude::{Fit, Predict, ToConfusionMatrix};
+use linfa_ensemble::AdaBoostParams;
+use linfa_trees::DecisionTree;
+use ndarray_rand::rand::SeedableRng;
+use rand::rngs::SmallRng;
+
+fn adaboost_with_stumps(n_estimators: usize, learning_rate: f64) {
+    // Load dataset
+    let mut rng = SmallRng::seed_from_u64(42);
+    let (train, test) = linfa_datasets::iris()
+        .shuffle(&mut rng)
+        .split_with_ratio(0.8);
+
+    // Train AdaBoost model with decision tree stumps (max_depth=1)
+    // Stumps are weak learners commonly used with AdaBoost
+    let model = AdaBoostParams::new_fixed_rng(DecisionTree::params().max_depth(Some(1)), rng)
+        .n_estimators(n_estimators)
+        .learning_rate(learning_rate)
+        .fit(&train)
+        .unwrap();
+
+    // Make predictions
+    let predictions = model.predict(&test);
+    println!("Final Predictions: \n{predictions:?}");
+
+    let cm = predictions.confusion_matrix(&test).unwrap();
+    println!("{cm:?}");
+    println!(
+        "Test accuracy: {:.2}%\nwith Decision Tree stumps (max_depth=1),\nn_estimators: {n_estimators},\nlearning_rate: {learning_rate}.\n",
+        100.0 * cm.accuracy()
+    );
+    println!("Number of models trained: {}", model.n_estimators());
+}
+
+fn adaboost_with_shallow_trees(n_estimators: usize, learning_rate: f64, max_depth: usize) {
+    let mut rng = SmallRng::seed_from_u64(42);
+    let (train, test) = linfa_datasets::iris()
+        .shuffle(&mut rng)
+        .split_with_ratio(0.8);
+
+    // Train AdaBoost model with shallow decision trees
+    let model =
+        AdaBoostParams::new_fixed_rng(DecisionTree::params().max_depth(Some(max_depth)), rng)
+            .n_estimators(n_estimators)
+            .learning_rate(learning_rate)
+            .fit(&train)
+            .unwrap();
+
+    // Make predictions
+    let predictions = model.predict(&test);
+    println!("Final Predictions: \n{predictions:?}");
+
+    let cm = predictions.confusion_matrix(&test).unwrap();
+    println!("{cm:?}");
+    println!(
+        "Test accuracy: {:.2}%\nwith Decision Trees (max_depth={max_depth}),\nn_estimators: {n_estimators},\nlearning_rate: {learning_rate}.\n",
+        100.0 * cm.accuracy()
+    );
+
+    // Display model weights
+    println!("Model weights (alpha values):");
+    for (i, weight) in model.weights().iter().enumerate() {
+        println!("  Model {}: {:.4}", i + 1, weight);
+    }
+    println!();
+}
+
+fn main() {
+    println!("{}", "=".repeat(80));
+    println!("AdaBoost Examples on Iris Dataset");
+    println!("{}", "=".repeat(80));
+    println!();
+
+    // Example 1: AdaBoost with decision stumps (most common configuration)
+    println!("Example 1: AdaBoost with Decision Stumps");
+    println!("{}", "-".repeat(80));
+    adaboost_with_stumps(50, 1.0);
+    println!();
+
+    // Example 2: AdaBoost with lower learning rate
+    println!("Example 2: AdaBoost with Lower Learning Rate");
+    println!("{}", "-".repeat(80));
+    adaboost_with_stumps(100, 0.5);
+    println!();
+
+    // Example 3: AdaBoost with shallow trees
+    println!("Example 3: AdaBoost with Shallow Decision Trees");
+    println!("{}", "-".repeat(80));
+    adaboost_with_shallow_trees(50, 1.0, 2);
+    println!();
+
+    // Example 4: Comparing different configurations
+    println!("Example 4: Comparing Configurations");
+    println!("{}", "-".repeat(80));
+    let configs = vec![
+        (25, 1.0, 1, "Few stumps, high learning rate"),
+        (50, 1.0, 1, "Medium stumps, high learning rate"),
+        (100, 0.5, 1, "Many stumps, low learning rate"),
+        (50, 1.0, 2, "Shallow trees, high learning rate"),
+    ];
+
+    for (n_est, lr, depth, desc) in configs {
+        let mut rng = SmallRng::seed_from_u64(42);
+        let (train, test) = linfa_datasets::iris()
+            .shuffle(&mut rng)
+            .split_with_ratio(0.8);
+
+        let model =
+            AdaBoostParams::new_fixed_rng(DecisionTree::params().max_depth(Some(depth)), rng)
+                .n_estimators(n_est)
+                .learning_rate(lr)
+                .fit(&train)
+                .unwrap();
+
+        let predictions = model.predict(&test);
+        let cm = predictions.confusion_matrix(&test).unwrap();
+
+        println!(
+            "{desc:50} => Accuracy: {:.2}% (models trained: {})",
+            100.0 * cm.accuracy(),
+            model.n_estimators()
+        );
+    }
+
+    println!();
+    println!("{}", "=".repeat(80));
+    println!("Notes:");
+    println!("- AdaBoost works by training weak learners sequentially");
+    println!("- Each learner focuses on samples misclassified by previous learners");
+    println!("- Decision stumps (depth=1) are the most common weak learners");
+    println!("- Lower learning_rate provides regularization but needs more estimators");
+    println!("- Model weights (alpha) reflect each learner's contribution to prediction");
+    println!("{}", "=".repeat(80));
+}