Struct HookManager 

pub struct HookManager { /* private fields */ }

Hook manager for coordinating debugging hooks

Implementations

impl HookManager

pub fn new() -> Self

Create a new hook manager

pub fn register_hook(&mut self, config: HookConfig) -> Result<Uuid>

Register a new hook

pub fn register_callback(&mut self, name: String, callback: HookCallback)

Register a custom callback

pub fn remove_hook(&mut self, hook_id: Uuid) -> Option<HookConfig>

Remove a hook

pub fn set_hook_enabled(&mut self, hook_id: Uuid, enabled: bool) -> Result<()>

Enable/disable a specific hook

pub fn set_enabled(&mut self, enabled: bool)

Enable/disable all hooks

pub fn set_step(&mut self, step: usize)

Update global step counter

pub fn set_loss(&mut self, loss: f64)

Report the current training loss for HookCondition::LossThreshold evaluation. Call this once per step before Self::execute_hooks; without it, LossThreshold conditions never fire (see Self::evaluate_condition).

pub fn set_gradient_norm(&mut self, grad_norm: f64)

Report the current gradient norm for HookCondition::GradientNormThreshold evaluation. See Self::set_loss.

pub fn set_memory_mb(&mut self, memory_mb: f64)

Report current memory usage (in MB) for HookCondition::MemoryThreshold evaluation. See Self::set_loss.

pub fn tensor_inspector(&self) -> &TensorInspector

Real statistics recorded by HookAction::InspectTensor and HookAction::TrackGradients hooks executed so far – shapes, mean/std/min/max, NaN/Inf counts, per-tensor alerts, etc, computed from the actual tensor data each hook received.

pub fn tensor_inspector_mut(&mut self) -> &mut TensorInspector

Mutable access to the wired TensorInspector, e.g. to call TensorInspector::clear between epochs.

pub fn activation_visualizer(&self) -> &ActivationVisualizer

Real per-layer activation statistics recorded by HookAction::RecordActivations hooks executed so far.

pub fn activation_visualizer_mut(&mut self) -> &mut ActivationVisualizer

Mutable access to the wired ActivationVisualizer.

pub fn pause_flag(&self) -> Arc<AtomicBool>

Returns a clone of the shared pause flag that HookAction::PauseTraining sets.

Contract

The hook system runs inside Self::execute_hooks, called by whatever training loop is driving it – it has no independent thread of control and therefore cannot itself halt that loop. What HookAction::PauseTraining truthfully can do, and does, is set this flag to true (see Self::execute_action). For “pause on hook” behaviour, the training loop must cooperate:

1. Once, after constructing the HookManager, clone this flag out with manager.pause_flag() and keep the Arc alongside the loop state.
2. On each step (or at another convenient point), check flag.load(Ordering::SeqCst) – equivalently Self::is_paused on the manager, if the loop still has access to it – and if true, actually stop advancing (block for operator input, yield to a debug console, etc).
3. Call Self::resume_training (or flag.store(false, ...) directly) once ready to continue.

A training loop that never polls this flag is simply not pausable by hooks; HookAction::PauseTraining does not claim otherwise – it only guarantees the flag itself is set truthfully when it fires.

pub fn is_paused(&self) -> bool

true if a HookAction::PauseTraining hook has fired and nothing has called Self::resume_training since. See Self::pause_flag for the full contract.

pub fn resume_training(&self)

Clears the pause flag set by HookAction::PauseTraining. See Self::pause_flag for the full contract.

pub fn execute_hooks<T>( &mut self, layer_name: &str, tensor_data: &[T], tensor_shape: &[usize], is_forward: bool, metadata: Option<HashMap<String, String>>, ) -> Vec<(Uuid, HookResult)>

where T: Clone + Into<f64> + 'static,

Execute hooks for a tensor operation

pub fn get_hook(&self, hook_id: Uuid) -> Option<&HookConfig>

Get hook configuration

pub fn get_all_hooks(&self) -> Vec<&HookConfig>

Get all hooks

pub fn get_hook_stats(&self, hook_id: Uuid) -> Option<&HookStats>

Get hook statistics

pub fn get_all_stats(&self) -> Vec<&HookStats>

Get all hook statistics

pub fn clear_hooks(&mut self)

Clear all hooks

pub fn create_tensor_inspection_hook( &mut self, layer_patterns: Vec<String>, ) -> Result<Uuid>

Create a convenient tensor inspection hook

pub fn create_gradient_tracking_hook( &mut self, layer_patterns: Vec<String>, ) -> Result<Uuid>

Create a gradient tracking hook

pub fn create_alert_hook( &mut self, condition: HookCondition, message: String, severity: AlertSeverity, ) -> Result<Uuid>

Create a conditional alert hook

Trait Implementations

impl Debug for HookManager

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

Formats the value using the given formatter.

impl Default for HookManager

fn default() -> Self

Returns the “default value” for a type.