Struct TransferLearningManager

pub struct TransferLearningManager<F: Float + Debug> { /* private fields */ }

Transfer learning manager

Implementations

impl<F: Float + Debug + 'static> TransferLearningManager<F>

pub fn new(strategy: TransferStrategy, base_learning_rate: f64) -> Result<Self>

Create a new transfer learning manager

Examples found in repository

examples/neural_advanced_features.rs (lines 311-314)

fn demonstrate_transfer_learning() -> Result<()> {
    println!("🔄 Transfer Learning Demonstration");
    println!("=================================\n");

    // Create transfer learning manager
    let mut transfer_manager = TransferLearningManager::<f64>::new(
        TransferStrategy::FeatureExtraction { unfrozen_layers: 2 },
        0.001,
    )?;

    let layer_names = vec![
        "backbone.conv1".to_string(),
        "backbone.conv2".to_string(),
        "backbone.conv3".to_string(),
        "head.fc1".to_string(),
        "head.fc2".to_string(),
    ];

    println!("1. Initializing transfer learning strategy...");
    transfer_manager.initialize_layer_states(&layer_names)?;

    let summary = transfer_manager.get_summary();
    println!("   Strategy: {:?}", summary.strategy);
    println!("   Total layers: {}", summary.total_layers);
    println!("   Frozen layers: {}", summary.frozen_layers);
    println!("   Trainable layers: {}", summary.trainable_layers);

    println!("\n2. Layer-wise learning rates:");
    for layer_name in &layer_names {
        let lr = transfer_manager.get_layer_learning_rate(layer_name);
        let frozen = transfer_manager.is_layer_frozen(layer_name);
        println!("   {}: lr={:.6}, frozen={}", layer_name, lr, frozen);
    }

    // Simulate progressive unfreezing
    println!("\n3. Progressive unfreezing simulation:");
    for epoch in [5, 10, 15] {
        transfer_manager.update_epoch(epoch)?;
        println!(
            "   Epoch {}: {} frozen layers",
            epoch,
            transfer_manager.get_summary().frozen_layers
        );
    }

    println!("✅ Transfer learning demonstration completed!\n");
    Ok(())
}

pub fn initialize_layer_states(&mut self, layer_names: &[String]) -> Result<()>

Initialize layer states based on the transfer strategy

Examples found in repository

examples/neural_advanced_features.rs (line 325)

fn demonstrate_transfer_learning() -> Result<()> {
    println!("🔄 Transfer Learning Demonstration");
    println!("=================================\n");

    // Create transfer learning manager
    let mut transfer_manager = TransferLearningManager::<f64>::new(
        TransferStrategy::FeatureExtraction { unfrozen_layers: 2 },
        0.001,
    )?;

    let layer_names = vec![
        "backbone.conv1".to_string(),
        "backbone.conv2".to_string(),
        "backbone.conv3".to_string(),
        "head.fc1".to_string(),
        "head.fc2".to_string(),
    ];

    println!("1. Initializing transfer learning strategy...");
    transfer_manager.initialize_layer_states(&layer_names)?;

    let summary = transfer_manager.get_summary();
    println!("   Strategy: {:?}", summary.strategy);
    println!("   Total layers: {}", summary.total_layers);
    println!("   Frozen layers: {}", summary.frozen_layers);
    println!("   Trainable layers: {}", summary.trainable_layers);

    println!("\n2. Layer-wise learning rates:");
    for layer_name in &layer_names {
        let lr = transfer_manager.get_layer_learning_rate(layer_name);
        let frozen = transfer_manager.is_layer_frozen(layer_name);
        println!("   {}: lr={:.6}, frozen={}", layer_name, lr, frozen);
    }

    // Simulate progressive unfreezing
    println!("\n3. Progressive unfreezing simulation:");
    for epoch in [5, 10, 15] {
        transfer_manager.update_epoch(epoch)?;
        println!(
            "   Epoch {}: {} frozen layers",
            epoch,
            transfer_manager.get_summary().frozen_layers
        );
    }

    println!("✅ Transfer learning demonstration completed!\n");
    Ok(())
}

pub fn update_epoch(&mut self, epoch: usize) -> Result<()>

Update layer states at the beginning of each epoch

Examples found in repository

examples/neural_advanced_features.rs (line 343)

fn demonstrate_transfer_learning() -> Result<()> {
    println!("🔄 Transfer Learning Demonstration");
    println!("=================================\n");

    // Create transfer learning manager
    let mut transfer_manager = TransferLearningManager::<f64>::new(
        TransferStrategy::FeatureExtraction { unfrozen_layers: 2 },
        0.001,
    )?;

    let layer_names = vec![
        "backbone.conv1".to_string(),
        "backbone.conv2".to_string(),
        "backbone.conv3".to_string(),
        "head.fc1".to_string(),
        "head.fc2".to_string(),
    ];

    println!("1. Initializing transfer learning strategy...");
    transfer_manager.initialize_layer_states(&layer_names)?;

    let summary = transfer_manager.get_summary();
    println!("   Strategy: {:?}", summary.strategy);
    println!("   Total layers: {}", summary.total_layers);
    println!("   Frozen layers: {}", summary.frozen_layers);
    println!("   Trainable layers: {}", summary.trainable_layers);

    println!("\n2. Layer-wise learning rates:");
    for layer_name in &layer_names {
        let lr = transfer_manager.get_layer_learning_rate(layer_name);
        let frozen = transfer_manager.is_layer_frozen(layer_name);
        println!("   {}: lr={:.6}, frozen={}", layer_name, lr, frozen);
    }

    // Simulate progressive unfreezing
    println!("\n3. Progressive unfreezing simulation:");
    for epoch in [5, 10, 15] {
        transfer_manager.update_epoch(epoch)?;
        println!(
            "   Epoch {}: {} frozen layers",
            epoch,
            transfer_manager.get_summary().frozen_layers
        );
    }

    println!("✅ Transfer learning demonstration completed!\n");
    Ok(())
}

pub fn unfreeze_layers(&mut self, count: usize) -> Result<()>

Unfreeze the specified number of layers from the end

pub fn freeze_layers(&mut self, layer_names: &[String]) -> Result<()>

Freeze specific layers

pub fn get_layer_learning_rate(&self, layer_name: &str) -> F

Get effective learning rate for a layer

Examples found in repository

examples/neural_advanced_features.rs (line 335)

fn demonstrate_transfer_learning() -> Result<()> {
    println!("🔄 Transfer Learning Demonstration");
    println!("=================================\n");

    // Create transfer learning manager
    let mut transfer_manager = TransferLearningManager::<f64>::new(
        TransferStrategy::FeatureExtraction { unfrozen_layers: 2 },
        0.001,
    )?;

    let layer_names = vec![
        "backbone.conv1".to_string(),
        "backbone.conv2".to_string(),
        "backbone.conv3".to_string(),
        "head.fc1".to_string(),
        "head.fc2".to_string(),
    ];

    println!("1. Initializing transfer learning strategy...");
    transfer_manager.initialize_layer_states(&layer_names)?;

    let summary = transfer_manager.get_summary();
    println!("   Strategy: {:?}", summary.strategy);
    println!("   Total layers: {}", summary.total_layers);
    println!("   Frozen layers: {}", summary.frozen_layers);
    println!("   Trainable layers: {}", summary.trainable_layers);

    println!("\n2. Layer-wise learning rates:");
    for layer_name in &layer_names {
        let lr = transfer_manager.get_layer_learning_rate(layer_name);
        let frozen = transfer_manager.is_layer_frozen(layer_name);
        println!("   {}: lr={:.6}, frozen={}", layer_name, lr, frozen);
    }

    // Simulate progressive unfreezing
    println!("\n3. Progressive unfreezing simulation:");
    for epoch in [5, 10, 15] {
        transfer_manager.update_epoch(epoch)?;
        println!(
            "   Epoch {}: {} frozen layers",
            epoch,
            transfer_manager.get_summary().frozen_layers
        );
    }

    println!("✅ Transfer learning demonstration completed!\n");
    Ok(())
}

pub fn is_layer_frozen(&self, layer_name: &str) -> bool

Check if a layer is frozen

Examples found in repository

examples/neural_advanced_features.rs (line 336)

fn demonstrate_transfer_learning() -> Result<()> {
    println!("🔄 Transfer Learning Demonstration");
    println!("=================================\n");

    // Create transfer learning manager
    let mut transfer_manager = TransferLearningManager::<f64>::new(
        TransferStrategy::FeatureExtraction { unfrozen_layers: 2 },
        0.001,
    )?;

    let layer_names = vec![
        "backbone.conv1".to_string(),
        "backbone.conv2".to_string(),
        "backbone.conv3".to_string(),
        "head.fc1".to_string(),
        "head.fc2".to_string(),
    ];

    println!("1. Initializing transfer learning strategy...");
    transfer_manager.initialize_layer_states(&layer_names)?;

    let summary = transfer_manager.get_summary();
    println!("   Strategy: {:?}", summary.strategy);
    println!("   Total layers: {}", summary.total_layers);
    println!("   Frozen layers: {}", summary.frozen_layers);
    println!("   Trainable layers: {}", summary.trainable_layers);

    println!("\n2. Layer-wise learning rates:");
    for layer_name in &layer_names {
        let lr = transfer_manager.get_layer_learning_rate(layer_name);
        let frozen = transfer_manager.is_layer_frozen(layer_name);
        println!("   {}: lr={:.6}, frozen={}", layer_name, lr, frozen);
    }

    // Simulate progressive unfreezing
    println!("\n3. Progressive unfreezing simulation:");
    for epoch in [5, 10, 15] {
        transfer_manager.update_epoch(epoch)?;
        println!(
            "   Epoch {}: {} frozen layers",
            epoch,
            transfer_manager.get_summary().frozen_layers
        );
    }

    println!("✅ Transfer learning demonstration completed!\n");
    Ok(())
}

pub fn update_layer_statistics( &self, layer_name: String, gradient_magnitude: F, param_update_magnitude: F, param_count: usize, activation_variance: F, ) -> Result<()>

Update layer statistics

pub fn get_layer_statistics( &self, ) -> Result<HashMap<String, LayerStatistics<F>>>

Get layer statistics

pub fn get_summary(&self) -> TransferLearningState

Get summary of current transfer learning state

Examples found in repository

examples/neural_advanced_features.rs (line 327)

fn demonstrate_transfer_learning() -> Result<()> {
    println!("🔄 Transfer Learning Demonstration");
    println!("=================================\n");

    // Create transfer learning manager
    let mut transfer_manager = TransferLearningManager::<f64>::new(
        TransferStrategy::FeatureExtraction { unfrozen_layers: 2 },
        0.001,
    )?;

    let layer_names = vec![
        "backbone.conv1".to_string(),
        "backbone.conv2".to_string(),
        "backbone.conv3".to_string(),
        "head.fc1".to_string(),
        "head.fc2".to_string(),
    ];

    println!("1. Initializing transfer learning strategy...");
    transfer_manager.initialize_layer_states(&layer_names)?;

    let summary = transfer_manager.get_summary();
    println!("   Strategy: {:?}", summary.strategy);
    println!("   Total layers: {}", summary.total_layers);
    println!("   Frozen layers: {}", summary.frozen_layers);
    println!("   Trainable layers: {}", summary.trainable_layers);

    println!("\n2. Layer-wise learning rates:");
    for layer_name in &layer_names {
        let lr = transfer_manager.get_layer_learning_rate(layer_name);
        let frozen = transfer_manager.is_layer_frozen(layer_name);
        println!("   {}: lr={:.6}, frozen={}", layer_name, lr, frozen);
    }

    // Simulate progressive unfreezing
    println!("\n3. Progressive unfreezing simulation:");
    for epoch in [5, 10, 15] {
        transfer_manager.update_epoch(epoch)?;
        println!(
            "   Epoch {}: {} frozen layers",
            epoch,
            transfer_manager.get_summary().frozen_layers
        );
    }

    println!("✅ Transfer learning demonstration completed!\n");
    Ok(())
}