--- title: t5_hf ---

fastvideo.models.encoders.t5_hf.BaseEncoderOutput

BaseEncoderOutput(last_hidden_state: torch.FloatTensor | None = None, pooler_output: torch.FloatTensor | None = None, hidden_states: tuple[torch.FloatTensor, ...] | None = None, attentions: tuple[torch.FloatTensor, ...] | None = None, attention_mask: torch.Tensor | None = None)

fastvideo.models.encoders.t5_hf.T5Config

T5Config(arch_config: TextEncoderArchConfig = T5ArchConfig(), prefix: str = 't5', quant_config: QuantizationConfig | None = None, lora_config: Any | None = None, is_chat_model: bool = False, treat_empty_as_dot: bool = False, *, _resolved_attention_backend: AttentionBackendEnum | None = None, chat_template_enable_thinking: bool = False)

fastvideo.models.encoders.t5_hf.TextEncoder

TextEncoder(config: TextEncoderConfig)

Base for native encoders with a model-specific forward output contract.

fastvideo.models.encoders.t5_hf.TextEncoder.forward

forward(*args: Any, **kwargs: Any) -> TextEncoderOutputT

fastvideo.models.encoders.t5_hf.T5EncoderModel

T5EncoderModel(config: T5Config, hf_model: Any | None = None)
Source
class T5EncoderModel(TextEncoder):

    supports_hf_from_pretrained: bool = True

    def __init__(self, config: T5Config, hf_model: Any | None = None) -> None:
        super().__init__(config)
        self.hf_model = hf_model

    @classmethod
    def from_pretrained_local(
        cls,
        model_path: str,
        config: T5Config,
        *,
        dtype: torch.dtype,
        device: torch.device,
    ) -> "T5EncoderModel":
        from transformers import T5EncoderModel as HFT5EncoderModel

        kwargs = {
            "local_files_only": True,
            "low_cpu_mem_usage": True,
        }
        try:
            hf = HFT5EncoderModel.from_pretrained(model_path, dtype=dtype, **kwargs)
        except TypeError:
            # Backward-compatible fallback for older Transformers versions.
            hf = HFT5EncoderModel.from_pretrained(model_path, torch_dtype=dtype, **kwargs)

        hf = hf.eval().to(device=device, dtype=dtype)
        return cls(config=config, hf_model=hf).eval()

    def forward(
        self,
        input_ids: torch.Tensor | None,
        position_ids: torch.Tensor | None = None,
        attention_mask: torch.Tensor | None = None,
        inputs_embeds: torch.Tensor | None = None,
        output_hidden_states: bool | None = None,
        **kwargs,
    ) -> BaseEncoderOutput:
        if self.hf_model is None:
            raise RuntimeError("T5EncoderModel(HF) is not initialized. Use "
                               "`from_pretrained_local(...)` to construct a loaded instance.")

        out = self.hf_model(
            input_ids=input_ids,
            attention_mask=attention_mask,
            inputs_embeds=inputs_embeds,
            output_hidden_states=bool(output_hidden_states) if output_hidden_states is not None else False,
            return_dict=True,
        )
        return BaseEncoderOutput(
            last_hidden_state=out.last_hidden_state,
            hidden_states=out.hidden_states if output_hidden_states else None,
            attention_mask=attention_mask,
        )

fastvideo.models.encoders.t5_hf.T5EncoderModel.from_pretrained_local

from_pretrained_local(model_path: str, config: T5Config, *, dtype: torch.dtype, device: torch.device) -> 'T5EncoderModel'
Source
@classmethod
def from_pretrained_local(
    cls,
    model_path: str,
    config: T5Config,
    *,
    dtype: torch.dtype,
    device: torch.device,
) -> "T5EncoderModel":
    from transformers import T5EncoderModel as HFT5EncoderModel

    kwargs = {
        "local_files_only": True,
        "low_cpu_mem_usage": True,
    }
    try:
        hf = HFT5EncoderModel.from_pretrained(model_path, dtype=dtype, **kwargs)
    except TypeError:
        # Backward-compatible fallback for older Transformers versions.
        hf = HFT5EncoderModel.from_pretrained(model_path, torch_dtype=dtype, **kwargs)

    hf = hf.eval().to(device=device, dtype=dtype)
    return cls(config=config, hf_model=hf).eval()

fastvideo.models.encoders.t5_hf.T5EncoderModel.forward

forward(input_ids: torch.Tensor | None, position_ids: torch.Tensor | None = None, attention_mask: torch.Tensor | None = None, inputs_embeds: torch.Tensor | None = None, output_hidden_states: bool | None = None, **kwargs) -> BaseEncoderOutput
Source
def forward(
    self,
    input_ids: torch.Tensor | None,
    position_ids: torch.Tensor | None = None,
    attention_mask: torch.Tensor | None = None,
    inputs_embeds: torch.Tensor | None = None,
    output_hidden_states: bool | None = None,
    **kwargs,
) -> BaseEncoderOutput:
    if self.hf_model is None:
        raise RuntimeError("T5EncoderModel(HF) is not initialized. Use "
                           "`from_pretrained_local(...)` to construct a loaded instance.")

    out = self.hf_model(
        input_ids=input_ids,
        attention_mask=attention_mask,
        inputs_embeds=inputs_embeds,
        output_hidden_states=bool(output_hidden_states) if output_hidden_states is not None else False,
        return_dict=True,
    )
    return BaseEncoderOutput(
        last_hidden_state=out.last_hidden_state,
        hidden_states=out.hidden_states if output_hidden_states else None,
        attention_mask=attention_mask,
    )