Struct FeatureFusion

pub struct FeatureFusion<F: Float + Debug + ScalarOperand + Send + Sync> {
    pub aligners: Vec<FeatureAlignment<F>>,
    pub fusion_module: Option<Box<dyn Layer<F> + Send + Sync>>,
    pub post_fusion: Sequential<F>,
    pub classifier: Option<Dense<F>>,
    pub config: FeatureFusionConfig,
}

Feature Fusion model

Fields

aligners: Vec<FeatureAlignment<F>>

Feature aligners for each input modality

fusion_module: Option<Box<dyn Layer<F> + Send + Sync>>

Fusion-specific modules

post_fusion: Sequential<F>

Post-fusion MLP

classifier: Option<Dense<F>>

Classifier head

config: FeatureFusionConfig

Model configuration

Implementations

impl<F: Float + Debug + ScalarOperand + Send + Sync> FeatureFusion<F>

pub fn new(config: FeatureFusionConfig) -> Result<Self>

Create a new FeatureFusion model

pub fn forward_multi( &self, inputs: &[Array<F, IxDyn>], ) -> Result<Array<F, IxDyn>>

Forward pass with multiple input modalities

pub fn create_early_fusion( dim_a: usize, dim_b: usize, hidden_dim: usize, num_classes: usize, include_head: bool, ) -> Result<Self>

Create a simple early fusion model for two modalities

pub fn create_attention_fusion( dim_a: usize, dim_b: usize, hidden_dim: usize, num_classes: usize, include_head: bool, ) -> Result<Self>

Create an attention-based fusion model for two modalities

pub fn create_film_fusion( dim_a: usize, dim_b: usize, hidden_dim: usize, num_classes: usize, include_head: bool, ) -> Result<Self>

Create a FiLM conditioning fusion model (B conditions A)

Trait Implementations

impl<F: Float + Debug + ScalarOperand + Send + Sync> Clone for FeatureFusion<F>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Float + Debug + ScalarOperand + Send + Sync> Debug for FeatureFusion<F>

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

Formats the value using the given formatter.

impl<F: Float + Debug + ScalarOperand + Send + Sync> Layer<F> for FeatureFusion<F>

fn forward(&self, _input: &Array<F, IxDyn>) -> Result<Array<F, IxDyn>>

Forward pass of the layer

fn backward( &self, _input: &Array<F, IxDyn>, _grad_output: &Array<F, IxDyn>, ) -> Result<Array<F, IxDyn>>

Backward pass of the layer to compute gradients

fn update(&mut self, _learning_rate: F) -> Result<()>

Update the layer parameters with the given gradients

fn params(&self) -> Vec<Array<F, IxDyn>>

Get the parameters of the layer

fn set_training(&mut self, training: bool)

Set the layer to training mode (true) or evaluation mode (false)

fn is_training(&self) -> bool

Get the current training mode

fn as_any(&self) -> &dyn Any

Get the layer as a dyn Any for downcasting

fn as_any_mut(&mut self) -> &mut dyn Any

Get the layer as a mutable dyn Any for downcasting

fn gradients(&self) -> Vec<Array<F, IxDyn>>

Get the gradients of the layer parameters

fn set_gradients(&mut self, _gradients: &[Array<F, IxDyn>]) -> Result<()>

Set the gradients of the layer parameters

fn set_params(&mut self, _params: &[Array<F, IxDyn>]) -> Result<()>

Set the parameters of the layer

fn layer_type(&self) -> &str

Get the type of the layer (e.g., “Dense”, “Conv2D”)

fn parameter_count(&self) -> usize

Get the number of trainable parameters in this layer

fn layer_description(&self) -> String

Get a detailed description of this layer