Struct PrototypicalNetworks 

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

Prototypical Networks for Few-Shot Learning

Prototypical Networks learn a metric space where classification can be performed by computing distances to prototype representations of each class. The prototypes are the mean of the support examples for each class in an embedding space.

The method is particularly effective for few-shot learning scenarios where only a few labeled examples are available per class.

Parameters

• embedding_dim - Dimensionality of the embedding space
• hidden_layers - Hidden layer dimensions for the embedding network
• distance_metric - Distance metric to use (‘euclidean’, ‘cosine’, ‘manhattan’)
• learning_rate - Learning rate for embedding network training
• n_episodes - Number of training episodes
• n_way - Number of classes per episode
• n_shot - Number of support examples per class
• n_query - Number of query examples per class

Examples

use sklears_semi_supervised::PrototypicalNetworks;
use sklears_core::traits::{Predict, Fit};


let X = array![
    [1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0],
    [1.1, 2.1], [2.1, 3.1], [3.1, 4.1], [4.1, 5.1]
];
let y = array![0, 1, 0, 1, 0, 1, 0, 1];

let proto_net = PrototypicalNetworks::new()
    .embedding_dim(32)
    .n_way(2)
    .n_shot(1)
    .n_query(3);
let fitted = proto_net.fit(&X.view(), &y.view()).unwrap();
let predictions = fitted.predict(&X.view()).unwrap();

Implementations

impl PrototypicalNetworks<Untrained>

pub fn new() -> Self

Create a new PrototypicalNetworks instance

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

Set the embedding dimensionality

pub fn hidden_layers(self, hidden_layers: Vec<usize>) -> Self

Set the hidden layer dimensions

pub fn distance_metric(self, metric: String) -> Self

Set the distance metric

pub fn learning_rate(self, learning_rate: f64) -> Self

Set the learning rate

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

Set the number of training episodes

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

Set the number of classes per episode (N-way)

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

Set the number of support examples per class (N-shot)

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

Set the number of query examples per class

pub fn temperature(self, temperature: f64) -> Self

Set the temperature parameter for softmax

Trait Implementations

impl<S: Clone> Clone for PrototypicalNetworks<S>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for PrototypicalNetworks<S>

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

Formats the value using the given formatter.

impl Default for PrototypicalNetworks<Untrained>

fn default() -> Self

Returns the “default value” for a type.

impl Estimator for PrototypicalNetworks<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]>>, ArrayBase<ViewRepr<&i32>, Dim<[usize; 1]>>> for PrototypicalNetworks<Untrained>

type Fitted = PrototypicalNetworks<PrototypicalNetworksTrained>

The fitted model type

fn fit( self, X: &ArrayView2<'_, Float>, y: &ArrayView1<'_, i32>, ) -> 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]>>, ArrayBase<OwnedRepr<i32>, Dim<[usize; 1]>>> for PrototypicalNetworks<PrototypicalNetworksTrained>

fn predict(&self, X: &ArrayView2<'_, Float>) -> SklResult<Array1<i32>>

Make predictions on the provided data

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

Make predictions with confidence intervals

impl PredictProba<ArrayBase<ViewRepr<&f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>> for PrototypicalNetworks<PrototypicalNetworksTrained>

fn predict_proba(&self, X: &ArrayView2<'_, Float>) -> SklResult<Array2<f64>>

Predict class probabilities