Struct TaskClusteringRegularization 

pub struct TaskClusteringRegularization<S = Untrained> { /* private fields */ }

Task Clustering Regularization for Multi-Task Learning

This method clusters tasks based on their similarity and applies different regularization strengths within and across clusters. Tasks in the same cluster are encouraged to have similar parameters, while tasks in different clusters are allowed to be more different.

Examples

use sklears_multioutput::regularization::TaskClusteringRegularization;
use sklears_core::traits::{Predict, Fit};
// Use SciRS2-Core for arrays and random number generation (SciRS2 Policy)
use scirs2_core::ndarray::array;
use std::collections::HashMap;

let X = array![[1.0, 2.0], [2.0, 3.0], [3.0, 1.0], [4.0, 4.0]];
let mut y_tasks = HashMap::new();
y_tasks.insert("task1".to_string(), array![[1.0], [2.0], [1.5], [2.5]]);
y_tasks.insert("task2".to_string(), array![[0.5], [1.0], [0.8], [1.2]]);
y_tasks.insert("task3".to_string(), array![[2.0], [3.0], [2.2], [3.1]]);

let task_clustering = TaskClusteringRegularization::new()
    .n_clusters(2)
    .intra_cluster_alpha(0.1)  // Strong regularization within clusters
    .inter_cluster_alpha(0.01) // Weak regularization across clusters
    .max_iter(1000);

Implementations

impl TaskClusteringRegularization<Untrained>

pub fn new() -> Self

Create a new TaskClusteringRegularization instance

pub fn n_clusters(self, n_clusters: usize) -> Self

Set number of task clusters

pub fn intra_cluster_alpha(self, alpha: Float) -> Self

Set intra-cluster regularization strength

pub fn inter_cluster_alpha(self, alpha: Float) -> Self

Set inter-cluster regularization strength

pub fn max_iter(self, max_iter: usize) -> Self

Set maximum iterations

pub fn tolerance(self, tolerance: Float) -> Self

Set tolerance

pub fn learning_rate(self, lr: Float) -> Self

Set learning rate

pub fn random_state(self, seed: u64) -> Self

Set random state for reproducible clustering

pub fn task_outputs(self, outputs: &[(&str, usize)]) -> Self

Set task outputs

Trait Implementations

impl<S: Clone> Clone for TaskClusteringRegularization<S>

fn clone(&self) -> TaskClusteringRegularization<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug> Debug for TaskClusteringRegularization<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TaskClusteringRegularization<Untrained>

fn default() -> Self

Returns the “default value” for a type.

impl Estimator for TaskClusteringRegularization<Untrained>

type Config = ()

Configuration type for the estimator

type Error = SklearsError

Error type for the estimator

type Float = f64

The numeric type used by this estimator

fn config(&self) -> &Self::Config

Get estimator configuration

fn validate_config(&self) -> Result<(), SklearsError>

Validate estimator configuration with detailed error context

fn check_compatibility( &self, n_samples: usize, n_features: usize, ) -> Result<(), SklearsError>

Check if estimator is compatible with given data dimensions

fn metadata(&self) -> EstimatorMetadata

Get estimator metadata

impl Fit<ArrayBase<ViewRepr<&f64>, Dim<[usize; 2]>>, HashMap<String, ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>> for TaskClusteringRegularization<Untrained>

type Fitted = TaskClusteringRegularization<TaskClusteringRegressionTrained>

The fitted model type

fn fit( self, X: &ArrayView2<'_, Float>, y: &HashMap<String, Array2<Float>>, ) -> SklResult<Self::Fitted>

Fit the model to the provided data with validation

fn fit_with_validation( self, x: &X, y: &Y, _x_val: Option<&X>, _y_val: Option<&Y>, ) -> Result<(Self::Fitted, FitMetrics), SklearsError>

where Self: Sized,

Fit with custom validation and early stopping

impl Predict<ArrayBase<ViewRepr<&f64>, Dim<[usize; 2]>>, HashMap<String, ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>> for TaskClusteringRegularization<TaskClusteringRegressionTrained>

fn predict( &self, X: &ArrayView2<'_, Float>, ) -> SklResult<HashMap<String, Array2<Float>>>

Make predictions on the provided data

fn predict_with_uncertainty( &self, x: &X, ) -> Result<(Output, UncertaintyMeasure), SklearsError>

Make predictions with confidence intervals