Trait AlgorithmPlugin 

pub trait AlgorithmPlugin<X, Y, Output>:
    Plugin
    + Send
    + Sync {
    type Fitted: Predict<X, Output> + Send + Sync;

    // Required methods
    fn fit(&self, x: &X, y: &Y) -> Result<Self::Fitted>;
    fn predict(&self, fitted: &Self::Fitted, x: &X) -> Result<Output>;
    fn get_parameters(&self) -> HashMap<String, PluginParameter>;
    fn set_parameters(
        &mut self,
        params: HashMap<String, PluginParameter>,
    ) -> Result<()>;
}

Trait for algorithm plugins that can fit and predict

This trait defines the interface for machine learning algorithms that follow the fit/predict pattern. It extends the base Plugin trait with algorithm-specific functionality.

Type Parameters

• X - The input feature type (e.g., Array2<f64>)
• Y - The target/label type (e.g., Array1<f64>)
• Output - The prediction output type

Examples

use sklears_core::plugin::{Plugin, AlgorithmPlugin, PluginParameter};
use sklears_core::traits::Predict;
use sklears_core::error::Result;
use std::collections::HashMap;

#[derive(Debug)]
struct LinearRegression {
    // algorithm parameters
}

struct FittedLinearRegression {
    // fitted model state
}

impl Predict<Vec<f64>, Vec<f64>> for FittedLinearRegression {
    fn predict(&self, x: &Vec<f64>) -> Result<Vec<f64>> {
        // prediction implementation
        Ok(x.clone())
    }
}

impl AlgorithmPlugin<Vec<f64>, Vec<f64>, Vec<f64>> for LinearRegression {
    type Fitted = FittedLinearRegression;

    fn fit(&self, x: &Vec<f64>, y: &Vec<f64>) -> Result<Self::Fitted> {
        Ok(FittedLinearRegression {})
    }

    fn predict(&self, fitted: &Self::Fitted, x: &Vec<f64>) -> Result<Vec<f64>> {
        fitted.predict(x)
    }

    fn get_parameters(&self) -> HashMap<String, PluginParameter> {
        HashMap::new()
    }

    fn set_parameters(&mut self, _params: HashMap<String, PluginParameter>) -> Result<()> {
        Ok(())
    }
}

Required Associated Types

type Fitted: Predict<X, Output> + Send + Sync

The fitted model type

This type represents the state of the algorithm after training. It must implement the Predict trait to enable predictions.

Required Methods

fn fit(&self, x: &X, y: &Y) -> Result<Self::Fitted>

Fit the algorithm to training data

This method trains the algorithm on the provided data and returns a fitted model that can be used for predictions.

Arguments

• x - Training features
• y - Training targets/labels

Returns

A fitted model instance or an error if training fails.

fn predict(&self, fitted: &Self::Fitted, x: &X) -> Result<Output>

Make predictions using the fitted model

This method uses the fitted model to make predictions on new data.

Arguments

• fitted - The fitted model from the fit method
• x - Input features for prediction

Returns

Predictions or an error if prediction fails.

fn get_parameters(&self) -> HashMap<String, PluginParameter>

Get algorithm-specific parameters

Returns a map of all configurable parameters for this algorithm. This enables introspection and parameter tuning.

fn set_parameters( &mut self, params: HashMap<String, PluginParameter>, ) -> Result<()>

Set algorithm-specific parameters

Allows updating the algorithm’s parameters. The algorithm should validate that the provided parameters are valid.

Arguments

• params - Map of parameter names to values

Returns

Ok(()) if parameters were set successfully, or an error if any parameter is invalid.

Implementors