Struct EfficientNet

pub struct EfficientNet<F: Float + Debug + ScalarOperand + Send + Sync> { /* private fields */ }

EfficientNet implementation

Implementations

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

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

Create a new EfficientNet model

Examples found in repository

examples/efficientnet_example.rs (line 64)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("EfficientNet Example");

    // Create EfficientNet-B0 model for image classification
    let input_channels = 3; // RGB images
    let num_classes = 1000; // ImageNet classes

    println!(
        "Creating EfficientNet-B0 model with {} input channels and {} output classes",
        input_channels, num_classes
    );

    // Create model
    let model = EfficientNet::<f32>::efficientnet_b0(input_channels, num_classes)?;

    // Create dummy input (batch_size=1, channels=3, height=224, width=224)
    let input = Array::from_shape_fn(IxDyn(&[1, input_channels, 224, 224]), |_| {
        rand::random::<f32>()
    });

    println!("Input shape: {:?}", input.shape());

    // Forward pass
    let output = model.forward(&input)?;

    println!("Output shape: {:?}", output.shape());
    println!("Output contains logits for {} classes", output.shape()[1]);

    // Create EfficientNet-B3 model (larger model)
    println!("\nCreating EfficientNet-B3 model...");

    let model_b3 = EfficientNet::<f32>::efficientnet_b3(input_channels, num_classes)?;

    // Create dummy input with higher resolution for B3 (300x300)
    let input_b3 = Array::from_shape_fn(IxDyn(&[1, input_channels, 300, 300]), |_| {
        rand::random::<f32>()
    });

    println!("Input shape for B3: {:?}", input_b3.shape());

    // Forward pass
    let output_b3 = model_b3.forward(&input_b3)?;

    println!("Output shape for B3: {:?}", output_b3.shape());

    // Create a custom EfficientNet model for smaller images
    println!("\nCreating a custom EfficientNet model for smaller images...");

    // Create simplified config with fewer stages
    let mut custom_config = EfficientNetConfig::efficientnet_b0(input_channels, 10); // 10 classes

    // Simplify by keeping only first 4 stages
    custom_config.stages.truncate(4);

    // Scale down the model
    custom_config.width_coefficient = 0.5;
    custom_config.depth_coefficient = 0.5;
    custom_config.resolution = 32; // For CIFAR-10 size images

    let custom_model = EfficientNet::<f32>::new(custom_config)?;

    // Create dummy input for small images (32x32)
    let small_input = Array::from_shape_fn(IxDyn(&[1, input_channels, 32, 32]), |_| {
        rand::random::<f32>()
    });

    println!("Custom input shape: {:?}", small_input.shape());

    // Forward pass
    let custom_output = custom_model.forward(&small_input)?;

    println!("Custom output shape: {:?}", custom_output.shape());
    println!(
        "Custom model produces logits for {} classes",
        custom_output.shape()[1]
    );

    println!("\nEfficientNet example completed successfully!");

    Ok(())
}

pub fn efficientnet_b0( input_channels: usize, num_classes: usize, ) -> Result<Self>

Create EfficientNet-B0 model

Examples found in repository

examples/efficientnet_example.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("EfficientNet Example");

    // Create EfficientNet-B0 model for image classification
    let input_channels = 3; // RGB images
    let num_classes = 1000; // ImageNet classes

    println!(
        "Creating EfficientNet-B0 model with {} input channels and {} output classes",
        input_channels, num_classes
    );

    // Create model
    let model = EfficientNet::<f32>::efficientnet_b0(input_channels, num_classes)?;

    // Create dummy input (batch_size=1, channels=3, height=224, width=224)
    let input = Array::from_shape_fn(IxDyn(&[1, input_channels, 224, 224]), |_| {
        rand::random::<f32>()
    });

    println!("Input shape: {:?}", input.shape());

    // Forward pass
    let output = model.forward(&input)?;

    println!("Output shape: {:?}", output.shape());
    println!("Output contains logits for {} classes", output.shape()[1]);

    // Create EfficientNet-B3 model (larger model)
    println!("\nCreating EfficientNet-B3 model...");

    let model_b3 = EfficientNet::<f32>::efficientnet_b3(input_channels, num_classes)?;

    // Create dummy input with higher resolution for B3 (300x300)
    let input_b3 = Array::from_shape_fn(IxDyn(&[1, input_channels, 300, 300]), |_| {
        rand::random::<f32>()
    });

    println!("Input shape for B3: {:?}", input_b3.shape());

    // Forward pass
    let output_b3 = model_b3.forward(&input_b3)?;

    println!("Output shape for B3: {:?}", output_b3.shape());

    // Create a custom EfficientNet model for smaller images
    println!("\nCreating a custom EfficientNet model for smaller images...");

    // Create simplified config with fewer stages
    let mut custom_config = EfficientNetConfig::efficientnet_b0(input_channels, 10); // 10 classes

    // Simplify by keeping only first 4 stages
    custom_config.stages.truncate(4);

    // Scale down the model
    custom_config.width_coefficient = 0.5;
    custom_config.depth_coefficient = 0.5;
    custom_config.resolution = 32; // For CIFAR-10 size images

    let custom_model = EfficientNet::<f32>::new(custom_config)?;

    // Create dummy input for small images (32x32)
    let small_input = Array::from_shape_fn(IxDyn(&[1, input_channels, 32, 32]), |_| {
        rand::random::<f32>()
    });

    println!("Custom input shape: {:?}", small_input.shape());

    // Forward pass
    let custom_output = custom_model.forward(&small_input)?;

    println!("Custom output shape: {:?}", custom_output.shape());
    println!(
        "Custom model produces logits for {} classes",
        custom_output.shape()[1]
    );

    println!("\nEfficientNet example completed successfully!");

    Ok(())
}

pub fn efficientnet_b1( input_channels: usize, num_classes: usize, ) -> Result<Self>

Create EfficientNet-B1 model

pub fn efficientnet_b2( input_channels: usize, num_classes: usize, ) -> Result<Self>

Create EfficientNet-B2 model

pub fn efficientnet_b3( input_channels: usize, num_classes: usize, ) -> Result<Self>

Create EfficientNet-B3 model

Examples found in repository

examples/efficientnet_example.rs (line 36)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("EfficientNet Example");

    // Create EfficientNet-B0 model for image classification
    let input_channels = 3; // RGB images
    let num_classes = 1000; // ImageNet classes

    println!(
        "Creating EfficientNet-B0 model with {} input channels and {} output classes",
        input_channels, num_classes
    );

    // Create model
    let model = EfficientNet::<f32>::efficientnet_b0(input_channels, num_classes)?;

    // Create dummy input (batch_size=1, channels=3, height=224, width=224)
    let input = Array::from_shape_fn(IxDyn(&[1, input_channels, 224, 224]), |_| {
        rand::random::<f32>()
    });

    println!("Input shape: {:?}", input.shape());

    // Forward pass
    let output = model.forward(&input)?;

    println!("Output shape: {:?}", output.shape());
    println!("Output contains logits for {} classes", output.shape()[1]);

    // Create EfficientNet-B3 model (larger model)
    println!("\nCreating EfficientNet-B3 model...");

    let model_b3 = EfficientNet::<f32>::efficientnet_b3(input_channels, num_classes)?;

    // Create dummy input with higher resolution for B3 (300x300)
    let input_b3 = Array::from_shape_fn(IxDyn(&[1, input_channels, 300, 300]), |_| {
        rand::random::<f32>()
    });

    println!("Input shape for B3: {:?}", input_b3.shape());

    // Forward pass
    let output_b3 = model_b3.forward(&input_b3)?;

    println!("Output shape for B3: {:?}", output_b3.shape());

    // Create a custom EfficientNet model for smaller images
    println!("\nCreating a custom EfficientNet model for smaller images...");

    // Create simplified config with fewer stages
    let mut custom_config = EfficientNetConfig::efficientnet_b0(input_channels, 10); // 10 classes

    // Simplify by keeping only first 4 stages
    custom_config.stages.truncate(4);

    // Scale down the model
    custom_config.width_coefficient = 0.5;
    custom_config.depth_coefficient = 0.5;
    custom_config.resolution = 32; // For CIFAR-10 size images

    let custom_model = EfficientNet::<f32>::new(custom_config)?;

    // Create dummy input for small images (32x32)
    let small_input = Array::from_shape_fn(IxDyn(&[1, input_channels, 32, 32]), |_| {
        rand::random::<f32>()
    });

    println!("Custom input shape: {:?}", small_input.shape());

    // Forward pass
    let custom_output = custom_model.forward(&small_input)?;

    println!("Custom output shape: {:?}", custom_output.shape());
    println!(
        "Custom model produces logits for {} classes",
        custom_output.shape()[1]
    );

    println!("\nEfficientNet example completed successfully!");

    Ok(())
}

pub fn efficientnet_b4( input_channels: usize, num_classes: usize, ) -> Result<Self>

Create EfficientNet-B4 model

pub fn efficientnet_b5( input_channels: usize, num_classes: usize, ) -> Result<Self>

Create EfficientNet-B5 model

pub fn efficientnet_b6( input_channels: usize, num_classes: usize, ) -> Result<Self>

Create EfficientNet-B6 model

pub fn efficientnet_b7( input_channels: usize, num_classes: usize, ) -> Result<Self>

Create EfficientNet-B7 model

Trait Implementations

impl<F: Float + Debug + ScalarOperand + Send + Sync> Layer<F> for EfficientNet<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 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 params(&self) -> Vec<Array<F, IxDyn>>

Get the parameters of the layer

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 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 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