Hugging Face

Bases: Engine[PromptSignature, Result, Model, InferenceMode]

Engine adapter around transformers.Pipeline for zero‑shot tasks.

Source code in sieves/engines/huggingface_.py

class HuggingFace(Engine[PromptSignature, Result, Model, InferenceMode]):
    """Engine adapter around ``transformers.Pipeline`` for zero‑shot tasks."""

    @override
    @property
    def inference_modes(self) -> type[InferenceMode]:
        return InferenceMode

    @override
    @property
    def supports_few_shotting(self) -> bool:
        return True

    @override
    def build_executable(
        self,
        inference_mode: InferenceMode,
        prompt_template: str | None,
        prompt_signature: type[PromptSignature] | PromptSignature,
        fewshot_examples: Sequence[pydantic.BaseModel] = (),
    ) -> Executable[Result | None]:
        cls_name = self.__class__.__name__
        assert prompt_template, ValueError(f"prompt_template has to be provided to {cls_name} engine by task.")
        assert isinstance(prompt_signature, list)

        # Render template with few-shot examples. Note that we don't use extracted document values here, as HF zero-shot
        # pipelines only support one hypothesis template per call - and we want to batch, so our hypothesis template
        # will be document-invariant.
        fewshot_examples_dict = HuggingFace.convert_fewshot_examples(fewshot_examples)
        # Render hypothesis template with everything but text.
        template = jinja2.Template(prompt_template).render(**({"examples": fewshot_examples_dict}))

        def execute(values: Sequence[dict[str, Any]]) -> Iterable[Result]:
            """Execute prompts with engine for given values.

            :param values: Values to inject into prompts.
            :return Iterable[Result]: Results for prompts.
            """
            match inference_mode:
                case InferenceMode.zeroshot_cls:
                    yield from self._model(
                        sequences=[doc_values["text"] for doc_values in values],
                        candidate_labels=prompt_signature,
                        hypothesis_template=template,
                        multi_label=True,
                        **self._inference_kwargs,
                    )

                case _:
                    raise ValueError(f"Inference mode {inference_mode} not supported by {cls_name} engine.")

        return execute

generation_settings property

Return generation settings.

Returns:

Type	Description
GenerationSettings	Generation settings.

model property

Return model instance.

Returns:

Type	Description
EngineModel	Model instance.

__init__(model, generation_settings)

Initialize engine with model and generation settings.

Parameters:

Name	Type	Description	Default
model	EngineModel	Instantiated model instance.	required
generation_settings	GenerationSettings	Generation settings.	required

Source code in sieves/engines/core.py

def __init__(self, model: EngineModel, generation_settings: GenerationSettings):
    """Initialize engine with model and generation settings.

    :param model: Instantiated model instance.
    :param generation_settings: Generation settings.
    """
    self._model = model
    self._generation_settings = generation_settings
    self._inference_kwargs = generation_settings.inference_kwargs or {}
    self._init_kwargs = generation_settings.init_kwargs or {}
    self._strict_mode = generation_settings.strict_mode

convert_fewshot_examples(fewshot_examples) staticmethod

Convert few‑shot examples to dicts.

Parameters:

Name	Type	Description	Default
fewshot_examples	Sequence[BaseModel]	Fewshot examples to convert.	required

Returns:

Type	Description
list[dict[str, Any]]	Fewshot examples as dicts.

Source code in sieves/engines/core.py

@staticmethod
def convert_fewshot_examples(fewshot_examples: Sequence[pydantic.BaseModel]) -> list[dict[str, Any]]:
    """Convert few‑shot examples to dicts.

    :param fewshot_examples: Fewshot examples to convert.
    :return: Fewshot examples as dicts.
    """
    return [fs_example.model_dump(serialize_as_any=True) for fs_example in fewshot_examples]