Function sequential_model_summary

pub fn sequential_model_summary<F: Float + Debug + ScalarOperand>(
    model: &Sequential<F>,
    input_shape: Option<Vec<usize>>,
    title: Option<&str>,
    options: Option<ModelVizOptions>,
) -> Result<String>

Create an ASCII text representation of a sequential model architecture

Arguments

• model - The sequential model to visualize
• input_shape - Optional input shape to propagate through the model
• title - Optional title for the visualization
• options - Visualization options

Returns

• Result<String> - ASCII representation of the model architecture

Examples found in repository

examples/model_visualization_simple.rs (lines 17-31)

fn main() -> Result<()> {
    // Initialize random number generator
    let mut rng = SmallRng::seed_from_u64(42);

    // Create a simple MLP model
    let model = create_mlp_model(&mut rng)?;

    // Display model summary
    let summary = sequential_model_summary(
        &model,
        Some(vec![32, 784]), // Input shape (batch_size, input_features)
        Some("Simple MLP Neural Network"),
        Some(ModelVizOptions {
            width: 80,
            show_params: true,
            show_shapes: true,
            show_properties: true,
            color_options: ColorOptions {
                enabled: true,
                ..Default::default()
            },
        }),
    )?;
    println!("{}", summary);

    // Display model dataflow
    let dataflow = sequential_model_dataflow(
        &model,
        vec![32, 784], // Input shape
        Some("MLP Data Flow Diagram"),
        None, // Use default options
    )?;
    println!("\n{}", dataflow);

    Ok(())
}

examples/model_visualization_cnn.rs (lines 17-31)

fn main() -> Result<()> {
    // Initialize random number generator
    let mut rng = SmallRng::seed_from_u64(42);

    // Create a CNN model
    let model = create_cnn_model(&mut rng)?;

    // Display model summary
    let summary = sequential_model_summary(
        &model,
        Some(vec![32, 3, 224, 224]), // Input shape (batch_size, channels, height, width)
        Some("CNN Architecture"),
        Some(ModelVizOptions {
            width: 100,
            show_params: true,
            show_shapes: true,
            show_properties: true,
            color_options: ColorOptions {
                enabled: true,
                ..Default::default()
            },
        }),
    )?;
    println!("{}", summary);

    // Display model dataflow
    let dataflow = sequential_model_dataflow(
        &model,
        vec![32, 3, 224, 224], // Input shape
        Some("CNN Data Flow Diagram"),
        Some(ModelVizOptions {
            width: 80,
            show_params: true,
            show_shapes: true,
            show_properties: false,
            color_options: ColorOptions {
                enabled: true,
                ..Default::default()
            },
        }),
    )?;
    println!("\n{}", dataflow);

    Ok(())
}

examples/model_architecture_visualization.rs (lines 21-32)

fn main() -> Result<()> {
    println!("Model Architecture Visualization Example");
    println!("=======================================\n");

    // Initialize RNG with a fixed seed for reproducibility
    let mut rng = SmallRng::seed_from_u64(42);

    // Example 1: MLP (Multilayer Perceptron) Architecture
    println!("\n--- Example 1: MLP Architecture ---\n");
    let mlp = create_mlp_model(&mut rng)?;

    // Display model summary
    let mlp_summary = sequential_model_summary(
        &mlp,
        Some(vec![32, 784]), // Input shape (batch_size, input_features)
        Some("MLP Neural Network"),
        Some(ModelVizOptions {
            width: 80,
            show_params: true,
            show_shapes: true,
            show_properties: true,
            color_options: ColorOptions::default(),
        }),
    )?;
    println!("{}", mlp_summary);

    // Display model dataflow
    let mlp_dataflow = sequential_model_dataflow(
        &mlp,
        vec![32, 784], // Input shape
        Some("MLP Data Flow"),
        None, // Use default options
    )?;
    println!("\n{}", mlp_dataflow);

    // Example 2: CNN (Convolutional Neural Network) Architecture
    println!("\n--- Example 2: CNN Architecture ---\n");
    let cnn = create_cnn_model(&mut rng)?;

    // Display model summary with colored output
    let mut color_options = ColorOptions::default();
    color_options.enabled = true; // Force enable colors
    color_options.use_bright = true;

    let cnn_summary = sequential_model_summary(
        &cnn,
        Some(vec![32, 28, 28, 1]), // Input shape (batch_size, height, width, channels)
        Some("CNN Neural Network"),
        Some(ModelVizOptions {
            width: 80,
            show_params: true,
            show_shapes: true,
            show_properties: true,
            color_options,
        }),
    )?;
    println!("{}", cnn_summary);

    // Display model dataflow
    let cnn_dataflow = sequential_model_dataflow(
        &cnn,
        vec![32, 28, 28, 1], // Input shape
        Some("CNN Data Flow"),
        Some(ModelVizOptions {
            width: 80,
            show_params: true,
            show_shapes: true,
            show_properties: false,
            color_options,
        }),
    )?;
    println!("\n{}", cnn_dataflow);

    // Example 3: RNN (Recurrent Neural Network) Architecture
    println!("\n--- Example 3: RNN (LSTM) Architecture ---\n");
    println!("Skipping RNN example due to threading constraints with LSTM implementation.");

    println!("\nModel Architecture Visualization Complete!");
    Ok(())
}