Struct Dropout 

pub struct Dropout { /* private fields */ }

Inverted dropout module.

Uses a single fused torch::dropout kernel (1 autograd node). During training: randomly zeros elements with probability p, scales remaining by 1/(1-p). During eval: identity function.

Implementations

impl Dropout

pub fn new(p: f64) -> Self

Create a dropout module with drop probability p (0.0 to 1.0). Use set_training(false) to disable during inference.

Examples found in repository

examples/showcase/main.rs (line 546)

fn build_showcase() -> flodl::Result<Graph> {
    const B: i64 = 2;  // batch size (>= 2 for BatchNorm training mode)
    const H: i64 = 8;

    FlowBuilder::from(Linear::new(2, H)?)
        // input() declares auxiliary graph inputs — forward_multi receives them
        .input(&["ctx"])

        // Tag names a position in the stream for later reference via .using()
        .tag("input")

        // .through() chains modules sequentially: stream -> module -> stream
        .through(GELU)
        .through(LayerNorm::new(H)?)
        .through(RmsNorm::new())

        // ContextBlend is a NamedInputModule that reads the "ctx" auxiliary input
        .through(ContextBlend)
        .using(&["ctx"])

        // .fork() runs a side-branch: output can be tagged, main stream unchanged
        .fork(spectral_monitor(H)?)
        .tag("spectral")

        // .split() forks the stream into parallel branches, .merge() recombines.
        // modules![] is shorthand for vec![Box::new(...) as Box<dyn Module>, ...]
        .split(modules![read_head(H)?, read_head(H)?])
        .merge(MergeOp::Mean)

        // .also() adds a residual connection: output = stream + module(stream)
        .also(Linear::new(H, H)?)
        .through(Dropout::new(0.1))
        .through(SoftClamp::new(0.5, 3.0))
        .through(Softplus)

        // VarianceGate exercises mean/var/std/expand
        .through(VarianceGate::new(H))

        // .map().slices(n) decomposes [B,D] -> [B*n,D/n], applies body, recomposes
        .map(read_head(2)?)
        .slices(H / 2)

        // Reshape changes tensor dimensions without copying data
        .through(Reshape::new(&[B * 2, H / 2]))

        // .map().each() applies body independently to each element in a multi-stream
        .map(Linear::new(H / 2, H / 2)?)
        .each()
        .tag("halves")

        // .map().over(tag) iterates over a tagged tensor (backward ref) instead
        // of the current stream — useful for refining previously computed features
        .map(Linear::new(H / 2, H / 2)?)
        .over("halves")

        // .map().batched().each() — fast path: full batch in one call
        .map(Linear::new(H / 2, H / 2)?)
        .batched()
        .each()

        .through(Reshape::new(&[B, H]))
        .through(ShapeOps::new(B, H))
        .through(NegSigmoidGate)
        .through(TransposeRoundTrip)

        // CounterModule overrides reset() — loops auto-call it before iterating
        .through(CounterModule::new())

        // ChunkRecombine: chunk, relu (Variable op), cat
        .through(ChunkRecombine)

        // AttentionLikeOps: softmax, select, narrow, index_select
        .through(AttentionLikeOps::new(H))

        // TopKFilterOps: topk, sort, gather, min, max, pad
        .through(TopKFilterOps::new(H))

        // RepeatNarrow: repeat
        .through(RepeatNarrow::new(H))

        // .loop_body().for_n(n) repeats the body n times, feeding output back as input.
        // silu_block is a sub-graph (Graph implements Module) — graphs compose freely.
        .loop_body(silu_block(H)?)
        .for_n(2)
        .tag("refined")

        // .gate() is soft routing (mixture of experts): all experts run, router
        // produces weights, outputs are combined. .using() feeds the tagged "input"
        // stream to the router as a backward reference.
        .gate(
            SoftmaxRouter::new(H, 2)?,
            modules![Linear::new(H, H)?, Linear::new(H, H)?],
        )
        .using(&["input"])

        // .switch() is hard routing: router picks one branch, others are skipped.
        // HeavyPathSelector is a custom NamedInputModule — it receives the "refined"
        // ref via forward_named() and decides which branch to activate.
        .switch(
            HeavyPathSelector,
            modules![Linear::new(H, H)?, ffn_block(H)?],
        )
        .using(&["refined"])

        // Forward reference: .using("memory") reads a tag that doesn't exist yet —
        // the framework creates a state buffer. .tag("memory") writes to it.
        // On the first pass, the state is zero (pass-through). On subsequent passes,
        // StateAdd accumulates: stream + previous_memory.
        .through(StateAdd)
        .using(&["memory"])
        .tag("memory")

        // .while_cond() repeats until the halt module signals stop (or max iterations).
        // ThresholdHalt stops when the stream's L2 norm exceeds the threshold.
        .loop_body(Linear::new(H, H)?)
        .while_cond(ThresholdHalt::new(100.0), 5)

        // .until_cond() is the inverse: repeats until halt signals true.
        // LearnedHalt has trainable parameters — it learns when to stop.
        .loop_body(Linear::new(H, H)?)
        .until_cond(LearnedHalt::new(H)?, 7)

        .through(LogSoftmaxReduce)
        .through(Linear::new(1, H)?)

        // Split with tag_group: names each branch ("final_heads_0", "final_heads_1")
        .split(vec![
            Box::new(Linear::new(H, H)?),
            Box::new(Linear::new(H, H)?),
        ])
        .tag_group("final_heads")
        .merge(MergeOp::Add)

        // Final projection and output tag for observation
        .through(Linear::new(H, 2)?)
        .tag("output")
        .build()
}

Trait Implementations

impl Module for Dropout

fn name(&self) -> &str

Human-readable type name used as node ID prefix in graph visualization. Override to return a lowercase identifier (e.g., “linear”, “gelu”).

fn forward(&self, input: &Variable) -> Result<Variable>

Run the forward pass on input and return the result.

fn set_training(&self, training: bool)

Set training/eval mode. Affects Dropout, BatchNorm, etc. Override in modules with mode-dependent behavior.

fn parameters(&self) -> Vec<Parameter>

Return this module’s learnable parameters. Default: recursively collects from sub_modules() with pointer dedup. Leaf modules should override to return their own parameters.

fn buffers(&self) -> Vec<Buffer>

Return this module’s non-learnable persistent buffers (e.g., running stats). Default: recursively collects from sub_modules() with pointer dedup. Leaf modules should override to return their own buffers.

fn sub_modules(&self) -> Vec<Rc<dyn Module>>

Return direct child modules for recursive tree walks. Override in composite modules (loops, switches, gates).

fn move_to_device(&self, _device: Device)

Move all parameters and buffers to the given device. Override in modules like BatchNorm that hold non-parameter state.

fn train(&self)

Set training mode. Shorthand for set_training(true).

fn eval(&self)

Set eval mode. Shorthand for set_training(false).

fn trace(&self) -> Option<Variable>

Return per-iteration side output for loop tracing. Override in loop body modules that capture trajectory data (e.g., attention fixation points). Returns None by default. When Some, the loop executor collects traces accessible via Graph::traces().

fn as_named_input(&self) -> Option<&dyn NamedInputModule>

Upcast to NamedInputModule for multi-input graphs. Override in types that implement NamedInputModule to enable receiving additional named inputs via graph using().

fn structural_hash(&self) -> Option<String>

SHA-256 hex hash of module architecture for checkpoint validation. Override in composite modules (Graph) that compute a deterministic hash from their topology and parameter shapes.

fn reset(&self)

Reset internal state (e.g. recurrent hidden state) between sequences. Called by loops before iterating to clear stale tensors whose grad_fns may reference freed saved tensors. Override in stateful modules.

fn detach_state(&self)

Detach internal state from the computation graph (for truncated BPTT). Called between training steps to break gradient chains on state carried across forward passes (e.g., recurrent hidden state). Override in stateful modules.