Struct EfficientNetConfig

pub struct EfficientNetConfig {
    pub width_coefficient: f64,
    pub depth_coefficient: f64,
    pub resolution: usize,
    pub dropout_rate: f64,
    pub stages: Vec<EfficientNetStage>,
    pub input_channels: usize,
    pub num_classes: usize,
}

Configuration for an EfficientNet model

Fields

width_coefficient: f64

Width multiplier

depth_coefficient: f64

Depth multiplier

resolution: usize

Resolution multiplier

dropout_rate: f64

Dropout rate

stages: Vec<EfficientNetStage>

Stage configurations

input_channels: usize

Number of input channels (e.g., 3 for RGB)

num_classes: usize

Number of output classes

Implementations

impl EfficientNetConfig

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

Create EfficientNet-B0 configuration

Examples found in repository

examples/efficientnet_example.rs (line 54)

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

Create EfficientNet-B1 configuration

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

Create EfficientNet-B2 configuration

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

Create EfficientNet-B3 configuration

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

Create EfficientNet-B4 configuration

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

Create EfficientNet-B5 configuration

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

Create EfficientNet-B6 configuration

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

Create EfficientNet-B7 configuration

pub fn scale_channels(&self, channels: usize) -> usize

Scale channels based on width coefficient

pub fn scale_depth(&self, depth: usize) -> usize

Scale depth based on depth coefficient

Trait Implementations

impl Clone for EfficientNetConfig

fn clone(&self) -> EfficientNetConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EfficientNetConfig

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

Formats the value using the given formatter.