Struct HookCache 

pub struct HookCache { /* private fields */ }

Tensors captured during a forward pass, plus the output logits.

Returned by MIBackend::forward. Use get to retrieve activations at specific hook points.

Example

use candle_mi::{HookCache, HookPoint};
use candle_core::{Device, Tensor};

let logits = Tensor::zeros((1, 10, 32000), candle_core::DType::F32, &Device::Cpu).unwrap();
let mut cache = HookCache::new(logits);

// Store a captured activation
let pattern = Tensor::zeros((1, 8, 10, 10), candle_core::DType::F32, &Device::Cpu).unwrap();
cache.store(HookPoint::AttnPattern(5), pattern);

// Retrieve captured activations
let output = cache.output();
let attn = cache.get(&HookPoint::AttnPattern(5)).unwrap();

Implementations

impl HookCache

pub fn new(output: Tensor) -> Self

Create a new cache with the given output tensor and no captures.

pub const fn output(&self) -> &Tensor

The output tensor from the forward pass.

pub fn into_output(self) -> Tensor

Consume the cache and return the output tensor.

pub fn get(&self, hook: &HookPoint) -> Option<&Tensor>

Retrieve a captured tensor by hook point.

pub fn require(&self, hook: &HookPoint) -> Result<&Tensor>

Retrieve a captured tensor, returning an error if not found.

Errors

Returns MIError::Hook if the hook point was not captured.

pub fn store(&mut self, hook: HookPoint, tensor: Tensor)

Store a captured activation. Called by backend implementations.

pub fn set_output(&mut self, output: Tensor)

Replace the output tensor (e.g., after computing final logits).

This allows the forward pass to collect captures into a cache initialized with a placeholder, then set the real output at the end.

pub fn num_captures(&self) -> usize

Number of captured tensors (excludes the output).

Trait Implementations

impl Debug for HookCache

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

Formats the value using the given formatter.