Struct ClipTextEncoder 

pub struct ClipTextEncoder<T: Float> {
    pub embeddings: ClipTextEmbeddings<T>,
    pub encoder: ClipEncoder<T>,
    pub final_layer_norm: LayerNorm<T>,
    pub config: ClipTextConfig,
    /* private fields */
}

The full SD-1.5 CLIP text encoder. Wraps ClipTextEmbeddings + ClipEncoder + a final LayerNorm (final_layer_norm).

Mirrors CLIPTextTransformer in transformers. The HF CLIPTextModel wrapper sits one prefix above (text_model.embeddings.*, text_model.encoder.*, text_model.final_layer_norm.*) — see crate::safetensors_loader::load_clip_text_encoder for the text_model. strip.

Output is the per-token last_hidden_state [B, S, hidden_size]. SD-1.5 consumes this directly as encoder_hidden_states for the UNet’s cross-attention (no pooling).

Fields

embeddings: ClipTextEmbeddings<T>

Token + position embedding sum.

encoder: ClipEncoder<T>

12 × ClipEncoderLayer for SD-1.5.

final_layer_norm: LayerNorm<T>

Final LayerNorm over the last hidden state.

config: ClipTextConfig

Frozen copy of the configuration used to build the module.

Implementations

impl<T: Float> ClipTextEncoder<T>

pub fn new(cfg: ClipTextConfig) -> FerrotorchResult<Self>

Build a randomly-initialized text encoder.

Errors

Returns the underlying FerrotorchError from any sub-module constructor.

pub fn forward_from_ids(&self, input_ids: &[u32]) -> FerrotorchResult<Tensor<T>>

Run the encoder on a token-id sequence and return the per-token last_hidden_state [1, S, hidden_size].

input_ids is the verbatim CLIP-BPE token-id vector (length S). For SD-1.5 the canonical inference call is S = 77 (already-padded with EOS to the max length).

Errors

• FerrotorchError::InvalidArgument if input_ids is empty or longer than max_position_embeddings.
• Propagates downstream Embedding / LayerNorm errors.

pub fn forward_from_id_tensor( &self, ids: &Tensor<T>, ) -> FerrotorchResult<Tensor<T>>

Run the encoder on a pre-built float-encoded token-id tensor of shape [S]. Returns [1, S, hidden_size].

ids carries u32 token ids losslessly cast to T (numeric_cast::cast::<u32, T>). Mirrors what the dump example reads off disk.

Errors

Propagates downstream lookup / LayerNorm errors and converts invalid (negative / NaN / overflow) ids to FerrotorchError::InvalidArgument.

pub fn load_hf_state_dict( &mut self, hf_state: &StateDict<T>, strict: bool, ) -> FerrotorchResult<DropReport>

Load a HuggingFace CLIPTextModel state dict into this module.

Accepts both:

• bare-text_model layout (no prefix; what the pin script normalises to).
• full text_model.<rest> prefix (what the upstream HF checkpoint ships).

The HF safetensors also ships a non-parameter buffer we explicitly drop:

• text_model.embeddings.position_ids — a [1, max_pos] arange(max_pos) buffer regenerated each forward pass. Recorded in the crate::safetensors_loader::DropReport.

Errors

Forwards whatever each sub-module’s load_state_dict returns (shape mismatch / strict-mode missing key). Strict mode will surface text_model.embeddings.position_ids and any unknown key as errors; callers with a full HF checkpoint must pass strict=false.

Trait Implementations

impl<T: Debug + Float> Debug for ClipTextEncoder<T>

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

Formats the value using the given formatter.

impl<T: Float> Module<T> for ClipTextEncoder<T>

fn forward(&self, input: &Tensor<T>) -> FerrotorchResult<Tensor<T>>

Module::forward treats input as already-summed embeddings [1, S, hidden] and only runs the encoder + final LayerNorm. Real callers should use Self::forward_from_ids / Self::forward_from_id_tensor.

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

Iterate over all learnable parameters.

fn parameters_mut(&mut self) -> Vec<&mut Parameter<T>>

Iterate over all learnable parameters mutably.

fn named_parameters(&self) -> Vec<(String, &Parameter<T>)>

Named parameters for state dict serialization.

fn train(&mut self)

Set training mode. Affects dropout, batchnorm, etc.

fn eval(&mut self)

Set evaluation mode.

fn is_training(&self) -> bool

Whether the module is in training mode.

fn state_dict(&self) -> StateDict<T>

Export parameters and buffers as a state dict (torch parity).

fn load_state_dict( &mut self, state: &StateDict<T>, strict: bool, ) -> FerrotorchResult<()>

Load parameters from a state dict.

fn to_device(&mut self, device: Device) -> Result<(), FerrotorchError>

Move all parameters and buffers to a device.

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

Iterate over all non-trainable buffers (e.g. running mean / variance in BatchNorm). Default returns empty — concrete modules with buffers override.

fn buffers_mut(&mut self) -> Vec<&mut Buffer<T>>

Mutable iteration over all buffers. Default returns empty.

fn named_buffers(&self) -> Vec<(String, &Buffer<T>)>

Named buffers (dot-separated paths for nested modules). Default returns empty.

fn as_any(&self) -> Option<&(dyn Any + 'static)>

Downcast hook for type-erased buffer-loader dispatch. (#984)

fn children(&self) -> Vec<&dyn Module<T>>

Direct child modules. Default returns empty (leaf module).

fn named_children(&self) -> Vec<(String, &dyn Module<T>)>

Direct child modules with their attribute names. Default returns empty.

fn modules(&self) -> Vec<&dyn Module<T>>

where Self: Sized,

All modules in this subtree, depth-first (self first, then each child’s descendants in order).

fn descendants_dyn(&self) -> Vec<&dyn Module<T>>

All strict descendants of self in depth-first order. Object-safe.

fn named_modules(&self) -> Vec<(String, &dyn Module<T>)>

where Self: Sized,

All modules in this subtree with dot-separated path names. The root is named ""; children paths are joined with ..

fn named_descendants_dyn(&self) -> Vec<(String, &dyn Module<T>)>

Strict descendants with dot-paths. Object-safe.

fn with_forward_hook( self, hook: Box<dyn Fn(&Tensor<T>, &Tensor<T>) + Send + Sync>, ) -> (HookedModule<Self, T>, HookHandle)

where Self: Sized,

Wrap this module in a HookedModule and register a forward hook. Returns the wrapper paired with a HookHandle that can be used to remove the hook later. The wrapper implements Module<T> itself, so it slots into any place the original module did. Mirrors torch.nn.Module.register_forward_hook.

fn with_forward_pre_hook( self, hook: Box<dyn Fn(&Tensor<T>) -> Result<Tensor<T>, FerrotorchError> + Send + Sync>, ) -> (HookedModule<Self, T>, HookHandle)

where Self: Sized,

Wrap this module in a HookedModule and register a forward pre-hook. See Self::with_forward_hook. Mirrors torch.nn.Module.register_forward_pre_hook.

fn with_backward_hook( self, hook: Box<dyn Fn(&Tensor<T>, &Tensor<T>) + Send + Sync>, ) -> (HookedModule<Self, T>, HookHandle)

where Self: Sized,

Wrap this module in a HookedModule and register a backward hook. See Self::with_forward_hook. Mirrors torch.nn.Module.register_backward_hook.

fn zero_grad(&self) -> Result<(), FerrotorchError>

Set the gradient of every parameter to None.

fn requires_grad_(&mut self, requires_grad: bool)

Toggle requires_grad on every parameter (freeze / unfreeze the module). Mirrors torch.nn.Module.requires_grad_.

fn apply_to_parameters(&mut self, f: &mut dyn FnMut(&mut Parameter<T>))

Apply a function to every parameter in this module. Mirrors torch.nn.Module.apply for the parameter case (true apply recurses over all submodules; the recursive form requires &mut dyn Module which conflicts with this trait’s &mut self borrow).