Linfa

https://docs.rs/linfa/latest/
Admin
Linfa is a comprehensive toolkit for building Machine Learning applications with Rust, focusing on...
Tokens:145,103
Snippets:1,374
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### K-Fold Example Setup

Source: https://docs.rs/linfa/latest/linfa/dataset/type.Dataset.html

Sets up a dataset with records and targets for demonstrating K-folding. This example requires `linfa::dataset::DatasetView` and `ndarray`.

```rust
use linfa::dataset::DatasetView;
use ndarray::{Ix1, array};

let records = array![[1.,1.], [2.,1.], [3.,2.], [4.,1.],[5., 3.], [6.,2.]];
let targets = array![1, 1, 0, 1, 0, 0];

```

--------------------------------

### Example: K-Fold Cross-Validation Usage

Source: https://docs.rs/linfa/latest/src/linfa/dataset/impl_dataset.rs.html

Demonstrates how to use the `iter_fold` method for k-fold cross-validation with a mock fittable algorithm. This example shows setting up a dataset and iterating through folds.

```rust
use linfa::traits::Fit;
use linfa::dataset::{Dataset, DatasetView, Records};
use ndarray::{array, ArrayView1, ArrayView2, Ix1};
use linfa::Error;

struct MockFittable {}

struct MockFittableResult {
   mock_var: usize,
}

impl<'a> Fit<ArrayView2<'a,f64>, ArrayView1<'a, f64>, linfa::error::Error> for MockFittable {
   type Object = MockFittableResult;

   fn fit(&self, training_data: &DatasetView<f64, f64, Ix1>) -> Result<Self::Object, linfa::error::Error> {
       Ok(MockFittableResult {
           mock_var: training_data.nsamples(),
       })
   }
}

let records = array![[1.,1.], [2.,2.], [3.,3.], [4.,4.], [5.,5.]];
let targets = array![1.,2.,3.,4.,5.];
let mut dataset: Dataset<f64, f64, Ix1> = (records, targets).into();
let params = MockFittable {};

for (model,validation_set) in dataset.iter_fold(5, |v| params.fit(v).unwrap()){
   // Here you can use `model` and `validation_set` to
   // assert the performance of the chosen algorithm
}
```

--------------------------------

### Getting Metadata with and_then

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Shows how to use `and_then` to chain fallible file system operations, like getting metadata and then its modified time. Includes examples for both successful and failing paths.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

--------------------------------

### Multi-Class Model Prediction Example

Source: https://docs.rs/linfa/latest/src/linfa/composing/multi_class_model.rs.html

Shows how to create a multi-class model and use it for prediction on sample data.

```rust
use ndarray::Array2;
use crate::linfa::composing::MultiClassModel;

fn main() {
    let model = MultiClassModel::<_, usize>::new()
        .with_classes(vec![0, 1])
        .with_predict_fn(|_, _| Ok(0))
        .collect::<MultiClassModel<_, usize>>();

    let data = Array2::zeros((4, 2));
    assert_eq!(model.predict(&data), array![1, 0, 1, 0]);
}

```

--------------------------------

### K-Fold Example

Source: https://docs.rs/linfa/latest/linfa/dataset/struct.DatasetBase.html

Demonstrates how to perform K-folding on a dataset to generate training and validation pairs. Requires dataset and target arrays.

```rust
use linfa::dataset::DatasetView;
use ndarray::{Ix1, array};

let records = array![[1.,1.], [2.,1.], [3.,2.], [4.,1.],[5., 3.], [6.,2.]];
let targets = array![1, 1, 0, 1, 0, 0];


```

--------------------------------

### K-Fold Cross-Validation Example

Source: https://docs.rs/linfa/latest/src/linfa/dataset/impl_dataset.rs.html

Demonstrates how to perform k-fold cross-validation on a dataset. This is useful for evaluating model performance robustly.

```rust
use linfa::dataset::DatasetView;
use ndarray::{Ix1, array};

let records = array![[1.,1.], [2.,1.], [3.,2.], [4.,1.],[5., 3.], [6.,2.]];
let targets = array![1, 1, 0, 1, 0, 0];

let dataset : DatasetView<f64, usize, Ix1> = (records.view(), targets.view()).into();
let accuracies = dataset.fold(3).into_iter().map(|(train, valid)| {
    // Here you can train your model and perform validation
    
    // let model = params.fit(&dataset);
    // let predi = model.predict(&valid);
    // predi.confusion_matrix(&valid).accuracy()  
});
```

--------------------------------

### Get Dataset Targets

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetPr.html

Retrieves the targets of a dataset. This example assumes the dataset has boolean targets.

```rust
println!("{:?}", dataset.targets());
```

--------------------------------

### Get Number of Targets in Dataset

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetPr.html

Prints the total number of targets in the dataset. This example uses the winequality dataset.

```rust
let dataset = linfa_datasets::winequality();

println!("#targets {}", dataset.ntargets());
```

--------------------------------

### Sum of Results Example

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Illustrates using the `sum` method on an iterator of `Result` values. This example sums integers from a vector, returning an `Err` if a negative element is encountered, as defined by a closure.

```Rust
let f = |&x: &i32| if x < 0 { Err("Negative element found") } else { Ok(x) };
let v = vec![1, 2];
let res: Result<i32, _> = v.iter().map(f).sum();
assert_eq!(res, Ok(3));
let v = vec![1, -2];
let res: Result<i32, _> = v.iter().map(f).sum();
assert_eq!(res, Err("Negative element found"));
```

--------------------------------

### Product of Results Example

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Demonstrates using the `product` method on an iterator of `Result` values. It shows how to calculate the product of parsed numbers from a vector, returning an `Err` if any parsing fails.

```Rust
let nums = vec!["5", "10", "1", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert_eq!(total, Ok(100));
let nums = vec!["5", "10", "one", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert!(total.is_err());
```

--------------------------------

### Predict Trait Usage Examples

Source: https://docs.rs/linfa/latest/linfa/traits/trait.Predict.html

Demonstrates various ways to use the `predict` method from the Predict trait with different input and output types.

```rust
use linfa::traits::Predict;

// predict targets with reference to dataset (&Dataset -> Array)
let pred_targets = model.predict(&dataset);
// predict targets inside dataset (Dataset -> Dataset)
let pred_dataset = model.predict(dataset);
// or use a record datastruct directly (Array -> Dataset)
let pred_targets = model.predict(x);
```

--------------------------------

### Get Target Names - DatasetView

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetView.html

Returns a slice of human-readable strings describing each target. Useful for understanding the purpose of each target variable.

```rust
pub fn target_names(&self) -> &[String]
```

--------------------------------

### Providing Default Values with unwrap_or

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Shows how to use `unwrap_or` to get the `Ok` value or a provided default if the `Result` is `Err`. Arguments are eagerly evaluated.

```rust
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);

let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);
```

--------------------------------

### Create MultiTargetModel with Different Models

Source: https://docs.rs/linfa/latest/src/linfa/composing/multi_target_model.rs.html

Creates a `MultiTargetModel` by explicitly providing a vector of boxed models. This example demonstrates combining models with different prediction behaviors.

```rust
let model_a = DummyModel { val: 42.0 };
let model_b = DummyModel2 { val: 42.0 };

let model = MultiTargetModel::new(vec![Box::new(model_a), Box::new(model_b)]);
```

--------------------------------

### Get references to Result contents with as_ref()

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Use `as_ref()` to convert a `&Result<T, E>` into a `Result<&T, &E>`. This allows borrowing the contents without consuming the original Result.

```Rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

--------------------------------

### Dataset methods implementation

Source: https://docs.rs/linfa/latest/src/linfa/dataset/mod.rs.html

Demonstrates the implementation and usage of various `Dataset` methods including `new`, `shuffle`, `bootstrap_samples`, `bootstrap_samples_with_indices`, `bootstrap_features`, and `bootstrap_features_with_indices`.

```rust
let mut rng = SmallRng::seed_from_u64(42);

        // ------ Targets ------

        // New
        let mut dataset = Dataset::new(array![[1., 2.], [1., 2.]], array![0., 1.]);

        // Shuffle
        dataset = dataset.shuffle(&mut rng);

        // Bootstrap samples
        {
            let mut iter = dataset.bootstrap_samples(3, &mut rng);
            for _ in 1..5 {
                let b_dataset = iter.next().unwrap();
                assert_eq!(b_dataset.records().dim().0, 3);
            }
        }
        // Bootstrap samples with indices
        {
            let mut iter = dataset.bootstrap_samples_with_indices(3, &mut rng);
            for _ in 1..5 {
                let (b_dataset, indices) = iter.next().unwrap();
                assert_eq!(b_dataset.records().dim().0, 3);
                assert_eq!(indices.len(), 3);
            }
        }

        // Bootstrap features
        {
            let mut iter = dataset.bootstrap_features(3, &mut rng);
            for _ in 1..5 {
                let dataset = iter.next().unwrap();
                assert_eq!(dataset.records().dim(), (2, 3));
            }
        }

        // Bootstrap features with indices
        {
            let mut iter = dataset.bootstrap_features_with_indices(3, &mut rng);
            for _ in 1..5 {
                let (dataset, indices) = iter.next().unwrap();
                assert_eq!(dataset.records().dim(), (2, 3));
                assert_eq!(indices.len(), 3);
            }
        }
        // Bootstrap both
```

--------------------------------

### Create Datasets with Weights and Names

Source: https://docs.rs/linfa/latest/src/linfa/dataset/impl_dataset.rs.html

Demonstrates creating two new datasets, each with attached weights, feature names, and target names. This is useful for initializing datasets with specific metadata before further processing.

```rust
let dataset1 = Dataset::new(first, first_targets)
            .with_weights(self.weights)
            .with_feature_names(feature_names.clone())
            .with_target_names(target_names.clone());
        let dataset2 = Dataset::new(second, second_targets)
            .with_weights(second_weights)
            .with_feature_names(feature_names.clone())
            .with_target_names(target_names.clone());
```

--------------------------------

### Get Dataset Targets

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetPr.html

Returns a reference to the targets of the dataset.

```Rust
let targets = dataset.targets();
```

--------------------------------

### Get reference to targets

Source: https://docs.rs/linfa/latest/src/linfa/dataset/impl_dataset.rs.html

Returns a reference to the targets of the dataset. This is a read-only accessor.

```rust
pub fn targets(&self) -> &S {
        &self.targets
    }
```

--------------------------------

### Bootstrap Samples from DatasetView

Source: https://docs.rs/linfa/latest/src/linfa/dataset/mod.rs.html

Creates an iterator that yields bootstrap samples from a dataset view. Each sample contains a specified number of records.

```rust
let mut iter = dataset_view.bootstrap_samples(3, &mut rng);
for _ in 1..5 {
    let b_dataset = iter.next().unwrap();
    assert_eq!(b_dataset.records().dim().0, 3);
}
```

--------------------------------

### Get Dataset Records

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetPr.html

Returns a reference to the records (data points) of the dataset.

```Rust
let records = dataset.records();
```

--------------------------------

### Get Number of Targets - DatasetView

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetView.html

Returns the total count of target variables in the dataset.

```rust
pub fn ntargets(&self) -> usize
```

```rust
let dataset = linfa_datasets::winequality();

println!("#targets {}", dataset.ntargets());
```

--------------------------------

### new

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetPr.html

Creates a new dataset from records and targets.

```APIDOC
## pub fn new(records: R, targets: S) -> DatasetBase<R, S> 

### Description
Create a new dataset from records and targets.

### Parameters
#### Path Parameters
- **records** (R) - Required - The records for the dataset.
- **targets** (S) - Required - The targets for the dataset.

### Example
```
let dataset = Dataset::new(records, targets);
```
```

--------------------------------

### impl<T> CloneToUninit for T

Source: https://docs.rs/linfa/latest/linfa/dataset/struct.Pr.html

Provides the `clone_to_uninit` method for nightly-only experimental API.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API.

### Method
unsafe fn

### Endpoint
N/A

### Parameters
- **dest** (*mut u8) - Required - A mutable pointer to the destination memory.

### Request Example
None

### Response
None

### Response Example
None
```

--------------------------------

### Get TypeId of MultiTargetModel

Source: https://docs.rs/linfa/latest/linfa/composing/struct.MultiTargetModel.html

Retrieves the `TypeId` of the `MultiTargetModel` instance. This is part of the `Any` trait implementation.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Get Feature Names

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetPr.html

Returns a slice containing the human-readable names of the dataset's features.

```Rust
let feature_names = dataset.feature_names();
```

--------------------------------

### Composition Models Overview

Source: https://docs.rs/linfa/latest/src/linfa/composing/mod.rs.html

This snippet outlines the available composition models: MultiClassModel, MultiTargetModel, and Platt. It shows how to import and use them.

```rust
//! Composition models
//! 
//! This module contains three composition models:
//!  * `MultiClassModel`: combine multiple binary decision models to a single multi-class model
//!  * `MultiTargetModel`: combine multiple univariate models to a single multi-target model
//!  * `Platt`: calibrate a classifier (i.e. SVC) to predicted posterior probabilities
mod multi_class_model;
mod multi_target_model;
pub mod platt_scaling;

pub use multi_class_model::MultiClassModel;
pub use multi_target_model::MultiTargetModel;
pub use platt_scaling::{Platt, PlattError, PlattParams};
```

--------------------------------

### Get Dataset Weights

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetPr.html

Returns an optional reference to the weights of the dataset. Returns None if no weights are specified.

```Rust
let weights = dataset.weights();
```

--------------------------------

### DatasetIter: New Instance Creation

Source: https://docs.rs/linfa/latest/src/linfa/dataset/iter.rs.html

Initializes a new DatasetIter, which iterates over a DatasetBase. It requires a reference to the dataset and a boolean flag to indicate whether to iterate over features or targets.

```rust
impl<'a, 'b: 'a, R: Records, T> DatasetIter<'a, 'b, R, T> {
    pub fn new(
        dataset: &'b DatasetBase<R, T>,
        target_or_feature: bool,
    ) -> DatasetIter<'a, 'b, R, T> {
        DatasetIter {
            dataset,
            idx: 0,
            target_or_feature,
            phantom: PhantomData,
        }
    }
}
```

--------------------------------

### Get Type ID

Source: https://docs.rs/linfa/latest/linfa/metrics/struct.ConfusionMatrix.html

Retrieves the `TypeId` of the current object. This is a fundamental operation for runtime type identification.

```rust
self.type_id()
```

--------------------------------

### Bootstrap Samples

Source: https://docs.rs/linfa/latest/linfa/dataset/struct.DatasetBase.html

Applies sample bootstrapping to generate datasets. Useful for sub-sample generation to improve model accuracy and stability by sampling with replacement.

```rust
pub fn bootstrap_samples<R: Rng>(
 &'b self,
 num_samples: usize,
 rng: &'b mut R,
) -> impl Iterator<Item = DatasetBase<Array2<F>, T::Owned>> + 'b
```

--------------------------------

### Create a New Dataset

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetPr.html

Constructs a new dataset from provided records and targets. This is a fundamental method for initializing a dataset.

```Rust
let dataset = Dataset::new(records, targets);
```

--------------------------------

### DatasetBase::new

Source: https://docs.rs/linfa/latest/src/linfa/dataset/impl_dataset.rs.html

Creates a new dataset from provided records and targets. Initializes weights to empty and feature/target names to empty vectors.

```APIDOC
## DatasetBase::new

### Description
Creates a new dataset from records and targets. Initializes weights to empty and feature/target names to empty vectors.

### Method
```rust
pub fn new(records: R, targets: S) -> DatasetBase<R, S>
```

### Parameters
* `records`: The data points for the dataset.
* `targets`: The target values associated with the records.

### Returns
A new `DatasetBase` instance.

### Example
```rust
// Assuming 'records' and 'targets' are defined elsewhere
// let dataset = Dataset::new(records, targets);
```
```

--------------------------------

### Get a single weight

Source: https://docs.rs/linfa/latest/src/linfa/dataset/impl_dataset.rs.html

Retrieves the weight for a specific observation index. If no weights are specified, it defaults to 1.0 for all observations.

```rust
pub fn weight_for(&self, idx: usize) -> f32 {
        self.weights.get(idx).copied().unwrap_or(1.0)
    }
```

--------------------------------

### TryFrom Implementation for Pr

Source: https://docs.rs/linfa/latest/linfa/dataset/struct.Pr.html

Enables conversion from f32 to Pr with error handling.

```APIDOC
## type Error = f32

### Description
The type returned in the event of a conversion error.

### Type Alias
Error
```

```APIDOC
## fn try_from(prob: f32) -> Result<Self, Self::Error>

### Description
Tries to convert a float to a probability type.

### Method
try_from

### Parameters
- **prob**: f32 - The float value to convert.

### Returns
Result<Self, Self::Error> - Either the converted Pr type or an error indicating the conversion failure.
```

--------------------------------

### Records Trait

Source: https://docs.rs/linfa/latest/src/linfa/dataset/mod.rs.html

Trait for types that can be treated as a collection of records, providing methods to get the number of samples and features.

```APIDOC
## trait Records

### Description
Trait for types that can be treated as a collection of records, providing methods to get the number of samples and features.

### Associated Types
* `Elem`: The element type of the records.

### Methods
* `nsamples(&self) -> usize`: Returns the number of samples.
* `nfeatures(&self) -> usize`: Returns the number of features.
```

--------------------------------

### Get Weight for Observation - DatasetView

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetView.html

Retrieves the weight for a specific observation by its index. Defaults to 1.0 if no weights are specified.

```rust
pub fn weight_for(&self, idx: usize) -> f32
```

--------------------------------

### Bootstrap Dataset Samples

Source: https://docs.rs/linfa/latest/src/linfa/dataset/mod.rs.html

Creates an iterator that yields bootstrap samples of a dataset. Each sample has a specified number of records.

```rust
let mut iter = dataset.bootstrap((10, 10), &mut rng);
for _ in 1..5 {
    let dataset = iter.next().unwrap();
    assert_eq!(dataset.records().dim(), (10, 10));
}
```

--------------------------------

### Fit and Predict with Platt Scaling

Source: https://docs.rs/linfa/latest/linfa/composing/platt_scaling/index.html

Demonstrates fitting a Platt scaling model with training data and then using the fitted model to predict probabilities on validation data. Ensure the model and data are properly initialized before use.

```rust
let model = ...;

let model = Platt::params()
     .fit_with(model, &train)?;

let pred: Array1<Pr> = model.predict(&valid);
```

--------------------------------

### Clone and CloneFrom

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetView.html

Allows for creating deep copies of DatasetBase instances using clone() and efficient copying of data from one instance to another using clone_from().

```APIDOC
### impl<R, T: Clone> Clone for DatasetBase<R, T>
where R: Records + Clone,

#### fn clone(&self) -> DatasetBase<R, T>
Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`. Read more
```

--------------------------------

### Get records

Source: https://docs.rs/linfa/latest/src/linfa/dataset/impl_dataset.rs.html

Returns a reference to the records (data points) of the dataset. Records are the input data used for making predictions.

```rust
pub fn records(&self) -> &R {
        &self.records
    }
```

--------------------------------

### CloneToUninit Method (Nightly)

Source: https://docs.rs/linfa/latest/linfa/composing/platt_scaling/enum.PlattError.html

Performs copy-assignment from `self` to an uninitialized memory location. This is an experimental nightly-only API.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Get Feature Names - DatasetView

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetView.html

Returns a slice of human-readable strings describing each feature. Useful for analysis and understanding data.

```rust
pub fn feature_names(&self) -> &[String]
```

--------------------------------

### Get Single Observation Weight

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetPr.html

Retrieves the weight for a specific observation index. Defaults to 1.0 if no weights are defined for the dataset.

```Rust
let weight = dataset.weight_for(idx);
```

--------------------------------

### Bootstrap Dataset Samples and Features with Indices

Source: https://docs.rs/linfa/latest/src/linfa/dataset/impl_dataset.rs.html

Generates bootstrapped datasets along with the indices of the sampled data and features. This allows tracking which original samples and features were selected.

```rust
pub fn bootstrap_with_indices<R: Rng>(
        &'b self,
        sample_feature_size: (usize, usize),
        rng: &'b mut R,
    ) -> impl Iterator<Item = (DatasetBase<Array2<F>, T::Owned>, Vec<usize>, Vec<usize>)> + 'b {
        std::iter::repeat(()).map(move |_| {
            // sample with replacement
            let data_indices = (0..sample_feature_size.0)
                .map(|_| rng.gen_range(0..self.nsamples()))
                .collect::<Vec<_>>();

            let records = self.records().select(Axis(0), &data_indices);
            let targets = T::new_targets(self.as_targets().select(Axis(0), &data_indices));

            let feat_indices = (0..sample_feature_size.1)
                .map(|_| rng.gen_range(0..self.nfeatures()))
                .collect::<Vec<_>>();

            let records = records.select(Axis(1), &feat_indices);

            (
                DatasetBase::new(records, targets),
                data_indices,
                feat_indices,
            )
        })
    }
```

--------------------------------

### Calculate Precision using ConfusionMatrix

Source: https://docs.rs/linfa/latest/linfa/metrics/struct.ConfusionMatrix.html

Demonstrates how to create a ConfusionMatrix and calculate the precision score for label 0. Ensure necessary imports are included.

```rust
use linfa::prelude::*
use ndarray::array;

// create dummy classes 0 and 1
let prediction = array![0, 1, 1, 1, 0, 0, 1];
let ground_truth = array![0, 0, 1, 0, 1, 0, 1];

// create confusion matrix
let cm = prediction.confusion_matrix(&ground_truth).unwrap();

// print precision for label 0
println!("{:?}", cm.precision());
```

--------------------------------

### Get default targets for MultiTargetModel

Source: https://docs.rs/linfa/latest/linfa/composing/struct.MultiTargetModel.html

Generates default target values that are compatible with the `predict_inplace` method for the given input records.

```rust
fn default_target(&self, x: &ArrayBase<D, Ix2>) -> Array2<L>
```

--------------------------------

### AsMultiTargets Trait Definition

Source: https://docs.rs/linfa/latest/linfa/dataset/trait.AsMultiTargets.html

Defines the AsMultiTargets trait, which extends AsTargets and provides a method to get a reference to multi-target variables.

```rust
pub trait AsMultiTargets: AsTargets<Ix = Ix2> {
    // Provided method
    fn as_multi_targets(&self) -> ArrayView2<'_, Self::Elem> { ... }
}
```

--------------------------------

### From Array Implementation

Source: https://docs.rs/linfa/latest/linfa/dataset/struct.DatasetBase.html

Constructs a DatasetBase from a single array, with empty targets.

```APIDOC
## impl<F, D: Data<Elem = F>, I: Dimension> From<ArrayBase<D, I>> for DatasetBase<ArrayBase<D, I>, Array1<()>>

### Methods
- `from(records: ArrayBase<D, I>) -> Self`: Converts to this type from the input type.
```

--------------------------------

### Create a new dataset

Source: https://docs.rs/linfa/latest/src/linfa/dataset/mod.rs.html

Instantiates a new `Dataset` with features and targets. The `with_target_names` method can be used to assign names to the target variables.

```rust
let dataset = Dataset::new(array![[1., 2.], [1., 2.]], array![0., 1.])
            .with_target_names(vec!["test"]);
```

--------------------------------

### Get Target Names

Source: https://docs.rs/linfa/latest/linfa/dataset/type.Dataset.html

Returns a slice of strings representing the names of the targets in the dataset. These names provide context for each target variable.

```rust
let target_names = dataset.target_names();
```

--------------------------------

### Iterating Over Dataset Targets

Source: https://docs.rs/linfa/latest/src/linfa/dataset/mod.rs.html

Demonstrates how to iterate over the target columns of a dataset. Shows collecting targets into a vector and accessing target names.

```rust
let dataset = Dataset::new(
    array![[1., 2., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.]],
    array![[1, 2], [3, 4], [5, 6]],
)
.with_target_names(vec!["a", "b"]);

let res = dataset
    .target_iter()
    .map(|x| x.as_targets().remove_axis(Axis(1)).to_owned())
    .collect::<Vec<_>>();

assert_eq!(res, &[array![1, 3, 5], array![2, 4, 6]]);

let mut iter = dataset.target_iter();
let first = iter.next();
let second = iter.next();

assert_eq!(vec!["a"], first.unwrap().target_names());
assert_eq!(vec!["b"], second.unwrap().target_names());
```

--------------------------------

### Deprecated Description Method for Error

Source: https://docs.rs/linfa/latest/linfa/composing/platt_scaling/enum.PlattError.html

Deprecated method for getting a string description of the error. Use the `Display` implementation or `to_string()` instead.

```rust
fn description(&self) -> &str
```

--------------------------------

### K-Fold Cross-Validation on Datasets

Source: https://docs.rs/linfa/latest/src/linfa/dataset/mod.rs.html

Illustrates the usage of k-fold cross-validation on datasets. Shows how to split a dataset into multiple folds for training and validation, and verifies the dimensions of the resulting subsets.

```rust
let linspace: Array1<f64> = Array1::linspace(0.0, 0.8, 100);
let records = Array2::from_shape_vec((50, 2), linspace.to_vec()).unwrap();
let targets: Array1<f64> = Array1::linspace(0.0, 0.8, 50);
for (train, val) in DatasetView::from((records.view(), targets.view()))
    .fold(2)
    .into_iter() {
    assert_eq!(train.records().dim(), (25, 2));
    assert_eq!(val.records().dim(), (25, 2));
    assert_eq!(train.targets().dim(), 25);
    assert_eq!(val.targets().dim(), 25);
}
assert_eq!(Dataset::from((records, targets)).fold(10).len(), 10);
```

```rust
let records =
    Array2::from_shape_vec((5, 2), vec![1., 1., 2., 2., 3., 3., 4., 4., 5., 5.]).unwrap();
let targets = Array1::from_shape_vec(5, vec![1., 2., 3., 4., 5.]).unwrap();
for (i, (train, val)) in Dataset::from((records, targets))
    .fold(5)
    .into_iter()
    .enumerate() {
    assert_eq!(val.records.row(0)[0] as usize, (i + 1));
    assert_eq!(val.records.row(0)[1] as usize, (i + 1));
    assert_eq!(val.targets[0] as usize, (i + 1));

    for j in 0..4 {
        assert!(train.records.row(j)[0] as usize != (i + 1));
        assert!(train.records.row(j)[1] as usize != (i + 1));
        assert!(train.targets[j] as usize != (i + 1));
    }
}
```

--------------------------------

### Apply Bootstrapping to Dataset Samples and Features

Source: https://docs.rs/linfa/latest/linfa/dataset/type.Dataset.html

Generates bootstrapped datasets by sampling observations and features with replacement. This is useful for improving the accuracy and stability of machine learning algorithms. Requires specifying the desired number of samples and features, and a random number generator.

```rust
let mut rng = rand::thread_rng();
let bootstrapped_iter = dataset.bootstrap((100, 10), &mut rng);

for bootstrapped_dataset in bootstrapped_iter.take(1) {
    // Use the bootstrapped_dataset
    println!("Bootstrapped dataset shape: {:?}", bootstrapped_dataset.shape());
}
```

--------------------------------

### Bootstrap Dataset Samples and Features

Source: https://docs.rs/linfa/latest/src/linfa/dataset/impl_dataset.rs.html

Generates bootstrapped datasets by sampling with replacement for both samples and features. Useful for improving model accuracy and stability.

```rust
pub fn bootstrap<R: Rng>(
        &'b self,
        sample_feature_size: (usize, usize),
        rng: &'b mut R,
    ) -> impl Iterator<Item = DatasetBase<Array2<F>, T::Owned>> + 'b {
        std::iter::repeat(()).map(move |_| {
            // sample with replacement
            let indices = (0..sample_feature_size.0)
                .map(|_| rng.gen_range(0..self.nsamples()))
                .collect::<Vec<_>>();

            let records = self.records().select(Axis(0), &indices);
            let targets = T::new_targets(self.as_targets().select(Axis(0), &indices));

            let indices = (0..sample_feature_size.1)
                .map(|_| rng.gen_range(0..self.nfeatures()))
                .collect::<Vec<_>>();

            let records = records.select(Axis(1), &indices);

            DatasetBase::new(records, targets)
        })
    }
```

--------------------------------

### Get Number of Targets

Source: https://docs.rs/linfa/latest/src/linfa/dataset/impl_dataset.rs.html

Returns the total number of targets present in the dataset. For multi-dimensional targets, it returns the size along the second axis.

```rust
pub fn ntargets(&self) -> usize {
        if T::Ix::NDIM.unwrap() == 1 {
            1
        } else {
            self.targets.as_targets().len_of(Axis(1))
        }
    }
```

--------------------------------

### Clone Implementation

Source: https://docs.rs/linfa/latest/linfa/dataset/struct.DatasetBase.html

Allows for cloning DatasetBase instances.

```APIDOC
## impl<R, T: Clone> Clone for DatasetBase<R, T>
where R: Records + Clone,

### Methods
- `clone(&self) -> DatasetBase<R, T>`: Returns a duplicate of the value.
- `clone_from(&mut self, source: &Self)`: Performs copy-assignment from `source`.
```

--------------------------------

### Get optional weights

Source: https://docs.rs/linfa/latest/src/linfa/dataset/impl_dataset.rs.html

Returns a slice of weights if they are present and not empty, otherwise returns None. Weights are used to assign importance to observations.

```rust
pub fn weights(&self) -> Option<&[f32]> {
        if !self.weights.is_empty() {
            Some(self.weights.as_slice().unwrap())
        } else {
            None
        }
    }
```

--------------------------------

### Get Label Frequencies with Mask

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetPr.html

Calculates label frequencies from a dataset while masking certain samples. The mask specifies which samples to include in the count.

```Rust
let frequencies = dataset.label_frequencies_with_mask(&mask);
```

--------------------------------

### Iterating Over Dataset Samples

Source: https://docs.rs/linfa/latest/src/linfa/dataset/mod.rs.html

Demonstrates iterating over individual samples (records and targets) within a dataset. Each iteration yields a tuple containing the record and target arrays for a single sample.

```rust
let dataset = Dataset::new(
    array![[1., 2., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.]],
    array![[1, 2], [3, 4], [5, 6]],
)
.with_target_names(vec!["a", "b"]);

let res = dataset
    .sample_iter()
    .map(|(a, b)| (a.to_owned(), b.to_owned()))
    .collect::<Vec<_>>();

assert_eq!(
    res,
    &[
        (array![1., 2., 3., 4.], array![1, 2]),
        (array![5., 6., 7., 8.], array![3, 4]),
        (array![9., 10., 11., 12.], array![5, 6]),
    ]
);
```

--------------------------------

### Calculate Recall using ConfusionMatrix

Source: https://docs.rs/linfa/latest/linfa/metrics/struct.ConfusionMatrix.html

Shows how to generate a ConfusionMatrix and compute the recall score for label 0. Make sure to include the required imports.

```rust
use linfa::prelude::*
use ndarray::array;

// create dummy classes 0 and 1
let prediction = array![0, 1, 1, 1, 0, 0, 1];
let ground_truth = array![0, 0, 1, 0, 1, 0, 1];

// create confusion matrix
let cm = prediction.confusion_matrix(&ground_truth).unwrap();

// print recall for label 0
println!("{:?}", cm.recall());
```

--------------------------------

### Deprecated Cause Method for Error

Source: https://docs.rs/linfa/latest/linfa/composing/platt_scaling/enum.PlattError.html

Deprecated method for getting the underlying cause of the error. Use `Error::source` for more robust error handling.

```rust
fn cause(&self) -> Option<&dyn Error>
```

--------------------------------

### DummyModel2 Implementation for Testing

Source: https://docs.rs/linfa/latest/src/linfa/composing/multi_target_model.rs.html

A second dummy model that generates predictions counting up from a starting value. Used in conjunction with `DummyModel` to test `MultiTargetModel`.

```rust
impl PredictInplace<Array2<f32>, Array1<f32>> for DummyModel2 {
    fn predict_inplace(&self, arr: &Array2<f32>, targets: &mut Array1<f32>) {
        assert_eq!(
            arr.nrows(),
            targets.len(),
            "The number of data points must match the number of output targets."
        );
        *targets = Array1::linspace(
            self.val,
            self.val + arr.len_of(Axis(0)) as f32 - 1.0,
            arr.len_of(Axis(0)),
        );
    }
}
```

--------------------------------

### Predict Targets with Reference to Dataset

Source: https://docs.rs/linfa/latest/src/linfa/traits.rs.html

Demonstrates how to predict targets using a model with a reference to a dataset, resulting in an array of predictions.

```rust
let pred_targets = model.predict(&dataset);
```

--------------------------------

### Handling File Metadata Operations

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Illustrates using `and_then` with file system operations to handle potential errors during metadata retrieval.

```APIDOC
## File Metadata Example

### Description
This example shows how to use `and_then` to chain operations when retrieving file metadata, handling potential errors like file not found.

### Code
```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```
```

--------------------------------

### Unwrap Error Value

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Use `unwrap_err` to get the `Err` value. This method will panic if the `Result` is an `Ok`, using the `Ok` value in the panic message.

```rust
let x: Result<u32, &str> = Ok(2);
x.unwrap_err(); // panics with `2`
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(x.unwrap_err(), "emergency failure");
```

--------------------------------

### into_ok

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Returns the contained `Ok` value, but never panics. This is an experimental API.

```APIDOC
## pub const fn into_ok(self) -> T

### Description
Returns the contained `Ok` value, but never panics. Unlike `unwrap`, this method is known to never panic on the result types it is implemented for. Therefore, it can be used instead of `unwrap` as a maintainability safeguard that will fail to compile if the error type of the `Result` is later changed to an error that can actually occur.

### Method
(Implicitly called on a Result instance)

### Parameters
None

### Response
- T: The contained Ok value.

### Note
This is a nightly-only experimental API.

### Examples
```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```
```

--------------------------------

### Get ROC Curve Points

Source: https://docs.rs/linfa/latest/linfa/metrics/struct.ReceiverOperatingCharacteristic.html

Retrieves the points that form the Receiver Operating Characteristic curve. Each point is a tuple of (false-positive rate, true-positive rate).

```rust
pub fn get_curve(&self) -> Vec<(f32, f32)>
```

--------------------------------

### bootstrap

Source: https://docs.rs/linfa/latest/linfa/dataset/struct.DatasetBase.html

Applies bootstrapping to generate sub-samples of data with replacement for both samples and features. This method returns an iterator yielding bootstrapped datasets.

```APIDOC
## pub fn bootstrap<R: Rng>( &'b self, sample_feature_size: (usize, usize), rng: &'b mut R, ) -> impl Iterator<Item = DatasetBase<Array2<F>, T::Owned>> + 'b

### Description
Apply bootstrapping for samples and features. Bootstrap aggregating is used for sub-sample generation and improves the accuracy and stability of machine learning algorithms. It samples data uniformly with replacement and generates datasets where elements may be shared. This selects a subset of observations as well as features.

### Parameters
  * `sample_feature_size`: The number of samples and features per bootstrap
  * `rng`: The random number generator used in the sampling procedure

### Returns
An infinite Iterator yielding at each step a new bootstrapped dataset
```

--------------------------------

### Expect Error Value

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Use `expect_err` to get the `Err` value. This method will panic if the `Result` is an `Ok`, providing a custom message along with the `Ok` value.

```rust
let x: Result<u32, &str> = Ok(10);
x.expect_err("Testing expect_err"); // panics with `Testing expect_err: 10`
```

--------------------------------

### Dataset::new

Source: https://docs.rs/linfa/latest/linfa/dataset/type.Dataset.html

Creates a new dataset from provided records and targets.

```APIDOC
## Dataset::new

### Description
Create a new dataset from records and targets

### Method
`new(records: R, targets: S) -> DatasetBase<R, S>`

### Parameters
* `records`: The records for the dataset.
* `targets`: The targets for the dataset.

### Example
```rust
let dataset = Dataset::new(records, targets);
```
```

--------------------------------

### Get ROC Curve Thresholds

Source: https://docs.rs/linfa/latest/linfa/metrics/struct.ReceiverOperatingCharacteristic.html

Retrieves the classification thresholds corresponding to each point on the ROC curve. This helps in understanding the decision boundaries at different sensitivity levels.

```rust
pub fn get_thresholds(&self) -> Vec<f32>
```

--------------------------------

### Unwrap or Default Value

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Use `unwrap_or_default` to get the `Ok` value or a default value if the `Result` is an `Err`. This is useful for providing fallback values when an operation might fail.

```rust
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);
```

--------------------------------

### Bootstrap Dataset Samples with Indices

Source: https://docs.rs/linfa/latest/src/linfa/dataset/mod.rs.html

Creates an iterator that yields bootstrap samples along with their original data and feature indices. Each sample has a specified number of records.

```rust
let mut iter = dataset.bootstrap_with_indices((10, 10), &mut rng);
for _ in 1..5 {
    let (dataset, data_indices, feat_indices) = iter.next().unwrap();
    assert_eq!(dataset.records().dim(), (10, 10));
    assert_eq!(data_indices.len(), 10);
    assert_eq!(feat_indices.len(), 10);
}
```

--------------------------------

### Confusion Matrix Metrics Calculation

Source: https://docs.rs/linfa/latest/src/linfa/metrics_classification.rs.html

Calculates various metrics like accuracy, MCC, precision, recall, and F1-score from a confusion matrix. Use this to get a comprehensive performance overview.

```rust
use linfa::metrics::ToConfusionMatrix;
use ndarray::{array, Array1};
use approx::assert_abs_diff_eq;

let ground_truth = Array1::from(vec![1, 1, 0, 1, 0, 1]);
let predicted = Array1::from(vec![0, 1, 0, 1, 0, 1]);

let x = predicted.confusion_matrix(ground_truth).unwrap();

let labels = array![0, 1];

assert_abs_diff_eq!(x.accuracy(), 5.0 / 6.0_f32);
assert_abs_diff_eq!(
    x.mcc(),
    (2. * 3. - 1. * 0.) / (2.0f32 * 3. * 3. * 4.).sqrt()
);

// Precision, Recall, F1-score are calculated using assert_split_eq in the full example
```

--------------------------------

### From Trait Implementation

Source: https://docs.rs/linfa/latest/linfa/dataset/struct.CountedTargets.html

Enables creation from an equivalent type.

```APIDOC
### impl<T> From<T> for T

#### fn from(t: T) -> T
Returns the argument unchanged.
```

--------------------------------

### bootstrap_samples

Source: https://docs.rs/linfa/latest/linfa/dataset/type.Dataset.html

Applies sample bootstrapping to generate sub-samples with replacement. This method improves the accuracy and stability of machine learning algorithms by creating datasets where elements may be shared, retaining all features and targets.

```APIDOC
## bootstrap_samples<R: Rng>

### Description
Apply sample bootstrapping. Bootstrap aggregating is used for sub-sample generation and improves the accuracy and stability of machine learning algorithms. It samples data uniformly with replacement and generates datasets where elements may be shared. Only a sample subset is selected which retains all features and targets.

### Parameters
- **num_samples** (usize) - The number of samples per bootstrap
- **rng** (R: Rng) - The random number generator used in the sampling procedure

### Returns
An infinite Iterator yielding at each step a new bootstrapped dataset
```

--------------------------------

### Unwrap Result Value

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Use `unwrap` to get the `Ok` value. This method will panic if the `Result` is an `Err`. It's generally discouraged in favor of safer error handling methods.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // panics with `emergency failure`
```

--------------------------------

### bootstrap_samples

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetPr.html

Applies bootstrapping specifically to samples, retaining all features. This method is useful when you want to create diverse subsets of your data points while keeping all original features.

```APIDOC
## bootstrap_samples<R: Rng>

### Description
Apply sample bootstrapping. Bootstrap aggregating is used for sub-sample generation and improves the accuracy and stability of machine learning algorithms. It samples data uniformly with replacement and generates datasets where elements may be shared. Only a sample subset is selected which retains all features and targets.

### Method
`bootstrap_samples`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* `num_samples`: The number of samples per bootstrap
* `rng`: The random number generator used in the sampling procedure

### Returns
An infinite Iterator yielding at each step a new bootstrapped dataset
```

--------------------------------

### Iterating Over Result Ok Value

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Use `iter` to get an iterator that yields a reference to the success value if the Result is Ok, otherwise yields nothing. This is useful for treating a Result as an optional collection.

```Rust
let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));

let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);
```

--------------------------------

### Get mutable references to Result contents with as_mut()

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Use `as_mut()` to convert a `&mut Result<T, E>` into a `Result<&mut T, &mut E>`. This allows mutable borrowing of the contents, enabling in-place modification.

```Rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

--------------------------------

### Platt Parameters Creation

Source: https://docs.rs/linfa/latest/linfa/composing/platt_scaling/struct.Platt.html

Creates a default parameter set for the Platt scaling algorithm. Default values for maxiter, minstep, and sigma are provided.

```rust
pub fn params() -> PlattParams<F, O>
Create default parameter set for the Platt scaling algorithm
The default values are:
  * `maxiter`: 100,
  * `minstep`: 1e-10,
  * `sigma`: 1e-12
```

--------------------------------

### Transformer Trait

Source: https://docs.rs/linfa/latest/src/linfa/traits.rs.html

The Transformer trait is implemented for algorithms that take a dataset and transform it into a different one. These transformers have no concept of state and do not provide methods for predicting new data. A typical example would be kernel methods.

```APIDOC
## Transformer Trait

### Description

Represents algorithms that transform a dataset into another dataset without maintaining state or predicting new data. Suitable for stateless transformations like kernel methods.

### Methods

- `transform(&self, x: R) -> T`: Takes a dataset `x` and returns a transformed dataset `T`.
```

--------------------------------

### Bootstrap dataset with sample and feature selection

Source: https://docs.rs/linfa/latest/linfa/dataset/struct.DatasetBase.html

Applies bootstrapping to generate new datasets by sampling observations and features with replacement. This is useful for improving model accuracy and stability.

```rust
let bootstrapped_iter = dataset.bootstrap((100, 50), &mut rng);
```

--------------------------------

### Mutably Iterating Over Result Ok Value

Source: https://docs.rs/linfa/latest/linfa/error/type.Result.html

Use `iter_mut` to get a mutable iterator that yields a mutable reference to the success value if the Result is Ok, otherwise yields nothing. This allows in-place modification of the success value.

```Rust
let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
    Some(v) => *v = 40,
    None => {},
}
assert_eq!(x, Ok(40));

let mut x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter_mut().next(), None);
```

--------------------------------

### view

Source: https://docs.rs/linfa/latest/linfa/dataset/type.DatasetPr.html

Creates a view of the dataset. This allows for borrowing parts of the dataset without copying.

```APIDOC
## view

### Description
Creates a view of a dataset

### Method
`view(&'a self) -> DatasetBase<ArrayView2<'a, F>, T::View>`
```
Tokens:
Raw