Upload folder using huggingface_hub

api.py

@@ -2,16 +2,21 @@ import json
 from functools import lru_cache
 from typing import Any, Dict, List, Optional, Union
 
+from datasets import Dataset, DatasetDict, IterableDataset, IterableDatasetDict
+
 from .artifact import fetch_artifact
 from .dataset_utils import get_dataset_artifact
 from .inference import InferenceEngine, LogProbInferenceEngine
 from .logging_utils import get_logger
 from .metric_utils import _compute, _inference_post_process
 from .operator import SourceOperator
-from .schema import UNITXT_DATASET_SCHEMA
+from .schema import UNITXT_DATASET_SCHEMA, loads_instance
+from .settings_utils import get_constants, get_settings
 from .standard import StandardRecipe
 
 logger = get_logger()
+constants = get_constants()
+settings = get_settings()
 
 
 def load(source: Union[SourceOperator, str]):
@@ -80,8 +85,12 @@ def load_recipe(dataset_query: Optional[str] = None, **kwargs) -> StandardRecipe
 
 
 def load_dataset(
-    dataset_query: Optional[str] = None, streaming: bool = False, **kwargs
-):
+    dataset_query: Optional[str] = None,
+    split: Optional[str] = None,
+    streaming: bool = False,
+    disable_cache: Optional[bool] = None,
+    **kwargs,
+) -> Union[DatasetDict, IterableDatasetDict, Dataset, IterableDataset]:
     """Loads dataset.
 
     If the 'dataset_query' argument is provided, then dataset is loaded from a card in local
@@ -93,6 +102,8 @@ def load_dataset(
             For example:
             "card=cards.wnli,template=templates.classification.multi_class.relation.default".
         streaming (bool, False): When True yields the data as Unitxt streams dictionary
+        split (str, optional): The split of the data to load
+        disable_cache (str, optional): Disable caching process of the data
         **kwargs: Arguments used to load dataset from provided card, which is not present in local catalog.
 
     Returns:
@@ -110,10 +121,21 @@ def load_dataset(
     """
     recipe = load_recipe(dataset_query, **kwargs)
 
+    stream = recipe()
+    if split is not None:
+        stream = stream[split]
+
+    if disable_cache is None:
+        disable_cache = settings.disable_hf_datasets_cache
+
     if streaming:
-        return recipe()
+        return stream.to_iterable_dataset(
+            features=UNITXT_DATASET_SCHEMA,
+        ).map(loads_instance, batched=True)
 
-    return recipe().to_dataset(features=UNITXT_DATASET_SCHEMA)
+    return stream.to_dataset(
+        features=UNITXT_DATASET_SCHEMA, disable_cache=disable_cache
+    ).with_transform(loads_instance)
 
 
 def evaluate(predictions, data) -> List[Dict[str, Any]]:
@@ -129,14 +151,16 @@ def _get_produce_with_cache(dataset_query: Optional[str] = None, **kwargs):
     return load_recipe(dataset_query, **kwargs).produce
 
 
-def produce(instance_or_instances, dataset_query: Optional[str] = None, **kwargs):
+def produce(
+    instance_or_instances, dataset_query: Optional[str] = None, **kwargs
+) -> Union[Dataset, Dict[str, Any]]:
     is_list = isinstance(instance_or_instances, list)
     if not is_list:
         instance_or_instances = [instance_or_instances]
     result = _get_produce_with_cache(dataset_query, **kwargs)(instance_or_instances)
     if not is_list:
-        result = result[0]
-    return result
+        return result[0]
+    return Dataset.from_list(result).with_transform(loads_instance)
 
 
 def infer(
@@ -174,13 +198,13 @@ def infer(
         )
     predictions = post_process(raw_predictions, dataset)
     if return_data:
-        for prediction, raw_prediction, instance, infer_output in zip(
-            predictions, raw_predictions, dataset, infer_outputs
-        ):
-            if return_meta_data:
-                instance["infer_meta_data"] = infer_output.__dict__
-                del instance["infer_meta_data"]["prediction"]
-            instance["prediction"] = prediction
-            instance["raw_prediction"] = raw_prediction
-        return dataset
+        if return_meta_data:
+            infer_output_list = [
+                infer_output.__dict__ for infer_output in infer_outputs
+            ]
+            for infer_output in infer_output_list:
+                del infer_output["prediction"]
+            dataset = dataset.add_column("infer_meta_data", infer_output_list)
+        dataset = dataset.add_column("prediction", predictions)
+        return dataset.add_column("raw_prediction", raw_predictions)
     return predictions

artifact.py

@@ -15,13 +15,14 @@ from .dataclass import (
     NonPositionalField,
     fields,
 )
+from .error_utils import Documentation, UnitxtError, UnitxtWarning
 from .logging_utils import get_logger
 from .parsing_utils import (
     separate_inside_and_outside_square_brackets,
 )
 from .settings_utils import get_constants, get_settings
 from .text_utils import camel_to_snake_case, is_camel_case
-from .type_utils import issubtype
+from .type_utils import isoftype, issubtype
 from .utils import (
     artifacts_json_cache,
     json_dump,
@@ -44,11 +45,11 @@ def verify_legal_catalog_name(name):
     ), f'Artifict name ("{name}") should be alphanumeric. Use "." for nesting (e.g. myfolder.my_artifact)'
 
 
-class Artifactories:
+class Catalogs:
     def __new__(cls):
         if not hasattr(cls, "instance"):
             cls.instance = super().__new__(cls)
-            cls.instance.artifactories = []
+            cls.instance.catalogs = []
 
         return cls.instance
 
@@ -57,42 +58,34 @@ class Artifactories:
         return self
 
     def __next__(self):
-        while self._index < len(self.artifactories):
-            artifactory = self.artifactories[self._index]
+        while self._index < len(self.catalogs):
+            catalog = self.catalogs[self._index]
             self._index += 1
             if (
-                settings.use_only_local_catalogs and not artifactory.is_local
+                settings.use_only_local_catalogs and not catalog.is_local
             ):  # Corrected typo from 'is_loacl' to 'is_local'
                 continue
-            return artifactory
+            return catalog
         raise StopIteration
 
-    def register(self, artifactory):
+    def register(self, catalog):
         assert isinstance(
-            artifactory, Artifactory
-        ), "Artifactory must be an instance of Artifactory"
-        assert hasattr(
-            artifactory, "__contains__"
-        ), "Artifactory must have __contains__ method"
-        assert hasattr(
-            artifactory, "__getitem__"
-        ), "Artifactory must have __getitem__ method"
-        self.artifactories = [artifactory, *self.artifactories]
-
-    def unregister(self, artifactory):
+            catalog, AbstractCatalog
+        ), "catalog must be an instance of AbstractCatalog"
+        assert hasattr(catalog, "__contains__"), "catalog must have __contains__ method"
+        assert hasattr(catalog, "__getitem__"), "catalog must have __getitem__ method"
+        self.catalogs = [catalog, *self.catalogs]
+
+    def unregister(self, catalog):
         assert isinstance(
-            artifactory, Artifactory
-        ), "Artifactory must be an instance of Artifactory"
-        assert hasattr(
-            artifactory, "__contains__"
-        ), "Artifactory must have __contains__ method"
-        assert hasattr(
-            artifactory, "__getitem__"
-        ), "Artifactory must have __getitem__ method"
-        self.artifactories.remove(artifactory)
+            catalog, AbstractCatalog
+        ), "catalog must be an instance of Catalog"
+        assert hasattr(catalog, "__contains__"), "catalog must have __contains__ method"
+        assert hasattr(catalog, "__getitem__"), "catalog must have __getitem__ method"
+        self.catalogs.remove(catalog)
 
     def reset(self):
-        self.artifactories = []
+        self.catalogs = []
 
 
 def map_values_in_place(object, mapper):
@@ -369,14 +362,19 @@ class Artifact(Dataclass):
         if not data_classification_policy:
             return instance
 
+        if not isoftype(instance, Dict[str, Any]):
+            raise ValueError(
+                f"The instance passed to inference engine is not a dictionary. Instance:\n{instance}"
+            )
         instance_data_classification = instance.get("data_classification_policy")
         if not instance_data_classification:
-            get_logger().warning(
+            UnitxtWarning(
                 f"The data does not provide information if it can be used by "
                 f"'{name}' with the following data classification policy "
                 f"'{data_classification_policy}'. This may lead to sending of undesired "
                 f"data to external service. Set the 'data_classification_policy' "
-                f"of the data to ensure a proper handling of sensitive information."
+                f"of the data to ensure a proper handling of sensitive information.",
+                Documentation.DATA_CLASSIFICATION_POLICY,
             )
             return instance
 
@@ -384,14 +382,15 @@ class Artifact(Dataclass):
             data_classification in data_classification_policy
             for data_classification in instance_data_classification
         ):
-            raise ValueError(
+            raise UnitxtError(
                 f"The instance '{instance} 'has the following data classification policy "
                 f"'{instance_data_classification}', however, the artifact '{name}' "
                 f"is only configured to support the data with classification "
                 f"'{data_classification_policy}'. To enable this either change "
                 f"the 'data_classification_policy' attribute of the artifact, "
                 f"or modify the environment variable "
-                f"'UNITXT_DATA_CLASSIFICATION_POLICY' accordingly."
+                f"'UNITXT_DATA_CLASSIFICATION_POLICY' accordingly.",
+                Documentation.DATA_CLASSIFICATION_POLICY,
             )
 
         return instance
@@ -419,7 +418,7 @@ class ArtifactList(list, Artifact):
             artifact.prepare()
 
 
-class Artifactory(Artifact):
+class AbstractCatalog(Artifact):
     is_local: bool = AbstractField()
 
     @abstractmethod
@@ -435,19 +434,19 @@ class Artifactory(Artifact):
         pass
 
 
-class UnitxtArtifactNotFoundError(Exception):
-    def __init__(self, name, artifactories):
+class UnitxtArtifactNotFoundError(UnitxtError):
+    def __init__(self, name, catalogs):
         self.name = name
-        self.artifactories = artifactories
-
-    def __str__(self):
-        msg = f"Artifact {self.name} does not exist, in artifactories:{self.artifactories}."
+        self.catalogs = catalogs
+        msg = (
+            f"Artifact {self.name} does not exist, in Unitxt catalogs: {self.catalogs}."
+        )
         if settings.use_only_local_catalogs:
-            msg += f" Notice that unitxt.settings.use_only_local_catalogs is set to True, if you want to use remote catalogs set this settings or the environment variable {settings.use_only_local_catalogs_key}."
-        return f"Artifact {self.name} does not exist, in artifactories:{self.artifactories}"
+            msg += f"\nNotice that unitxt.settings.use_only_local_catalogs is set to True, if you want to use remote catalogs set this settings or the environment variable {settings.use_only_local_catalogs_key}."
+        super().__init__(msg)
 
 
-def fetch_artifact(artifact_rep) -> Tuple[Artifact, Union[Artifactory, None]]:
+def fetch_artifact(artifact_rep) -> Tuple[Artifact, Union[AbstractCatalog, None]]:
     """Loads an artifict from one of possible representations.
 
     (1) If artifact representation is already an Artifact object, return it.
@@ -467,12 +466,10 @@ def fetch_artifact(artifact_rep) -> Tuple[Artifact, Union[Artifactory, None]]:
     if isinstance(artifact_rep, str):
         name, _ = separate_inside_and_outside_square_brackets(artifact_rep)
         if is_name_legal_for_catalog(name):
-            artifactory, artifact_rep, args = get_artifactory_name_and_args(
-                name=artifact_rep
-            )
-            return artifactory.get_with_overwrite(
+            catalog, artifact_rep, args = get_catalog_name_and_args(name=artifact_rep)
+            return catalog.get_with_overwrite(
                 artifact_rep, overwrite_args=args
-            ), artifactory
+            ), catalog
 
     # If Json string, first load into dictionary
     if isinstance(artifact_rep, str):
@@ -481,24 +478,24 @@ def fetch_artifact(artifact_rep) -> Tuple[Artifact, Union[Artifactory, None]]:
     return Artifact.from_dict(artifact_rep), None
 
 
-def get_artifactory_name_and_args(
-    name: str, artifactories: Optional[List[Artifactory]] = None
+def get_catalog_name_and_args(
+    name: str, catalogs: Optional[List[AbstractCatalog]] = None
 ):
     name, args = separate_inside_and_outside_square_brackets(name)
 
-    if artifactories is None:
-        artifactories = list(Artifactories())
+    if catalogs is None:
+        catalogs = list(Catalogs())
 
-    for artifactory in artifactories:
-        if name in artifactory:
-            return artifactory, name, args
+    for catalog in catalogs:
+        if name in catalog:
+            return catalog, name, args
 
-    raise UnitxtArtifactNotFoundError(name, artifactories)
+    raise UnitxtArtifactNotFoundError(name, catalogs)
 
 
 def verbosed_fetch_artifact(identifier):
-    artifact, artifactory = fetch_artifact(identifier)
-    logger.debug(f"Artifact {identifier} is fetched from {artifactory}")
+    artifact, catalog = fetch_artifact(identifier)
+    logger.debug(f"Artifact {identifier} is fetched from {catalog}")
     return artifact
 
 
@@ -569,10 +566,11 @@ def get_artifacts_data_classification(artifact: str) -> Optional[List[str]]:
                 for artifact_data_classification in artifact_data_classifications
             )
         ):
-            raise RuntimeError(
+            raise UnitxtError(
                 "'UNITXT_DATA_CLASSIFICATION_POLICY' should be of type "
                 "'Dict[str, List[str]]', where a artifact's name is a key, and a "
-                "value is a list of data classifications used by that artifact."
+                "value is a list of data classifications used by that artifact.",
+                Documentation.DATA_CLASSIFICATION_POLICY,
             )
 
     if artifact not in data_classification.keys():

augmentors.py

@@ -9,16 +9,14 @@ from typing import (
 
 from .operators import FieldOperator
 from .random_utils import new_random_generator
-from .type_utils import isoftype
+from .type_utils import isoftype, parse_type_string, to_type_string
+from .types import Text
 
 
 class Augmentor(FieldOperator):
     """A stream operator that augments the values of either the task input fields before rendering with the template,  or the input passed to the model after rendering of the template."""
 
-    operator: FieldOperator
-
-    def process_value(self, value: Any) -> Any:
-        return self.operator.process_value(value)
+    pass
 
 
 class TaskInputsAugmentor(Augmentor):
@@ -27,31 +25,38 @@ class TaskInputsAugmentor(Augmentor):
         self.field_to_field = {field: field for field in fields}
 
 
-class FinalStateInputsAugmentor(Augmentor):
-    pass
+class TypeDependentAugmentor(TaskInputsAugmentor):
+    augmented_type: object
 
+    def process_instance_value(self, value: Any, instance: Dict[str, Any]):
+        if not isoftype(value, self.augmented_type):
+            return value
+        return super().process_instance_value(value=value, instance=instance)
 
-class ModelInputAugmentor(FinalStateInputsAugmentor):
-    field = "source"
+    @classmethod
+    def process_data_after_load(cls, data):
+        if "augmented_type" in data:
+            data["augmented_type"] = parse_type_string(data["augmented_type"])
+        return data
 
+    def process_data_before_dump(self, data):
+        if "augmented_type" in data:
+            data["augmented_type"] = to_type_string(data["augmented_type"])
+        return data
 
-class ImagesAugmentor(FinalStateInputsAugmentor):
-    field = "media/images"
-    process_every_value = True
 
-
-class Identity(FieldOperator):
-    def process_value(self, value: Any) -> Any:
-        return value
+class TextAugmentor(TypeDependentAugmentor):
+    augmented_type = Text
 
 
 class NullAugmentor(Augmentor):
     """Does not change the input string."""
 
-    operator = Identity()
+    def process_value(self, value: Any) -> Any:
+        return value
 
 
-class AugmentWhitespace(FieldOperator):
+class AugmentWhitespace(TextAugmentor):
     """Augments the inputs by replacing existing whitespaces with other whitespaces.
 
     Currently, each whitespace is replaced by a random choice of 1-3 whitespace characters (space, tab, newline).
@@ -74,7 +79,7 @@ class AugmentWhitespace(FieldOperator):
         return new_value
 
 
-class AugmentPrefixSuffix(FieldOperator):
+class AugmentPrefixSuffix(TextAugmentor):
     r"""Augments the input by prepending and appending randomly selected (typically, whitespace) patterns.
 
     Args:

benchmark.py

@@ -1,3 +1,4 @@
+from abc import abstractmethod
 from typing import Dict, Union
 
 from .dataclass import NonPositionalField
@@ -15,6 +16,10 @@ class BaseBenchmark(SourceOperator):
     system_prompt: SystemPrompt = NonPositionalField(default=None)
     loader_limit: int = NonPositionalField(default=None)
 
+    @abstractmethod
+    def reset(self):
+        pass
+
 
 class Benchmark(BaseBenchmark):
     subsets: Dict[str, Union[StandardRecipe, BaseBenchmark]]
@@ -23,14 +28,20 @@ class Benchmark(BaseBenchmark):
     max_samples_per_subset: int = None
 
     def verify(self):
+        super().verify()
         if (
             self.max_total_samples is not None
             and self.max_samples_per_subset is not None
         ):
             raise ValueError("Set either max_total_samples or max_samples_per_subset")
 
-    def prepare(self):
-        if self.format is not None or self.num_demos is not None:
+    def reset(self):
+        if (
+            self.format is not None
+            or self.num_demos is not None
+            or self.system_prompt is not None
+            or self.loader_limit is not None
+        ):
             for subset in self.subsets.values():
                 if self.num_demos is not None:
                     subset.num_demos = self.num_demos
@@ -40,7 +51,13 @@ class Benchmark(BaseBenchmark):
                     subset.system_prompt = self.system_prompt
                 if self.loader_limit is not None:
                     subset.loader_limit = self.loader_limit
-                subset.prepare()
+
+                subset.reset()
+
+    def prepare(self):
+        super().prepare()
+
+        self.reset()
 
     def process(
         self,

catalog.py

@@ -8,10 +8,10 @@ from typing import Optional
 import requests
 
 from .artifact import (
+    AbstractCatalog,
     Artifact,
-    Artifactories,
-    Artifactory,
-    get_artifactory_name_and_args,
+    Catalogs,
+    get_catalog_name_and_args,
     reset_artifacts_json_cache,
     verify_legal_catalog_name,
 )
@@ -24,10 +24,13 @@ logger = get_logger()
 constants = get_constants()
 
 
-class Catalog(Artifactory):
+class Catalog(AbstractCatalog):
     name: str = None
     location: str = None
 
+    def __repr__(self):
+        return f"{self.location}"
+
 
 class LocalCatalog(Catalog):
     name: str = "local"
@@ -145,13 +148,11 @@ def get_from_catalog(
         catalog = LocalCatalog(location=catalog_path)
 
     if catalog is None:
-        artifactories = None
+        catalogs = None
     else:
-        artifactories = [catalog]
+        catalogs = [catalog]
 
-    catalog, name, args = get_artifactory_name_and_args(
-        name, artifactories=artifactories
-    )
+    catalog, name, args = get_catalog_name_and_args(name, catalogs=catalogs)
 
     return catalog.get_with_overwrite(
         name=name,
@@ -161,10 +162,10 @@ def get_from_catalog(
 
 def get_local_catalogs_paths():
     result = []
-    for artifactory in Artifactories():
-        if isinstance(artifactory, LocalCatalog):
-            if artifactory.is_local:
-                result.append(artifactory.location)
+    for catalog in Catalogs():
+        if isinstance(catalog, LocalCatalog):
+            if catalog.is_local:
+                result.append(catalog.location)
     return result
 
 

data.py

@@ -1,4 +1,5 @@
 import os
+from typing import Optional, Union
 
 import datasets
 
@@ -44,6 +45,7 @@ from .random_utils import __file__ as _
 from .recipe import __file__ as _
 from .register import __file__ as _
 from .schema import __file__ as _
+from .schema import loads_instance
 from .serializers import __file__ as _
 from .settings_utils import __file__ as _
 from .settings_utils import get_constants
@@ -65,15 +67,12 @@ from .utils import __file__ as _
 from .utils import is_package_installed
 from .validate import __file__ as _
 from .version import __file__ as _
-from .version import version
 
 logger = get_logger()
 constants = get_constants()
 
 
 class Dataset(datasets.GeneratorBasedBuilder):
-    """TODO: Short description of my dataset."""
-
     VERSION = constants.version
 
     @property
@@ -114,3 +113,16 @@ class Dataset(datasets.GeneratorBasedBuilder):
         return super()._download_and_prepare(
             dl_manager, "no_checks", **prepare_splits_kwargs
         )
+
+    def as_dataset(
+        self,
+        split: Optional[datasets.Split] = None,
+        run_post_process=True,
+        verification_mode: Optional[Union[datasets.VerificationMode, str]] = None,
+        in_memory=False,
+    ) -> Union[datasets.Dataset, datasets.DatasetDict]:
+        return (
+            super()
+            .as_dataset(split, run_post_process, verification_mode, in_memory)
+            .with_transform(loads_instance)
+        )

error_utils.py

@@ -10,9 +10,12 @@ class Documentation:
     HUGGINGFACE_METRICS = "docs/adding_metric.html#adding-a-hugginface-metric"
     ADDING_TASK = "docs/adding_task.html"
     ADDING_TEMPLATE = "docs/adding_template.html"
+    POST_PROCESSORS = "docs/adding_template.html#post-processors"
     MULTIPLE_METRICS_OUTPUTS = (
         "docs/adding_metric.html#metric-outputs-with-multiple-metrics"
     )
+    DATA_CLASSIFICATION_POLICY = "docs/data_classification_policy.html"
+    CATALOG = "docs/saving_and_loading_from_catalog.html"
 
 
 def additional_info(path: str) -> str:

formats.py

@@ -1,15 +1,25 @@
 import re
+from abc import abstractmethod
 from typing import (
     Any,
     Dict,
     List,
+    Literal,
     Optional,
+    Tuple,
+    TypedDict,
+    Union,
 )
 
 from .dataclass import OptionalField
+from .dict_utils import dict_get
+from .image_operators import image_to_data_url
 from .operator import InstanceOperator
+from .settings_utils import get_constants
 from .type_utils import isoftype
 
+constants = get_constants()
+
 
 class Format(InstanceOperator):
     pass
@@ -59,9 +69,7 @@ class BaseFormat(Format):
     demos_field: str = "demos"
 
     @staticmethod
-    def _retrieve_field_and_pop_from_instance(
-        instance, field_name, do_pop: bool = True
-    ) -> str:
+    def _pop_field(instance, field_name, do_pop: bool = True) -> str:
         if field_name is not None and field_name in instance:
             field_value = instance[field_name]
             if do_pop:
@@ -72,6 +80,53 @@ class BaseFormat(Format):
             return field_value
         return ""
 
+    def _prepare_instance_fields(self, instance) -> Tuple[str]:
+        instance_fields = {}
+
+        for field in "source", "instruction", "system_prompt", "target_prefix":
+            instance_fields[field] = self._pop_field(instance, field)
+
+        instance_fields["media"] = self._pop_field(instance, "media", do_pop=False)
+        if not instance_fields["media"]:
+            instance_fields["media"] = {"images": [], "audios": []}
+
+        instance_fields["demos"] = []
+        if self.demos_field is not None and self.demos_field in instance:
+            demos = instance[self.demos_field]
+            assert (
+                demos is not None and isoftype(demos, List[Dict[str, Any]])
+            ), f"A list of dict-s is expected in field '{self.demos_field}'. Received instance: {instance}"
+            for demo_instance in demos:
+                demo = {}
+                for field in ["source", "target", "target_prefix"]:
+                    demo[field] = self._pop_field(demo_instance, field, do_pop=False)
+                instance_fields["demos"].append(demo)
+
+        return instance_fields
+
+    @abstractmethod
+    def _format_instance_to_source(
+        self,
+        system_prompt: str,
+        instruction: str,
+        source: str,
+        target_prefix: str,
+        demos: List[Dict[str, Any]],
+        media: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """Abstract method for formatting instances in different subclasses.
+
+        Subclasses should implement this method to define specific formatting behavior.
+        """
+        return ""
+
+    def process(
+        self, instance: Dict[str, Any], stream_name: Optional[str] = None
+    ) -> Dict[str, Any]:
+        instance_fields = self._prepare_instance_fields(instance)
+        instance["source"] = self._format_instance_to_source(**instance_fields)
+        return instance
+
 
 class SystemFormat(BaseFormat):
     r"""Generates the whole input to the model, from constant strings that are given as args, and from values found in specified fields of the instance.
@@ -137,51 +192,19 @@ class SystemFormat(BaseFormat):
     )
     format_args: Dict[str, str] = OptionalField(default_factory=dict)
 
-    def process(
-        self, instance: Dict[str, Any], stream_name: Optional[str] = None
-    ) -> Dict[str, Any]:
-        assert (
-            "source" in instance
-        ), f"field 'source' is expected to be in the input instance. Received instance: {instance}"
-        source = self._retrieve_field_and_pop_from_instance(
-            instance=instance, field_name="source"
-        )
-
-        instruction = self._retrieve_field_and_pop_from_instance(
-            instance=instance, field_name="instruction"
-        )
-        target_prefix = self._retrieve_field_and_pop_from_instance(
-            instance=instance, field_name="target_prefix"
-        )
-        system_prompt = self._retrieve_field_and_pop_from_instance(
-            instance=instance, field_name="system_prompt"
-        )
-
-        demo_instances = []
-        if self.demos_field is not None and self.demos_field in instance:
-            demos = instance[self.demos_field]
-            assert (
-                demos is not None and isoftype(demos, List[Dict[str, Any]])
-            ), f"A list of dict-s is expected in field '{self.demos_field}'. Received instance: {instance}"
-            demo_instances = demos
-            # instance.pop(self.demos_field)
-
+    def _format_instance_to_source(
+        self,
+        system_prompt: str,
+        instruction: str,
+        source: str,
+        target_prefix: str,
+        demos: List[Dict[str, Any]],
+        media: Optional[Dict[str, Any]] = None,
+    ) -> str:
         demos_string = ""
-        for demo_instance in demo_instances:
-            demo_source = self._retrieve_field_and_pop_from_instance(
-                instance=demo_instance, field_name="source", do_pop=False
-            )
-            demo_target = self._retrieve_field_and_pop_from_instance(
-                instance=demo_instance, field_name="target", do_pop=False
-            )
-            demo_target_prefix = self._retrieve_field_and_pop_from_instance(
-                instance=demo_instance, field_name="target_prefix", do_pop=False
-            )
-
+        for demo in demos:
             demo_str = self.demo_format.format(
-                target_prefix=demo_target_prefix,
-                source=demo_source,
-                target=demo_target,
+                **demo,
                 instruction=instruction,
                 **self.format_args,
             )
@@ -195,12 +218,209 @@ class SystemFormat(BaseFormat):
             target_prefix=target_prefix,
             **self.format_args,
         )
-        output = apply_capital_new_line_notation(output)
-        instance["source"] = output
-        return instance
 
+        return apply_capital_new_line_notation(output)
+
+
+class TextContent(TypedDict):
+    type: Literal["text"]
+    text: str
+
+
+class ImageUrlContent(TypedDict):
+    type: Literal["image_url"]
+    image_url: Dict[Literal["url"], str]
+
+
+class ImageFileContent(TypedDict):
+    type: Literal["image_file"]
+    image_file: Dict[Literal["file_id"], str]
+
+
+Content = Union[TextContent, ImageUrlContent, ImageFileContent]
+
+
+class Message(TypedDict):
+    role: Literal["system", "user", "assistant"]
+    content: Union[str, List[Content]]
+
+
+class ChatAPIFormat(BaseFormat):
+    r"""Formats output for LLM APIs using OpenAI's chat schema.
+
+    Many API services use OpenAI's chat format as a standard for conversational models.
+    `OpenAIFormat` prepares the output in this API-compatible format, converting input
+    instances into OpenAI's structured chat format, which supports both text and
+    multimedia elements, like images.
+
+    The formatted output can be easily converted to a dictionary using `json.loads()`
+    to make it ready for direct use with OpenAI's API.
+
+    Example:
+        Given an input instance:
+
+        .. code-block:: python
+
+            {
+                "source": "<img src='https://example.com/image1.jpg'>What's in this image?",
+                "target": "A dog",
+                "instruction": "Help the user.",
+            },
+
+        When processed by:
+
+        .. code-block:: python
+
+            system_format = OpenAIFormat()
 
-class HFSystemFormat(BaseFormat):
+        The resulting formatted output is:
+
+        .. code-block:: python
+
+            {
+                "target": "A dog",
+                "source": '[{"role": "system", "content": "Help the user."}, '
+                          '{"role": "user", "content": [{"type": "image_url", '
+                          '"image_url": {"url": "https://example.com/image1.jpg", "detail": "low"}}, '
+                          '{"type": "text", "text": "What\'s in this image?"}]}]'
+            }
+
+        This `source` field is a JSON-formatted string. To make it ready for OpenAI's API,
+        you can convert it to a dictionary using `json.loads()`:
+
+        .. code-block:: python
+
+            import json
+
+            messages = json.loads(formatted_output["source"])
+
+            response = client.chat.completions.create(
+                model="gpt-4o",
+                messages=messages,
+            )
+
+        The resulting `messages` is now a dictionary ready for sending to the OpenAI API.
+    """
+
+    def to_content(self, text: str, media: Dict[str, Any]) -> Union[str, List[Content]]:
+        # Regular expression to find <img> tags with src attribute
+        img_tag_pattern = re.compile(
+            r"<" + f"{constants.image_tag}" + r'\s+[^>]*src=["\']([^"\']+)["\'][^>]*>',
+            re.IGNORECASE,
+        )
+
+        # Find all matches of <img> tags and their positions
+        matches = list(img_tag_pattern.finditer(text))
+
+        # If no images are found, return the text as a plain string
+        if not matches:
+            return text
+
+        contents: List[dict] = []
+        last_pos = 0
+
+        # Process each match
+        for match in matches:
+            start, end = match.span()
+            img_url = match.group(1)
+
+            # Add preceding text, if any
+            if last_pos < start:
+                contents.append({"type": "text", "text": text[last_pos:start]})
+
+            # Add image content with a default detail level
+            if img_url.startswith("media/"):
+                image = dict_get(media, img_url[6:])
+                data_url = image_to_data_url(image)
+                contents.append(
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": data_url, "detail": "low"},
+                    }
+                )
+            else:
+                contents.append(
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": img_url, "detail": "low"},
+                    }
+                )
+
+            # Update the last processed position
+            last_pos = end
+
+        # Add any remaining text after the last image
+        if last_pos < len(text):
+            contents.append({"type": "text", "text": text[last_pos:]})
+
+        return contents
+
+    def to_chat(
+        self,
+        system_prompt: str,
+        instruction: str,
+        source: str,
+        target_prefix: str,
+        demos: List[Dict[str, Any]],
+        media: Optional[Dict[str, Any]] = None,
+    ) -> List[Message]:
+        messages = []
+
+        if system_prompt or instruction:
+            system_content = self.to_content(
+                system_prompt + ("\n" if system_prompt != "" else "") + instruction,
+                media,
+            )
+            messages.append(
+                {
+                    "role": "system",
+                    "content": system_content,
+                }
+            )
+
+        for demo_instance in demos:
+            user_content = self.to_content(demo_instance["source"], media)
+            assistant_content = self.to_content(
+                target_prefix + demo_instance["target"], media
+            )
+            messages.extend(
+                [
+                    {"role": "user", "content": user_content},
+                    {
+                        "role": "assistant",
+                        "content": assistant_content,
+                    },
+                ]
+            )
+
+        last_user_content = self.to_content(source, media)
+
+        messages.extend([{"role": "user", "content": last_user_content}])
+
+        return messages
+
+    def _format_instance_to_source(
+        self,
+        system_prompt: str,
+        instruction: str,
+        source: str,
+        target_prefix: str,
+        demos: List[Dict[str, Any]],
+        media: Optional[Dict[str, Any]] = None,
+    ) -> Union[str, List[Message]]:
+        chat = self.to_chat(
+            system_prompt,
+            instruction,
+            source,
+            target_prefix,
+            demos,
+            media,
+        )
+        media["images"] = []
+        return chat
+
+
+class HFSystemFormat(ChatAPIFormat):
     r"""Formats the complete input for the model using the HuggingFace chat template of a given model.
 
     HFSystemFormat expects the input instance to contain:
@@ -227,65 +447,29 @@ class HFSystemFormat(BaseFormat):
     """
 
     model_name: str
-    _requirements_list = ["transformers"]
+    _requirements_list = ["transformers", "Jinja2"]
 
     def prepare(self):
+        super().prepare()
         from transformers import AutoTokenizer
 
         self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
 
-    def process(
-        self, instance: Dict[str, Any], stream_name: Optional[str] = None
-    ) -> Dict[str, Any]:
-        assert (
-            "source" in instance
-        ), f"field 'source' is expected to be in the input instance. Received instance: {instance}"
-
-        source = self._retrieve_field_and_pop_from_instance(
-            instance=instance, field_name="source"
-        )
-
-        instruction = self._retrieve_field_and_pop_from_instance(
-            instance=instance, field_name="instruction"
-        )
-        target_prefix = self._retrieve_field_and_pop_from_instance(
-            instance=instance, field_name="target_prefix"
-        )
-        system_prompt = self._retrieve_field_and_pop_from_instance(
-            instance=instance, field_name="system_prompt"
+    def _format_instance_to_source(
+        self,
+        system_prompt: str,
+        instruction: str,
+        source: str,
+        target_prefix: str,
+        demos: List[Dict[str, Any]],
+        media: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        chat = self.to_chat(
+            system_prompt, instruction, source, target_prefix, demos, media
         )
-
-        messages = [
-            {
-                "role": "system",
-                "content": system_prompt
-                + ("\n" if system_prompt != "" else "")
-                + instruction,
-            },
-        ]
-        demo_instances = []
-        if self.demos_field is not None and self.demos_field in instance:
-            demos = instance[self.demos_field]
-            assert (
-                demos is not None and isoftype(demos, List[Dict[str, Any]])
-            ), f"A list of dict-s is expected in field '{self.demos_field}'. Received instance: {instance}"
-            demo_instances = demos
-            # instance.pop(self.demos_field)
-
-        for demo_instance in demo_instances:
-            messages.extend(
-                [
-                    {"role": "user", "content": demo_instance["source"]},
-                    {
-                        "role": "assistant",
-                        "content": target_prefix + demo_instance["target"],
-                    },
-                ]
+        return (
+            self.tokenizer.apply_chat_template(
+                chat, tokenize=False, add_generation_prompt=True
             )
-        messages.extend([{"role": "user", "content": source}])
-        tokenized_chat = self.tokenizer.apply_chat_template(
-            messages, tokenize=False, add_generation_prompt=True
+            + target_prefix
         )
-
-        instance["source"] = tokenized_chat + target_prefix
-        return instance

generator_utils.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, List
 
 from .dataclass import Dataclass, OptionalField
-from .utils import recursive_shallow_copy
+from .utils import recursive_copy
 
 
 class ReusableGenerator(Dataclass):
@@ -22,4 +22,4 @@ class ReusableGenerator(Dataclass):
 class CopyingReusableGenerator(ReusableGenerator):
     def __iter__(self):
         for instance in self.activate():
-            yield recursive_shallow_copy(instance)
+            yield recursive_copy(instance)

image_operators.py

@@ -2,12 +2,71 @@ import base64
 import io
 import re
 from abc import abstractmethod
-from typing import Any, Dict
+from typing import Any, Dict, Tuple
 
 import numpy as np
+from datasets import Image as DatasetsImage
 
+from .augmentors import TaskInputsAugmentor
 from .dict_utils import dict_get
-from .operators import FieldOperator, InstanceFieldOperator, PackageRequirementsMixin
+from .operator import PackageRequirementsMixin
+from .operators import FieldOperator, InstanceFieldOperator
+from .settings_utils import get_constants
+from .type_utils import isoftype
+from .types import Image
+
+constants = get_constants()
+
+datasets_image = DatasetsImage()
+
+
+def _image_to_bytes(image, format="JPEG"):
+    import base64
+
+    with io.BytesIO() as buffer:
+        image.save(buffer, format=format)
+        return base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+
+def image_to_data_url(image: Image, default_format="JPEG"):
+    """Convert an image to a data URL.
+
+    https://developer.mozilla.org/en-US/docs/Web/URI/Schemes/data
+    """
+    image_format = image["format"] if image["format"] else default_format
+    base64_image = _image_to_bytes(image["image"], format=image_format.upper())
+    return f"data:image/{image_format.lower()};base64,{base64_image}"
+
+
+def _bytes_to_image(b64_string):
+    import base64
+    import io
+
+    from PIL import Image
+
+    # Decode the base64-encoded string
+    decoded_bytes = base64.b64decode(b64_string)
+    # Open the image from the decoded bytes
+    return Image.open(io.BytesIO(decoded_bytes))
+
+
+def data_url_to_image(data_url: str):
+    import re
+
+    # Verify that the string is a data URL
+    if not data_url.startswith("data:"):
+        raise ValueError("Invalid data URL")
+
+    # Extract the base64 data using a regular expression
+    match = re.match(r"data:image/(.*?);base64,(.*)", data_url)
+    if not match:
+        raise ValueError("Invalid data URL format")
+
+    # Extract image format and base64 data
+    image_format, b64_data = match.groups()
+
+    # Use _bytes_to_image to convert base64 data to an image
+    return _bytes_to_image(b64_data)
 
 
 class PillowMixin(PackageRequirementsMixin):
@@ -16,14 +75,16 @@ class PillowMixin(PackageRequirementsMixin):
     def prepare(self):
         super().prepare()
         import PIL
-        from PIL import Image
+        from PIL import Image, ImageEnhance, ImageFilter
 
         self.pil = PIL
         self.image = Image
+        self.enhance = ImageEnhance
+        self.filter = ImageFilter
 
 
 def extract_images(text, instance):
-    regex = r'<img\s+src=["\'](.*?)["\']'
+    regex = r"<" + f"{constants.image_tag}" + r'\s+src=["\'](.*?)["\']'
     image_sources = re.findall(regex, text)
     images = []
     for image_source in image_sources:
@@ -33,31 +94,46 @@ def extract_images(text, instance):
 
 
 class DecodeImage(FieldOperator, PillowMixin):
-    def decode_base64_to_image(self, base64_string):
-        image_data = base64.b64decode(base64_string)
+    def process_value(self, value: str) -> Any:
+        image_data = base64.b64decode(value)
         return self.image.open(io.BytesIO(image_data))
 
-    def process_value(self, value: Any) -> Any:
-        return {"image": self.decode_base64_to_image(value)}
-
 
 class ToImage(InstanceFieldOperator):
-    def process_instance_value(self, value: Any, instance: Dict[str, Any]):
-        return {"image": value}
+    def process_instance_value(self, value: Any, instance: Dict[str, Any]) -> Image:
+        return {
+            "image": value,
+            "format": value.format if value.format is not None else "JPEG",
+        }
 
 
 class ImageFieldOperator(FieldOperator, PillowMixin):
     @abstractmethod
-    def process_image(self, image):
+    def process_image(self, image: Any):
         pass
 
-    def process_value(self, value: Any) -> Any:
-        if not isinstance(value, self.image.Image):
+    def process_value(self, value: Image) -> Any:
+        if not isinstance(value["image"], self.image.Image):
             raise ValueError(f"ImageFieldOperator requires image, got {type(value)}.")
-        return self.process_image(value)
+        value["image"] = self.process_image(value["image"])
+        return value
 
 
-class GrayScale(ImageFieldOperator):
+class ImageAugmentor(TaskInputsAugmentor, PillowMixin):
+    augmented_type: object = Image
+
+    @abstractmethod
+    def process_image(self, image: Any):
+        pass
+
+    def process_value(self, value: Image) -> Any:
+        if not isoftype(value, Image):
+            return value
+        value["image"] = self.process_image(value["image"])
+        return value
+
+
+class GrayScale(ImageAugmentor):
     def process_image(self, image):
         # Convert the image to grayscale
         grayscale_image = image.convert("L")
@@ -75,6 +151,128 @@ class GrayScale(ImageFieldOperator):
         return self.image.fromarray(grayscale_array)
 
 
+class GridLines(ImageAugmentor):
+    """A class that overlays a fixed number of evenly spaced horizontal and vertical lines on an image.
+
+    Attributes:
+    - num_lines (int): The number of horizontal and vertical lines to add.
+    - line_thickness (int): Thickness of each line in pixels.
+    - line_color (Tuple[int, int, int]): RGB color of the grid lines.
+
+    Methods:
+    - process_image(image): Adds grid lines to the provided image and returns the modified image.
+    """
+
+    num_lines: int = 128
+    line_thickness: int = 1
+    line_color: Tuple[int, int, int] = (255, 255, 255)
+
+    def process_image(self, image):
+        image_array = np.array(image)
+
+        # Determine image dimensions
+        height, width, _ = image_array.shape
+
+        # Calculate spacing for the lines based on image size and number of lines
+        horizontal_spacing = height // (self.num_lines + 1)
+        vertical_spacing = width // (self.num_lines + 1)
+
+        # Add horizontal lines
+        for i in range(1, self.num_lines + 1):
+            y = i * horizontal_spacing
+            image_array[y : y + self.line_thickness, :, :] = self.line_color
+
+        # Add vertical lines
+        for i in range(1, self.num_lines + 1):
+            x = i * vertical_spacing
+            image_array[:, x : x + self.line_thickness, :] = self.line_color
+
+        # Convert back to a PIL image
+        return self.image.fromarray(image_array)
+
+
+class PixelNoise(ImageAugmentor):
+    """A class that overlays a mask of randomly colored nxn squares across an image based on a specified noise rate.
+
+    Attributes:
+    - square_size (int): Size of each square in pixels.
+    - noise_rate (float): Proportion of the image that should be affected by noise (0 to 1).
+
+    Methods:
+    - process_image(image): Adds the random square mask to the provided image and returns the modified image.
+    """
+
+    square_size: int = 1
+    noise_rate: float = 0.3  # Percentage of squares to be randomly colored
+
+    def process_image(self, image):
+        image_array = np.array(image)
+        height, width, channels = image_array.shape
+
+        # Calculate grid dimensions
+        y_squares = height // self.square_size
+        x_squares = width // self.square_size
+
+        # Create a grid indicating where to apply the mask
+        noise_mask = np.random.rand(y_squares, x_squares) < self.noise_rate
+
+        # Generate random colors for each square
+        colors = np.random.randint(
+            0, 256, (y_squares, x_squares, channels), dtype=np.uint8
+        )
+
+        # Expand the mask and colors to the size of the image array
+        mask_expanded = np.repeat(
+            np.repeat(noise_mask, self.square_size, axis=0), self.square_size, axis=1
+        )
+        colors_expanded = np.repeat(
+            np.repeat(colors, self.square_size, axis=0), self.square_size, axis=1
+        )
+
+        # Reshape `mask_expanded` to add the color channel dimension
+        mask_expanded = np.repeat(mask_expanded[:, :, np.newaxis], channels, axis=2)
+
+        # Apply colors where the mask is true using element-wise assignment
+        image_array = np.where(mask_expanded, colors_expanded, image_array)
+
+        # Convert back to a PIL image
+        return self.image.fromarray(image_array)
+
+
+class Oldify(ImageAugmentor):
+    noise_strength: int = 30
+    tint_strength: float = 0.4  # Percentage of squares to be randomly colored
+
+    def process_image(self, image):
+        # Convert to a numpy array for manipulation
+        image_array = np.array(image)
+
+        # Step 1: Add a slight yellowish tint
+        yellow_tint = np.array([255, 228, 170], dtype=np.uint8)  # Aged paper-like color
+        tinted_image_array = (
+            image_array * (1 - self.tint_strength) + yellow_tint * self.tint_strength
+        ).astype(np.uint8)
+
+        # Step 2: Add noise for a "film grain" effect
+        noise = np.random.normal(0, self.noise_strength, image_array.shape).astype(
+            np.int16
+        )
+        noisy_image_array = np.clip(tinted_image_array + noise, 0, 255).astype(np.uint8)
+
+        # Step 3: Convert back to a PIL Image for additional processing
+        old_image = self.image.fromarray(noisy_image_array)
+
+        # Step 4: Apply a slight blur to mimic an older lens or slight wear
+        old_image = old_image.filter(self.filter.GaussianBlur(radius=1))
+
+        # Step 5: Adjust contrast and brightness to give it a "faded" look
+        enhancer = self.enhance.Contrast(old_image)
+        old_image = enhancer.enhance(0.6)  # Lower contrast
+
+        enhancer = self.enhance.Brightness(old_image)
+        return enhancer.enhance(1.2)  # Slightly increased brightness
+
+
 class ToRGB(ImageFieldOperator):
     def process_image(self, image):
         return image.convert("RGB")

inference.py

@@ -1,21 +1,50 @@
 import abc
+import asyncio
 import dataclasses
+import json
+import logging
 import os
 import re
+import sys
+import time
+import uuid
+from collections import Counter
 from typing import Any, Dict, List, Literal, Optional, Union
 
 from datasets import DatasetDict
-from tqdm import tqdm
+from tqdm import tqdm, trange
+from tqdm.asyncio import tqdm_asyncio
 
-from .artifact import Artifact, fetch_artifact
+from .artifact import Artifact
 from .dataclass import InternalField, NonPositionalField
 from .deprecation_utils import deprecation
-from .image_operators import extract_images
+from .error_utils import UnitxtError
+from .image_operators import data_url_to_image, extract_images
 from .logging_utils import get_logger
 from .operator import PackageRequirementsMixin
-from .settings_utils import get_settings
+from .operators import ArtifactFetcherMixin
+from .settings_utils import get_constants, get_settings
 
+constants = get_constants()
 settings = get_settings()
+logger = get_logger()
+
+
+class StandardAPIParamsMixin(Artifact):
+    model: str
+    frequency_penalty: Optional[float] = None
+    presence_penalty: Optional[float] = None
+    max_tokens: Optional[int] = None
+    seed: Optional[int] = None
+    stop: Union[Optional[str], List[str]] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    top_logprobs: Optional[int] = None
+    logit_bias: Optional[Dict[str, int]] = None
+    logprobs: Optional[bool] = None
+    n: Optional[int] = None
+    parallel_tool_calls: Optional[bool] = None
+    service_tier: Optional[Literal["auto", "default"]] = None
 
 
 def get_model_and_label_id(model_name, label):
@@ -49,7 +78,7 @@ class TextGenerationInferenceOutput:
     inference_type: Optional[str] = None
 
 
-class InferenceEngine(abc.ABC, Artifact):
+class InferenceEngine(Artifact):
     """Abstract base class for inference."""
 
     @abc.abstractmethod
@@ -73,6 +102,7 @@ class InferenceEngine(abc.ABC, Artifact):
 
     def prepare(self):
         if not settings.mock_inference_mode:
+            super().prepare()  # no need to prepare a mock
             self.prepare_engine()
 
     def infer(
@@ -93,9 +123,15 @@ class InferenceEngine(abc.ABC, Artifact):
 
         [self.verify_instance(instance) for instance in dataset]
         if settings.mock_inference_mode:
-            return [instance["source"] for instance in dataset]
+            return self._mock_infer(dataset)
         return self._infer(dataset, return_meta_data)
 
+    def _mock_infer(
+        self,
+        dataset: Union[List[Dict[str, Any]], DatasetDict],
+    ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
+        return [str(instance["source"]) for instance in dataset]
+
     def get_engine_id(self):
         raise NotImplementedError()
 
@@ -116,6 +152,22 @@ class InferenceEngine(abc.ABC, Artifact):
                 if param_inst_val is None:
                     setattr(self, param, param_dict_val)
 
+    def verify_not_chat_api(self, dataset):
+        if isinstance(dataset[0]["source"], list):
+            raise NotImplementedError(
+                f"Inference engine {self.__class__.__name__} does not support chat api format."
+            )
+
+    def to_messages(self, instance):
+        if isinstance(instance["source"], list):
+            return instance["source"]
+        return [
+            {
+                "role": "user",
+                "content": instance["source"],
+            }
+        ]
+
 
 class LogProbInferenceEngine(abc.ABC, Artifact):
     """Abstract base class for inference with log probs."""
@@ -170,6 +222,8 @@ class HFPipelineBasedInferenceEngine(
     model_name: str
     max_new_tokens: int
     use_fp16: bool = True
+    batch_size: int = 1
+    top_k: Optional[int] = None
 
     _requirements_list = {
         "transformers": "Install huggingface package using 'pip install --upgrade transformers"
@@ -178,9 +232,20 @@ class HFPipelineBasedInferenceEngine(
     def get_engine_id(self):
         return get_model_and_label_id(self.model_name, "hf_pipeline")
 
+    def _get_task(self):
+        from transformers import AutoConfig
+
+        return (
+            "text2text-generation"
+            if AutoConfig.from_pretrained(
+                self.model_name, trust_remote_code=True
+            ).is_encoder_decoder
+            else "text-generation"
+        )
+
     def _prepare_pipeline(self):
         import torch
-        from transformers import AutoConfig, pipeline
+        from transformers import pipeline
 
         model_args: Dict[str, Any] = (
             {"torch_dtype": torch.float16} if self.use_fp16 else {}
@@ -203,13 +268,7 @@ class HFPipelineBasedInferenceEngine(
         else:
             model_args.update({"device": device})
 
-        task = (
-            "text2text-generation"
-            if AutoConfig.from_pretrained(
-                self.model_name, trust_remote_code=True
-            ).is_encoder_decoder
-            else "text-generation"
-        )
+        task = self._get_task()
 
         if task == "text-generation":
             model_args.update({"return_full_text": False})
@@ -230,11 +289,18 @@ class HFPipelineBasedInferenceEngine(
         dataset: Union[List[Dict[str, Any]], DatasetDict],
         return_meta_data: bool = False,
     ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
+        if self._get_task() == "text2text-generation":
+            self.verify_not_chat_api(dataset)
+
         if not self._is_loaded():
             self._prepare_pipeline()
 
         outputs = []
-        for output in self.model([instance["source"] for instance in dataset]):
+        for output in self.model(
+            [instance["source"] for instance in dataset],
+            batch_size=self.batch_size,
+            top_k=self.top_k,
+        ):
             if isinstance(output, list):
                 output = output[0]
             outputs.append(output["generated_text"])
@@ -251,12 +317,18 @@ class MockInferenceEngine(InferenceEngine):
     def prepare_engine(self):
         return
 
+    def _mock_infer(
+        self,
+        dataset: Union[List[Dict[str, Any]], DatasetDict],
+    ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
+        return [self.default_inference_value for _ in dataset]
+
     def _infer(
         self,
         dataset: Union[List[Dict[str, Any]], DatasetDict],
         return_meta_data: bool = False,
     ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
-        return [self.default_inference_value for instance in dataset]
+        return self._mock_infer(dataset)
 
 
 class MockModeMixin(Artifact):
@@ -302,7 +374,7 @@ class IbmGenAiInferenceEngineParams(Artifact):
     typical_p: Optional[float] = None
 
 
-class GenericInferenceEngine(InferenceEngine):
+class GenericInferenceEngine(InferenceEngine, ArtifactFetcherMixin):
     default: Optional[str] = None
 
     def prepare_engine(self):
@@ -318,7 +390,7 @@ class GenericInferenceEngine(InferenceEngine):
                 "\nor passing a similar required engine in the default argument"
             )
             engine_reference = self.default
-        self.engine, _ = fetch_artifact(engine_reference)
+        self.engine = self.get_artifact(engine_reference)
 
     def get_engine_id(self):
         return "generic_inference_engine"
@@ -331,16 +403,17 @@ class GenericInferenceEngine(InferenceEngine):
         return self.engine._infer(dataset)
 
 
-class OllamaInferenceEngine(InferenceEngine, PackageRequirementsMixin):
+class OllamaInferenceEngine(
+    InferenceEngine, StandardAPIParamsMixin, PackageRequirementsMixin
+):
     label: str = "ollama"
-    model_name: str
     _requirements_list = {
         "ollama": "Install ollama package using 'pip install --upgrade ollama"
     }
     data_classification_policy = ["public", "proprietary"]
 
     def get_engine_id(self):
-        return get_model_and_label_id(self.model_name, self.label)
+        return get_model_and_label_id(self.model, self.label)
 
     def prepare_engine(self):
         pass
@@ -352,19 +425,117 @@ class OllamaInferenceEngine(InferenceEngine, PackageRequirementsMixin):
     ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
         import ollama
 
-        result = [
-            ollama.chat(
-                model="llama2",
-                messages=[
-                    {
-                        "role": "user",
-                        "content": instance["source"],
-                    },
-                ],
+        args = self.to_dict([StandardAPIParamsMixin])
+
+        results = []
+
+        for instance in dataset:
+            messages = self.to_messages(instance)
+            response = ollama.chat(
+                model=self.model,
+                messages=messages,
+                **args,
             )
-            for instance in dataset
+            results.append(response)
+
+        return [element["message"]["content"] for element in results]
+
+
+class OptionSelectingByLogProbsInferenceEngine:
+    """OptionSelectingByLogProbsInferenceEngine inference engine is used to select an option based on the logprobs of an options list conditioned by a prompt.
+
+    The inference engines that inherit from this class must implement `get_token_count` and `get_options_log_probs`.
+    """
+
+    @abc.abstractmethod
+    def get_token_count(self, dataset):
+        """Get the token count of the source key of each dict of the dataset. Add to each instance in the data a "token_count" field.
+
+        Args:
+            dataset (List[Dict[str, Any]]): A list of dictionaries, each representing a data instance.
+
+        Returns:
+            List[int]: The token count of the texts
+        """
+
+    @abc.abstractmethod
+    def get_options_log_probs(self, dataset):
+        """Get the token logprobs of the options of the key task_data.options of each dict of the dataset.
+
+        Add to each instance in the data a "options_log_prob" field, which is a dict with str as key and a list of {text: str, logprob:float}.
+
+        Args:
+            dataset (List[Dict[str, Any]]): A list of dictionaries, each representing a data instance.
+
+        Returns:
+            List[int]: The token count of the texts
+        """
+
+    def select(self, dataset: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Calculate most likely labels based on log probabilities for a set of fixed completions."""
+        dataset_with_token_counts = self.get_token_count(dataset)
+        token_counts = [d["token_count"] for d in dataset_with_token_counts]
+
+        # pass in the token count so we only return the option score
+        dataset_with_options = [
+            {
+                "source": instance["source"] + option,
+                "task_data": {"token_count": token_count},
+            }
+            for instance, token_count in zip(dataset, token_counts)
+            for option in instance["task_data"]["options"]
         ]
-        return [element["message"]["content"] for element in result]
+
+        dataset_with_options_logprobs: list[
+            list[dict[str, float | str]]
+        ] = self.get_options_log_probs(dataset_with_options)
+
+        dataset_iterator = iter(dataset_with_options_logprobs)
+
+        for instance in dataset:
+            tokens_with_logprob_list = []
+            # get the input tokens for the completions of the current resp_idx
+            for _ in instance["task_data"]["options"]:
+                tokens_with_logprob = next(dataset_iterator)["prediction"]
+                tokens_with_logprob_list.append(tokens_with_logprob)
+            # we start comparing all the options, e.g. if there are five options the value will be [0,1,2,3,4]
+            to_compare_indexes = list(range(len(instance["task_data"]["options"])))
+            # token_with_logprob_comp is the logprobs and the text of the tokens
+            # for each of the options at a specific index
+            for token_with_logprob_comp in zip(*tokens_with_logprob_list):
+                tokens_comp = [t["text"] for t in token_with_logprob_comp]
+                logprobs_comp = [t["logprob"] for t in token_with_logprob_comp]
+                # Find the maximum value by comparing the logprob of the nth token of non-discarded options
+                index_max = max(
+                    (
+                        (val, idx)
+                        for idx, val in enumerate(logprobs_comp)
+                        if idx in to_compare_indexes
+                    ),
+                    key=lambda x: x[0],
+                )[1]
+                # get the token of the biggest logprob
+                token_value_with_max_logprob = tokens_comp[index_max]
+                # check that the token is not repeated in the non-discarded options
+                count = tokens_comp.count(token_value_with_max_logprob)
+                if count > 1:
+                    # multiple tokens with same max logprob, we need to continue iterating
+                    to_compare_indexes = [
+                        index
+                        for index, token_value in enumerate(tokens_comp)
+                        if token_value == token_value_with_max_logprob
+                    ]
+                    continue
+                # we got the index of the maximum log_prob that doesn't have a duplicated token value at other index
+                break
+
+            if len(to_compare_indexes) > 1:
+                # multiple options are either equal or have the same token values prefix
+                # choose the first
+                index_max = to_compare_indexes[0]
+
+            instance["prediction"] = instance["task_data"]["options"][index_max]
+        return dataset
 
 
 class IbmGenAiInferenceEngine(
@@ -372,11 +543,12 @@ class IbmGenAiInferenceEngine(
     IbmGenAiInferenceEngineParamsMixin,
     PackageRequirementsMixin,
     LogProbInferenceEngine,
+    OptionSelectingByLogProbsInferenceEngine,
 ):
     label: str = "ibm_genai"
     model_name: str
     _requirements_list = {
-        "genai": "Install ibm-genai package using 'pip install --upgrade ibm-generative-ai"
+        "ibm-generative-ai": "Install ibm-genai package using 'pip install --upgrade ibm-generative-ai"
     }
     data_classification_policy = ["public", "proprietary"]
     parameters: Optional[IbmGenAiInferenceEngineParams] = None
@@ -482,6 +654,62 @@ class IbmGenAiInferenceEngine(
             )
         return predict_result
 
+    def get_token_count(self, dataset):
+        texts = [instance["source"] for instance in dataset]
+        token_counts = list(
+            tqdm(
+                [
+                    result.token_count
+                    for response in self.client.text.tokenization.create(
+                        model_id=self.model_name,
+                        input=texts,
+                        execution_options={"ordered": True},
+                    )
+                    for result in response.results
+                ],
+                desc="Tokenizing",
+                total=len(texts),
+            )
+        )
+        for i, token_count in enumerate(token_counts):
+            dataset[i]["token_count"] = token_count
+        return dataset
+
+    def get_options_log_probs(self, dataset):
+        """Add to each instance in the data a "options_log_prob" field, which is a dict with str as key and a list of {text: str, logprob:float}."""
+        from genai.schema import TextGenerationParameters, TextGenerationReturnOptions
+
+        texts = [x["source"] for x in dataset]
+
+        responses = tqdm(
+            self.client.text.generation.create(
+                model_id=self.model_name,
+                inputs=texts,
+                execution_options={"ordered": True},
+                parameters=TextGenerationParameters(
+                    max_new_tokens=1,
+                    return_options=TextGenerationReturnOptions(
+                        input_tokens=True, token_logprobs=True
+                    ),
+                    # random_seed=self.random_state
+                ),
+            ),
+            total=len(texts),
+            desc="Completions",
+        )
+
+        scores = [
+            [
+                {"text": token.text, "logprob": token.logprob}
+                for token in response.results[0].input_tokens
+            ]
+            for response in responses
+        ]
+
+        for instance, score in zip(dataset, scores):
+            instance["prediction"] = score[instance["task_data"]["token_count"] - 1 :]
+        return dataset
+
 
 class OpenAiInferenceEngineParamsMixin(Artifact):
     frequency_penalty: Optional[float] = None
@@ -569,17 +797,9 @@ class OpenAiInferenceEngine(
     ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
         outputs = []
         for instance in tqdm(dataset, desc="Inferring with openAI API"):
+            messages = self.to_messages(instance)
             response = self.client.chat.completions.create(
-                messages=[
-                    # {
-                    #     "role": "system",
-                    #     "content": self.system_prompt,
-                    # },
-                    {
-                        "role": "user",
-                        "content": instance["source"],
-                    }
-                ],
+                messages=messages,
                 model=self.model_name,
                 **self._get_completion_kwargs(),
             )
@@ -701,18 +921,19 @@ class TogetherAiInferenceEngine(
             if v is not None
         }
 
-    def _infer_chat(self, prompt: str) -> str:
+    def _infer_chat(self, instance: Dict[str, Any]) -> str:
+        messages = self.to_messages(instance)
         response = self.client.chat.completions.create(
             model=self.model_name,
-            messages=[{"role": "user", "content": prompt}],
+            messages=messages,
             **self._get_infer_kwargs(),
         )
         return response.choices[0].message.content
 
-    def _infer_text(self, prompt: str) -> str:
+    def _infer_text(self, instance: Dict[str, Any]) -> str:
         response = self.client.completions.create(
             model=self.model_name,
-            prompt=prompt,
+            prompt=instance["source"],
             **self._get_infer_kwargs(),
         )
         return response.choices[0].text
@@ -727,10 +948,11 @@ class TogetherAiInferenceEngine(
         outputs = []
         if self.model_type == ModelType.CHAT:
             for instance in tqdm(dataset, desc="Inferring with Together AI Chat API"):
-                outputs.append(self._infer_chat(instance["source"]))
+                outputs.append(self._infer_chat(instance))
         else:
+            self.verify_not_chat_api(dataset)
             for instance in tqdm(dataset, desc="Inferring with Together AI Text API"):
-                outputs.append(self._infer_text(instance["source"]))
+                outputs.append(self._infer_text(instance))
         return outputs
 
 
@@ -791,6 +1013,7 @@ class WMLInferenceEngine(
     WMLInferenceEngineParamsMixin,
     PackageRequirementsMixin,
     LogProbInferenceEngine,
+    OptionSelectingByLogProbsInferenceEngine,
 ):
     """Runs inference using ibm-watsonx-ai.
 
@@ -835,7 +1058,7 @@ class WMLInferenceEngine(
     deployment_id: Optional[str] = None
     label: str = "wml"
     _requirements_list = {
-        "ibm_watsonx_ai": "Install ibm-watsonx-ai package using 'pip install --upgrade ibm-watsonx-ai'. "
+        "ibm-watsonx-ai==1.1.14": "Install ibm-watsonx-ai package using 'pip install --upgrade ibm-watsonx-ai'. "
         "It is advised to have Python version >=3.10 installed, as at lower version this package "
         "may cause conflicts with other installed packages."
     }
@@ -930,12 +1153,13 @@ class WMLInferenceEngine(
         dataset: Union[List[Dict[str, Any]], DatasetDict],
         return_meta_data: bool = False,
     ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
+        self.verify_not_chat_api(dataset)
         model, params = self._load_model_and_params()
 
         result = []
-        for instance in dataset:
+        for source in dataset["source"]:
             instance_result = model.generate(
-                prompt=instance["source"],
+                prompt=source,
                 params=self.to_dict([WMLInferenceEngineParamsMixin], keep_empty=False),
             )
             prediction = instance_result["results"][0]["generated_text"]
@@ -951,6 +1175,8 @@ class WMLInferenceEngine(
         dataset: Union[List[Dict[str, Any]], DatasetDict],
         return_meta_data: bool = False,
     ) -> Union[List[Dict], List[TextGenerationInferenceOutput]]:
+        self.verify_not_chat_api(dataset)
+
         model, params = self._load_model_and_params()
 
         user_return_options = params.pop("return_options", {})
@@ -997,11 +1223,83 @@ class WMLInferenceEngine(
             )
         return predict_result
 
+    def get_token_count(self, dataset):
+        from ibm_watsonx_ai.foundation_models import ModelInference
+
+        texts = [instance["source"] for instance in dataset]
+
+        model = ModelInference(
+            model_id=self.model_name,
+            deployment_id=self.deployment_id,
+            api_client=self._client,
+        )
+
+        for i in trange(len(texts), desc="Tokenizing"):
+            response = model.tokenize(prompt=texts[i], return_tokens=True)["result"]
+            dataset[i]["token_count"] = response["token_count"]
+
+        return dataset
+
+    def get_options_log_probs(self, dataset):
+        """Add to each instance in the data a "options_log_prob" field, which is a dict with str as key and a list of {text: str, logprob:float}."""
+        from ibm_watsonx_ai.foundation_models import ModelInference
+
+        model = ModelInference(
+            model_id=self.model_name,
+            deployment_id=self.deployment_id,
+            api_client=self._client,
+        )
+
+        texts = [x["source"] for x in dataset]
+
+        responses = list(
+            tqdm(
+                model.generate(
+                    prompt=texts,
+                    params={
+                        "decoding_method": "greedy",
+                        "max_new_tokens": 1,
+                        "return_options": {
+                            "input_tokens": True,
+                            "token_logprobs": True,
+                        },
+                    },
+                ),
+                total=len(texts),
+                desc="Completions",
+            )
+        )
+
+        scores = [
+            [
+                {
+                    "text": token["text"],
+                    "logprob": token["logprob"] if "logprob" in token else 1,
+                }
+                for token in response["results"][0]["input_tokens"]
+            ]
+            for response in responses
+        ]
+
+        for instance, score in zip(dataset, scores):
+            instance["prediction"] = score[instance["task_data"]["token_count"] - 1 :]
+        return dataset
+
+
+def get_images_without_text(instance):
+    return extract_images(instance["source"], instance)
+
+
+def get_text_without_images(instance, image_token="<image>"):
+    regex = r"<" + f"{constants.image_tag}" + r'\s+src=["\'](.*?)["\']\s*/?>'
+    return re.sub(regex, image_token, instance["source"])
+
 
 class HFLlavaInferenceEngine(InferenceEngine, LazyLoadMixin):
     model_name: str
     max_new_tokens: int
     lazy_load = True
+    image_token = "<image>"
 
     _requirements_list = {
         "transformers": "Install huggingface package using 'pip install --upgrade transformers",
@@ -1039,6 +1337,21 @@ class HFLlavaInferenceEngine(InferenceEngine, LazyLoadMixin):
     def _is_loaded(self):
         return hasattr(self, "model") and self.model is not None
 
+    def _get_input(self, instance):
+        assert isinstance(instance["source"], list), "Must use format=formats.chat_api"
+        images = []
+        conversation = []
+        for turn in instance["source"]:
+            if isinstance(turn["content"], list):
+                for content in turn["content"]:
+                    if content["type"] == "image_url":
+                        content["type"] = "image"
+                        image_url = content.pop("image_url")["url"]
+                        image = data_url_to_image(image_url)
+                        images.append(image)
+            conversation.append(turn)
+        return conversation, images
+
     def _infer(
         self,
         dataset: Union[List[Dict[str, Any]], DatasetDict],
@@ -1051,16 +1364,19 @@ class HFLlavaInferenceEngine(InferenceEngine, LazyLoadMixin):
 
         results = []
         for instance in tqdm(dataset):
-            text = instance["source"]
-            images = extract_images(text, instance)
-            # Regular expression to match all <img src="..."> tags
-            regex = r'<img\s+src=["\'](.*?)["\']\s*/?>'
-            model_input = re.sub(regex, "<image>", text)
+            conversation, images = self._get_input(instance)
+
             if len(images) == 1:
                 images = images[0]
-            inputs = self.processor(
-                images=images, text=model_input, return_tensors="pt"
-            ).to(self.device, torch.float16)
+
+            text = self.processor.apply_chat_template(
+                conversation, add_generation_prompt=True
+            )
+
+            inputs = self.processor(images=images, text=text, return_tensors="pt").to(
+                self.device, torch.float16
+            )
+
             input_len = len(inputs["input_ids"][0])
             output = self.model.generate(
                 **inputs,
@@ -1074,3 +1390,542 @@ class HFLlavaInferenceEngine(InferenceEngine, LazyLoadMixin):
             results.append(result)
 
         return results
+
+
+class LMMSEvalBaseInferenceEngine(
+    InferenceEngine, PackageRequirementsMixin, LazyLoadMixin
+):
+    model_type: str
+    model_args: Dict[str, str]
+    batch_size: int = 1
+    image_token = "<image>"
+
+    _requirements_list = ["lmms-eval==0.2.4"]
+
+    def prepare_engine(self):
+        if not self.lazy_load:
+            self._prepare_engine()
+
+    def _prepare_engine(self):
+        import torch
+        from lmms_eval.api.instance import Instance
+        from lmms_eval.models import get_model
+
+        self.new_instance = Instance
+
+        self.device = torch.device(
+            "mps"
+            if torch.backends.mps.is_available()
+            else "cuda"
+            if torch.cuda.is_available()
+            else "cpu"
+        )
+
+        if isinstance(self.model_args, dict):
+            self.model_args = ",".join(f"{k}={v}" for k, v in self.model_args.items())
+
+        self.model = get_model(self.model_type).create_from_arg_string(
+            self.model_args,
+            {
+                "batch_size": self.batch_size,
+                "device": self.device,
+            },
+        )
+
+    def _is_loaded(self):
+        return hasattr(self, "model") and self.model is not None
+
+
+class LMMSEvalInferenceEngine(LMMSEvalBaseInferenceEngine):
+    max_new_tokens: int = 32
+    temperature: float = 0.0
+    do_sample: bool = False
+    generate_until: List[str] = ["\n\n"]
+
+    def _infer(
+        self,
+        dataset: Union[List[Dict[str, Any]], DatasetDict],
+        return_meta_data: bool = False,
+    ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
+        self.verify_not_chat_api(dataset)
+        if not self._is_loaded():
+            self._prepare_engine()
+
+        from lmms_eval.api.instance import Instance
+
+        temp_task_name = str(uuid.uuid4())
+
+        requests = []
+        for i, instance in enumerate(dataset):
+            requests.append(
+                Instance(
+                    request_type="generate_until",
+                    arguments=(
+                        get_text_without_images(instance, image_token=self.image_token),
+                        {
+                            "max_new_tokens": self.max_new_tokens,
+                            "temperature": self.temperature,
+                            "do_sample": self.do_sample,
+                            "until": self.generate_until,
+                        },
+                        get_images_without_text,
+                        i,
+                        temp_task_name,
+                        "test",
+                    ),
+                    idx=i,
+                    metadata={
+                        "task": temp_task_name,
+                        "doc_id": i,
+                        "repeats": 1,
+                    },
+                )
+            )
+
+        self.model.task_dict[temp_task_name] = DatasetDict({"test": dataset})
+
+        responses = self.model.generate_until(requests)
+
+        self.model.task_dict.pop(temp_task_name)
+
+        return responses
+
+
+class LMMSEvalLoglikelihoodInferenceEngine(LMMSEvalBaseInferenceEngine):
+    request_type: Literal["loglikelihood"] = "loglikelihood"
+
+    def make_instance(self, instance, special_args, index, task_name):
+        from lmms_eval.api.instance import Instance
+
+        return Instance(
+            request_type=self.request_type,
+            arguments=(
+                get_text_without_images(instance, image_token=self.image_token),
+                special_args,
+                get_images_without_text,
+                index,
+                task_name,
+                "test",
+            ),
+            idx=index,
+            metadata={
+                "task": task_name,
+                "doc_id": index,
+                "repeats": 1,
+            },
+        )
+
+    def _infer(
+        self,
+        dataset: Union[List[Dict[str, Any]], DatasetDict],
+        return_meta_data: bool = False,
+    ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
+        if not self._is_loaded():
+            self._prepare_engine()
+
+        temp_task_name = str(uuid.uuid4())
+
+        requests = []
+        for i, instance in enumerate(dataset):
+            task_data = instance["task_data"]
+
+            if isinstance(task_data, str):
+                task_data = json.loads(task_data)
+
+            for option in task_data["options"]:
+                requests.append(
+                    self.make_instance(
+                        instance,
+                        option,
+                        i,
+                        temp_task_name,
+                    )
+                )
+
+        self.model.task_dict[temp_task_name] = DatasetDict({"test": dataset})
+        self.model.metadata = {}
+
+        responses = self.model.loglikelihood(requests)
+
+        self.model.task_dict.pop(temp_task_name)
+
+        optimal_scores = [sys.float_info.max] * len(dataset)
+        optimal_responses = [None] * len(dataset)
+
+        for request, (score, _) in zip(requests, responses):
+            if score < optimal_scores[request.idx]:
+                optimal_scores[request.idx] = score
+                optimal_responses[request.idx] = request.arguments[1]
+
+        return optimal_responses
+
+
+class VLLMInferenceEngine(
+    InferenceEngine, PackageRequirementsMixin, StandardAPIParamsMixin
+):
+    def prepare_engine(self):
+        from vllm import LLM, SamplingParams
+
+        args = self.to_dict([StandardAPIParamsMixin])
+        self.sampling_params = SamplingParams(**args)
+        self.llm = LLM(model=self.model)
+
+    def _infer(
+        self,
+        dataset: Union[List[Dict[str, Any]], DatasetDict],
+        return_meta_data: bool = False,
+    ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
+        inputs = []
+        for instance in dataset:
+            inputs.append(instance["source"])
+
+        if isinstance(inputs[0], list):
+            outputs = self.llm.chat(inputs, self.sampling_params)
+        else:
+            outputs = self.llm.generate(inputs, self.sampling_params)
+
+        predictions = []
+        for output in outputs:
+            predictions.append(output.outputs[0].text)
+
+        return predictions
+
+
+class AsyncTokenBucket:
+    def __init__(self, rate, capacity):
+        self.rate = rate  # Tokens added per second
+        self.capacity = capacity  # Maximum tokens in the bucket
+        self.tokens = capacity
+        self.timestamp = time.perf_counter()
+        self.lock = asyncio.Lock()
+        self.interval = 1.0 / self.rate  # Time between tokens
+
+    async def acquire(self, tokens=1):
+        while True:
+            async with self.lock:
+                now = time.perf_counter()
+                delta = now - self.timestamp
+
+                # Calculate the number of tokens to add
+                token_intervals = int(delta / self.interval)
+                if token_intervals > 0:
+                    self.tokens = min(self.capacity, self.tokens + token_intervals)
+                    self.timestamp += token_intervals * self.interval
+                    logging.debug(
+                        f"Added {token_intervals} tokens. Tokens now: {self.tokens}"
+                    )
+
+                if self.tokens >= tokens:
+                    self.tokens -= tokens
+                    logging.debug(f"Token acquired. Tokens left: {self.tokens}")
+                    return
+                # Calculate time until the next token is available
+                time_until_next_token = self.interval - (now - self.timestamp)
+                logging.debug(
+                    f"Not enough tokens. Need to wait {time_until_next_token:.4f} seconds."
+                )
+            # Sleep outside the lock to allow other coroutines to proceed
+            await asyncio.sleep(time_until_next_token)
+
+
+class LiteLLMInferenceEngine(
+    InferenceEngine, StandardAPIParamsMixin, PackageRequirementsMixin
+):
+    max_requests_per_second: float = 6
+    max_retries: int = 5  # Set to 0 to prevent internal retries
+
+    _requirements_list: list = ["litellm", "tenacity", "tqdm", "diskcache"]
+
+    def prepare_engine(self):
+        # Initialize the token bucket rate limiter
+        self._rate_limiter = AsyncTokenBucket(
+            rate=self.max_requests_per_second,
+            capacity=self.max_requests_per_second,
+        )
+        self.inference_type = "litellm"
+        import litellm
+        from litellm import acompletion
+        from litellm.caching.caching import Cache
+
+        litellm.cache = Cache(type="disk")
+
+        self._completion = acompletion
+        # Initialize a semaphore to limit concurrency
+        self._semaphore = asyncio.Semaphore(self.max_requests_per_second)
+
+    async def _infer_instance(
+        self, index: int, instance: Dict[str, Any]
+    ) -> TextGenerationInferenceOutput:
+        """Process a single inference request."""
+        async with self._semaphore:
+            await self._rate_limiter.acquire()
+            # Introduce a slight delay to prevent burstiness
+            await asyncio.sleep(0.01)
+            messages = self.to_messages(instance)
+            kwargs = self.to_dict([StandardAPIParamsMixin])
+            try:
+                response = await self._completion(
+                    messages=messages,
+                    max_retries=self.max_retries,
+                    caching=True,
+                    **kwargs,
+                )
+            except Exception as e:
+                raise RuntimeError(
+                    f"Error inferring the following instance:\n{instance}"
+                ) from e
+
+            usage = response.get("usage", {})
+            return TextGenerationInferenceOutput(
+                prediction=response["choices"][0]["message"]["content"],
+                input_tokens=usage.get("prompt_tokens"),
+                output_tokens=usage.get("completion_tokens"),
+                model_name=response.get("model", self.model),
+                inference_type=self.inference_type,
+            )
+
+    async def _infer_async(
+        self, dataset: List[Dict[str, Any]]
+    ) -> List[TextGenerationInferenceOutput]:
+        """Process multiple inference requests concurrently with a progress bar."""
+        tasks = [
+            self._infer_instance(i, instance) for i, instance in enumerate(dataset)
+        ]
+        # Use tqdm_asyncio.gather to display progress bar
+        return await tqdm_asyncio.gather(
+            *tasks, desc=f"LiteLLM Inference ({self.model})", total=len(tasks)
+        )
+
+    def _infer(
+        self,
+        dataset: Union[List[Dict[str, Any]], "DatasetDict"],
+        return_meta_data: bool = False,
+    ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
+        """Main inference entry point."""
+        loop = asyncio.get_event_loop()
+        responses = loop.run_until_complete(self._infer_async(dataset))
+
+        if return_meta_data:
+            return responses
+
+        return [response.prediction for response in responses]
+
+
+_supported_apis = Literal[
+    "watsonx", "together-ai", "open-ai", "aws", "ollama", "bam", "watsonx-sdk"
+]
+
+
+class CrossProviderInferenceEngine(InferenceEngine, StandardAPIParamsMixin):
+    """Inference engine capable of dynamically switching between multiple providers APIs.
+
+    This class extends the InferenceEngine and OpenAiInferenceEngineParamsMixin
+    to enable seamless integration with various API providers. The supported APIs are
+    specified in `_supported_apis`, allowing users to interact with multiple models
+    from different sources. The `api_model_map` dictionary maps each API to
+    specific model identifiers, enabling automatic configuration based on
+    user requests.
+
+    Attributes:
+        provider: Optional; Specifies the current API in use. Must be one of the
+            literals in `_supported_apis`.
+        provider_model_map: Dictionary mapping each supported API to a corresponding
+            model identifier string. This mapping allows consistent access to models
+            across different API backends.
+    """
+
+    provider: Optional[_supported_apis] = None
+
+    provider_model_map: Dict[_supported_apis, Dict[str, str]] = {
+        "watsonx": {
+            "llama-3-8b-instruct": "watsonx/meta-llama/llama-3-8b-instruct",
+            "llama-3-70b-instruct": "watsonx/meta-llama/llama-3-70b-instruct",
+            "granite-3-8b-instruct": "watsonx/ibm/granite-3-8b-instruct",
+            "flan-t5-xxl": "watsonx/google/flan-t5-xxl",
+            "llama-3-2-1b-instruct": "watsonx/meta-llama/llama-3-2-1b-instruct",
+        },
+        "watsonx-sdk": {
+            "llama-3-8b-instruct": "meta-llama/llama-3-8b-instruct",
+            "llama-3-70b-instruct": "meta-llama/llama-3-70b-instruct",
+            "granite-3-8b-instruct": "ibm/granite-3-8b-instruct",
+        },
+        "together-ai": {
+            "llama-3-8b-instruct": "together_ai/togethercomputer/llama-3-8b-instruct",
+            "llama-3-70b-instruct": "together_ai/togethercomputer/llama-3-70b-instruct",
+            "llama-3-2-1b-instruct": "together_ai/togethercomputer/llama-3-2-1b-instruct",
+        },
+        "aws": {
+            "llama-3-8b-instruct": "bedrock/meta.llama3-8b-instruct-v1:0",
+            "llama-3-70b-instruct": "bedrock/meta.llama3-70b-instruct-v1:0",
+        },
+        "ollama": {
+            "llama-3-8b-instruct": "llama3:8b",
+            "llama-3-70b-instruct": "llama3:70b",
+        },
+        "bam": {
+            "granite-3-8b-instruct": "ibm/granite-8b-instruct-preview-4k",
+            "llama-3-8b-instruct": "meta-llama/llama-3-8b-instruct",
+            "llama-3-2-1b-instruct": "meta-llama/llama-3-2-1b-instruct",
+            "flan-t5-xxl": "google/flan-t5-xxl",
+        },
+    }
+
+    _provider_to_base_class = {
+        "watsonx": LiteLLMInferenceEngine,
+        "open-ai": LiteLLMInferenceEngine,
+        "together-ai": LiteLLMInferenceEngine,
+        "aws": LiteLLMInferenceEngine,
+        "ollama": OllamaInferenceEngine,
+        "bam": IbmGenAiInferenceEngine,
+        "watsonx-sdk": WMLInferenceEngine,
+    }
+
+    _provider_param_renaming = {
+        "bam": {"max_tokens": "max_new_tokens", "model": "model_name"},
+        "watsonx-sdk": {"max_tokens": "max_new_tokens", "model": "model_name"},
+    }
+
+    def get_provider_name(self):
+        return self.provider if self.provider is not None else settings.default_provider
+
+    def prepare_engine(self):
+        provider = self.get_provider_name()
+        if provider not in self._provider_to_base_class:
+            raise UnitxtError(
+                f"{provider} a known API. Supported apis: {','.join(self.provider_model_map.keys())}"
+            )
+        if self.model not in self.provider_model_map[provider]:
+            raise UnitxtError(
+                f"{self.model} is not configured for provider {provider}. Supported models: {','.join(self.provider_model_map[provider].keys())}"
+            )
+        cls = self.__class__._provider_to_base_class[provider]
+        args = self.to_dict([StandardAPIParamsMixin])
+        args["model"] = self.provider_model_map[provider][self.model]
+        params = list(args.keys())
+        if provider in self._provider_param_renaming:
+            for param in params:
+                if args[param] is not None:
+                    if param in self._provider_param_renaming[provider]:
+                        args[self._provider_param_renaming[provider][param]] = args[
+                            param
+                        ]
+                        del args[param]
+                else:
+                    del args[param]
+        self.engine = cls(**args)
+
+    def _infer(
+        self,
+        dataset: Union[List[Dict[str, Any]], DatasetDict],
+        return_meta_data: bool = False,
+    ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
+        return self.engine._infer(dataset, return_meta_data)
+
+    def get_engine_id(self):
+        api = self.get_provider_name()
+        return get_model_and_label_id(self.provider_model_map[api][self.model], api)
+
+
+class HFOptionSelectingInferenceEngine(InferenceEngine):
+    """HuggingFace based class for inference engines that calculate log probabilities.
+
+    This class uses models from the HuggingFace Transformers library to calculate log probabilities for text inputs.
+    """
+
+    model_name: str
+    batch_size: int
+
+    _requirements_list = {
+        "transformers": "Install huggingface package using 'pip install --upgrade transformers"
+    }
+
+    def prepare_engine(self):
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+
+        self.device = torch.device(
+            "mps"
+            if torch.backends.mps.is_available()
+            else "cuda"
+            if torch.cuda.is_available()
+            else "cpu"
+        )
+
+        # Load model and tokenizer
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+        self.model = AutoModelForCausalLM.from_pretrained(self.model_name).to(
+            self.device
+        )
+        # Set pad_token if it doesn't exist
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+
+    def get_log_probs(self, texts):
+        # Check available device
+        import torch
+        from tqdm import tqdm
+
+        log_probs = []
+
+        # Process texts in batches
+        for i in tqdm(range(0, len(texts), self.batch_size)):
+            batch = texts[i : i + self.batch_size]
+
+            # Tokenize batch
+            if isinstance(texts[0], list):
+                batch = self.tokenizer.apply_chat_template(batch, tokenize=False)
+
+            inputs = self.tokenizer(
+                batch, return_tensors="pt", padding=True, truncation=True
+            ).to(self.device)
+
+            # Compute log probabilities
+            with torch.no_grad():
+                predictions = self.model(**inputs)
+                logits = predictions.logits
+
+                for j in range(len(batch)):
+                    input_ids = inputs.input_ids[j]
+                    text_logits = logits[j, :-1, :]  # exclude last token
+                    text_log_probs = torch.log_softmax(text_logits, dim=-1)
+
+                    # Gather log probs for each token
+                    token_log_probs = text_log_probs[
+                        torch.arange(text_logits.shape[0]), input_ids[1:]
+                    ]
+
+                    # Sum log probs to get sequence log prob
+                    sequence_log_prob = token_log_probs.sum().item()
+                    log_probs.append(sequence_log_prob)
+
+        return log_probs
+
+    def _infer(
+        self,
+        dataset: Union[List[Dict[str, Any]], DatasetDict],
+        return_meta_data: bool = False,
+    ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
+        inputs = []
+
+        for instance in dataset:
+            for option in instance["task_data"]["options"]:
+                if isinstance(instance["source"], list):
+                    inputs.append(
+                        instance["source"] + [{"role": "assistant", "content": option}]
+                    )
+                else:
+                    inputs.append(instance["source"] + option)
+
+        scores = self.get_log_probs(inputs)
+
+        scores_iterator = iter(scores)
+
+        predictions = []
+        for instance in dataset:
+            options_scores = Counter()
+            for option in instance["task_data"]["options"]:
+                score = next(scores_iterator)
+                options_scores[option] = score
+            predictions.append(options_scores.most_common(1)[0][0])
+
+        return predictions

llm_as_judge.py

@@ -2,12 +2,12 @@ from abc import abstractmethod
 from typing import Any, Dict, List, Literal, Optional
 
 from .api import infer
-from .artifact import fetch_artifact
 from .dataclass import Field
 from .formats import Format, SystemFormat
 from .inference import InferenceEngine, LogProbInferenceEngine, OpenAiInferenceEngine
 from .metrics import BulkInstanceMetric
 from .operator import SequentialOperator
+from .operators import ArtifactFetcherMixin
 from .settings_utils import get_settings
 from .system_prompts import EmptySystemPrompt, SystemPrompt
 from .templates import Template
@@ -122,7 +122,7 @@ class LLMAsJudgeBase(BulkInstanceMetric):
         pass
 
 
-class LLMAsJudge(LLMAsJudgeBase):
+class LLMAsJudge(LLMAsJudgeBase, ArtifactFetcherMixin):
     """LLM-as-judge-based metric class for evaluating correctness of generated predictions.
 
     This class uses the source prompt given to the generator and the generator's predictions to evaluate
@@ -156,7 +156,7 @@ class LLMAsJudge(LLMAsJudgeBase):
             instances = []
             for task_data_instance in task_data:
                 template = task_data_instance["metadata"]["template"]
-                template, _ = fetch_artifact(template)
+                template = self.get_artifact(template)
                 instance = SequentialOperator(
                     steps=[template, "formats.empty"]
                 ).process_instance(
@@ -176,6 +176,26 @@ class LLMAsJudge(LLMAsJudgeBase):
     def _get_instance_for_judge_model(
         self, input_instances: List[str], predictions: List, references: List
     ) -> List[Dict]:
+        string_input_instances = []
+
+        for input_instance in input_instances:
+            if isinstance(input_instance, str):
+                string_input_instances.append(input_instance)
+            if isinstance(input_instance, list):  # chat api
+                if len(input_instance) == 1:  # only user
+                    string_input_instances.append(input_instance[0]["content"])
+                if len(input_instance) == 2:  # only system and user
+                    string_input_instances.append(
+                        input_instance[0]["content"]
+                        + "\n"
+                        + input_instance[1]["content"]
+                    )
+                else:  # num demos > 0
+                    turns = []
+                    for turn in input_instance:
+                        turns.append(f'{turn["role"]}: {turn["content"]}')
+                    string_input_instances.append("\n".join(turns))
+
         if self.task == "rating.single_turn":
             instances = [
                 {
@@ -183,7 +203,7 @@ class LLMAsJudge(LLMAsJudgeBase):
                     "answer": prediction,
                 }
                 for input_instance, prediction, reference in zip(
-                    input_instances, predictions, references
+                    string_input_instances, predictions, references
                 )
             ]
         elif self.task == "rating.single_turn_with_reference":
@@ -194,7 +214,7 @@ class LLMAsJudge(LLMAsJudgeBase):
                     "reference_answer": reference[0],
                 }
                 for input_instance, prediction, reference in zip(
-                    input_instances, predictions, references
+                    string_input_instances, predictions, references
                 )
             ]
         elif self.task == "pairwise_comparative_rating.single_turn":
@@ -207,7 +227,7 @@ class LLMAsJudge(LLMAsJudgeBase):
                     "model_b": "baseline_model",
                 }
                 for input_instance, prediction, reference in zip(
-                    input_instances, predictions, references
+                    string_input_instances, predictions, references
                 )
             ]
         else:
@@ -262,14 +282,14 @@ class LLMAsJudge(LLMAsJudgeBase):
 
                 result = {
                     self.main_score: model_a_preference_score,
-                    "judge_raw_output": instance["raw_prediction"],
-                    "judge_raw_input": instance["source"],
+                    f"{self.main_score}_judge_raw_output": instance["raw_prediction"],
+                    f"{self.main_score}_judge_raw_input": instance["source"],
                 }
             else:
                 result = {
                     self.main_score: instance["prediction"],
-                    "judge_raw_output": instance["raw_prediction"],
-                    "judge_raw_input": instance["source"],
+                    f"{self.main_score}_judge_raw_output": instance["raw_prediction"],
+                    f"{self.main_score}_judge_raw_input": instance["source"],
                 }
             results.append(result)
         return results
@@ -394,6 +414,13 @@ class TaskBasedLLMasJudge(LLMAsJudgeBase):
             if self.prediction_field and prediction:
                 instance_task_data[self.prediction_field] = str(prediction)
             instance_task_data = judge_task.process(instance_task_data)["input_fields"]
+
+            data_classification_policy = input_instance.get("metadata", {}).get(
+                "data_classification_policy"
+            )
+            instance_task_data[
+                "data_classification_policy"
+            ] = data_classification_policy
             instances.append(instance_task_data)
 
         return instances

loaders.py

@@ -38,14 +38,14 @@ import tempfile
 from abc import abstractmethod
 from pathlib import Path
 from tempfile import TemporaryDirectory
-from typing import Any, Dict, List, Mapping, Optional, Sequence, Union
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Union
 
 import pandas as pd
 from datasets import load_dataset as hf_load_dataset
 from huggingface_hub import HfApi
 from tqdm import tqdm
 
-from .dataclass import InternalField, OptionalField
+from .dataclass import OptionalField
 from .fusion import FixedFusion
 from .logging_utils import get_logger
 from .operator import SourceOperator
@@ -53,7 +53,7 @@ from .operators import Set
 from .settings_utils import get_settings
 from .stream import DynamicStream, MultiStream
 from .type_utils import isoftype
-from .utils import recursive_copy
+from .utils import LRUCache
 
 logger = get_logger()
 settings = get_settings()
@@ -81,7 +81,10 @@ class Loader(SourceOperator):
     streaming: bool = False
     num_proc: int = None
 
-    def get_limit(self):
+    # class level shared cache:
+    _loader_cache = LRUCache(max_size=settings.loader_cache_size)
+
+    def get_limit(self) -> int:
         if settings.global_loader_limit is not None and self.loader_limit is not None:
             return min(int(settings.global_loader_limit), self.loader_limit)
         if settings.global_loader_limit is not None:
@@ -132,10 +135,22 @@ class Loader(SourceOperator):
             self.data_classification_policy = default_data_classification_policy
 
     @abstractmethod
-    def load_data(self):
+    def load_iterables(self) -> Dict[str, Iterable]:
+        pass
+
+    def _maybe_set_classification_policy(self):
         pass
 
+    def load_data(self) -> MultiStream:
+        iterables = self.__class__._loader_cache.get(str(self), None)
+        if iterables is None:
+            iterables = self.load_iterables()
+            self.__class__._loader_cache.max_size = settings.loader_cache_size
+            self.__class__._loader_cache[str(self)] = iterables
+        return MultiStream.from_iterables(iterables, copying=True)
+
     def process(self) -> MultiStream:
+        self._maybe_set_classification_policy()
         return self.add_data_classification(self.load_data())
 
 
@@ -175,7 +190,6 @@ class LoadHF(Loader):
     streaming: bool = True
     filtering_lambda: Optional[str] = None
     num_proc: Optional[int] = None
-    _cache: dict = InternalField(default=None)
     requirements_list: List[str] = OptionalField(default_factory=list)
 
     def verify(self):
@@ -193,39 +207,33 @@ class LoadHF(Loader):
         return dataset.filter(eval(self.filtering_lambda))
 
     def stream_dataset(self):
-        if self._cache is None:
-            with tempfile.TemporaryDirectory() as dir_to_be_deleted:
-                if settings.disable_hf_datasets_cache and not self.streaming:
-                    cache_dir = dir_to_be_deleted
-                else:
-                    cache_dir = None
-                try:
-                    dataset = hf_load_dataset(
-                        self.path,
-                        name=self.name,
-                        data_dir=self.data_dir,
-                        data_files=self.data_files,
-                        revision=self.revision,
-                        streaming=self.streaming,
-                        cache_dir=cache_dir,
-                        split=self.split,
-                        trust_remote_code=settings.allow_unverified_code,
-                        num_proc=self.num_proc,
-                    )
-                except ValueError as e:
-                    if "trust_remote_code" in str(e):
-                        raise ValueError(
-                            f"{self.__class__.__name__} cannot run remote code from huggingface without setting unitxt.settings.allow_unverified_code=True or by setting environment variable: UNITXT_ALLOW_UNVERIFIED_CODE."
-                        ) from e
-                    raise e
-
-            if self.split is not None:
-                dataset = {self.split: dataset}
-
-            self._cache = dataset
+        with tempfile.TemporaryDirectory() as dir_to_be_deleted:
+            if settings.disable_hf_datasets_cache and not self.streaming:
+                cache_dir = dir_to_be_deleted
+            else:
+                cache_dir = None
+            try:
+                dataset = hf_load_dataset(
+                    self.path,
+                    name=self.name,
+                    data_dir=self.data_dir,
+                    data_files=self.data_files,
+                    revision=self.revision,
+                    streaming=self.streaming,
+                    cache_dir=cache_dir,
+                    split=self.split,
+                    trust_remote_code=settings.allow_unverified_code,
+                    num_proc=self.num_proc,
+                )
+            except ValueError as e:
+                if "trust_remote_code" in str(e):
+                    raise ValueError(
+                        f"{self.__class__.__name__} cannot run remote code from huggingface without setting unitxt.settings.allow_unverified_code=True or by setting environment variable: UNITXT_ALLOW_UNVERIFIED_CODE."
+                    ) from e
+                raise e
 
-        else:
-            dataset = self._cache
+        if self.split is not None:
+            dataset = {self.split: dataset}
 
         if self.filtering_lambda is not None:
             dataset = self.filter_load(dataset)
@@ -233,41 +241,35 @@ class LoadHF(Loader):
         return dataset
 
     def load_dataset(self):
-        if self._cache is None:
-            with tempfile.TemporaryDirectory() as dir_to_be_deleted:
-                if settings.disable_hf_datasets_cache:
-                    cache_dir = dir_to_be_deleted
-                else:
-                    cache_dir = None
-                try:
-                    dataset = hf_load_dataset(
-                        self.path,
-                        name=self.name,
-                        data_dir=self.data_dir,
-                        data_files=self.data_files,
-                        streaming=False,
-                        keep_in_memory=True,
-                        cache_dir=cache_dir,
-                        split=self.split,
-                        trust_remote_code=settings.allow_unverified_code,
-                        num_proc=self.num_proc,
-                    )
-                except ValueError as e:
-                    if "trust_remote_code" in str(e):
-                        raise ValueError(
-                            f"{self.__class__.__name__} cannot run remote code from huggingface without setting unitxt.settings.allow_unverified_code=True or by setting environment variable: UNITXT_ALLOW_UNVERIFIED_CODE."
-                        ) from e
-
-            if self.split is None:
-                for split in dataset.keys():
-                    dataset[split] = dataset[split].to_iterable_dataset()
+        with tempfile.TemporaryDirectory() as dir_to_be_deleted:
+            if settings.disable_hf_datasets_cache:
+                cache_dir = dir_to_be_deleted
             else:
-                dataset = {self.split: dataset}
-
-            self._cache = dataset
+                cache_dir = None
+            try:
+                dataset = hf_load_dataset(
+                    self.path,
+                    name=self.name,
+                    data_dir=self.data_dir,
+                    data_files=self.data_files,
+                    streaming=False,
+                    keep_in_memory=True,
+                    cache_dir=cache_dir,
+                    split=self.split,
+                    trust_remote_code=settings.allow_unverified_code,
+                    num_proc=self.num_proc,
+                )
+            except ValueError as e:
+                if "trust_remote_code" in str(e):
+                    raise ValueError(
+                        f"{self.__class__.__name__} cannot run remote code from huggingface without setting unitxt.settings.allow_unverified_code=True or by setting environment variable: UNITXT_ALLOW_UNVERIFIED_CODE."
+                    ) from e
 
+        if self.split is None:
+            for split in dataset.keys():
+                dataset[split] = dataset[split].to_iterable_dataset()
         else:
-            dataset = self._cache
+            dataset = {self.split: dataset}
 
         if self.filtering_lambda is not None:
             dataset = self.filter_load(dataset)
@@ -285,11 +287,11 @@ class LoadHF(Loader):
                     generator=self.split_limited_load,
                     gen_kwargs={"dataset": dataset, "split_name": name},
                 )
-                for name in self._cache.keys()
+                for name in dataset.keys()
             }
         )
 
-    def load_data(self):
+    def _maybe_set_classification_policy(self):
         if os.path.exists(self.path):
             self.sef_default_data_classification(
                 ["proprietary"], "when loading from local files"
@@ -298,6 +300,8 @@ class LoadHF(Loader):
             self.sef_default_data_classification(
                 ["public"], "when loading from Huggingface hub"
             )
+
+    def load_iterables(self):
         try:
             dataset = self.stream_dataset()
         except (
@@ -308,7 +312,7 @@ class LoadHF(Loader):
         if self.get_limit() is not None:
             return self.limited_load(dataset=dataset)
 
-        return MultiStream.from_iterables(dataset)
+        return dataset
 
 
 class LoadCSV(Loader):
@@ -333,58 +337,26 @@ class LoadCSV(Loader):
 
     files: Dict[str, str]
     chunksize: int = 1000
-    _cache = InternalField(default_factory=dict)
     loader_limit: Optional[int] = None
     streaming: bool = True
     sep: str = ","
 
-    def stream_csv(self, file):
-        if self.get_limit() is not None:
-            self.log_limited_loading()
-            chunksize = min(self.get_limit(), self.chunksize)
-        else:
-            chunksize = self.chunksize
-
-        row_count = 0
-        for chunk in pd.read_csv(file, chunksize=chunksize, sep=self.sep):
-            for _, row in chunk.iterrows():
-                if self.get_limit() is not None and row_count >= self.get_limit():
-                    return
-                yield row.to_dict()
-                row_count += 1
-
-    def load_csv(self, file):
-        if file not in self._cache:
-            if self.get_limit() is not None:
-                self.log_limited_loading()
-                self._cache[file] = pd.read_csv(
-                    file, nrows=self.get_limit(), sep=self.sep
-                ).to_dict("records")
-            else:
-                self._cache[file] = pd.read_csv(file).to_dict("records")
-
-        yield from self._cache[file]
-
-    def load_data(self):
+    def _maybe_set_classification_policy(self):
         self.sef_default_data_classification(
             ["proprietary"], "when loading from local files"
         )
-        if self.streaming:
-            return MultiStream(
-                {
-                    name: DynamicStream(
-                        generator=self.stream_csv, gen_kwargs={"file": file}
-                    )
-                    for name, file in self.files.items()
-                }
-            )
 
-        return MultiStream(
-            {
-                name: DynamicStream(generator=self.load_csv, gen_kwargs={"file": file})
-                for name, file in self.files.items()
-            }
-        )
+    def load_iterables(self):
+        iterables = {}
+        for split_name, file_path in self.files.items():
+            if self.get_limit() is not None:
+                self.log_limited_loading()
+                iterables[split_name] = pd.read_csv(
+                    file_path, nrows=self.get_limit(), sep=self.sep
+                ).to_dict("records")
+            else:
+                iterables[split_name] = pd.read_csv(file_path).to_dict("records")
+        return iterables
 
 
 class LoadFromSklearn(Loader):
@@ -407,7 +379,9 @@ class LoadFromSklearn(Loader):
     dataset_name: str
     splits: List[str] = ["train", "test"]
 
-    _requirements_list: List[str] = ["sklearn", "pandas"]
+    _requirements_list: List[str] = ["scikit-learn", "pandas"]
+
+    data_classification_policy = ["public"]
 
     def verify(self):
         super().verify()
@@ -421,7 +395,7 @@ class LoadFromSklearn(Loader):
 
         self.downloader = getattr(sklearn_datatasets, f"fetch_{self.dataset_name}")
 
-    def load_data(self):
+    def load_iterables(self):
         with TemporaryDirectory() as temp_directory:
             for split in self.splits:
                 split_data = self.downloader(subset=split)
@@ -429,9 +403,7 @@ class LoadFromSklearn(Loader):
                 df = pd.DataFrame([split_data["data"], targets]).T
                 df.columns = ["data", "target"]
                 df.to_csv(os.path.join(temp_directory, f"{split}.csv"), index=None)
-            dataset = hf_load_dataset(temp_directory, streaming=False)
-
-        return MultiStream.from_iterables(dataset)
+            return hf_load_dataset(temp_directory, streaming=False)
 
 
 class MissingKaggleCredentialsError(ValueError):
@@ -475,12 +447,10 @@ class LoadFromKaggle(Loader):
 
         self.downloader = download
 
-    def load_data(self):
+    def load_iterables(self):
         with TemporaryDirectory() as temp_directory:
             self.downloader(self.url, temp_directory)
-            dataset = hf_load_dataset(temp_directory, streaming=False)
-
-        return MultiStream.from_iterables(dataset)
+            return hf_load_dataset(temp_directory, streaming=False)
 
 
 class LoadFromIBMCloud(Loader):
@@ -527,7 +497,7 @@ class LoadFromIBMCloud(Loader):
     caching: bool = True
     data_classification_policy = ["proprietary"]
 
-    _requirements_list: List[str] = ["ibm_boto3"]
+    _requirements_list: List[str] = ["ibm-cos-sdk"]
 
     def _download_from_cos(self, cos, bucket_name, item_name, local_file):
         logger.info(f"Downloading {item_name} from {bucket_name} COS")
@@ -595,13 +565,15 @@ class LoadFromIBMCloud(Loader):
         if self.streaming:
             raise NotImplementedError("LoadFromKaggle cannot load with streaming.")
 
-    def load_data(self):
-        if not self.verified:
-            self.lazy_verify()
-            self.verified = True
+    def _maybe_set_classification_policy(self):
         self.sef_default_data_classification(
             ["proprietary"], "when loading from IBM COS"
         )
+
+    def load_iterables(self):
+        if not self.verified:
+            self.lazy_verify()
+            self.verified = True
         import ibm_boto3
 
         cos = ibm_boto3.resource(
@@ -658,7 +630,7 @@ class LoadFromIBMCloud(Loader):
                 field=self.data_field,
             )
 
-        return MultiStream.from_iterables(dataset)
+        return dataset
 
 
 class MultipleSourceLoader(Loader):
@@ -692,6 +664,9 @@ class MultipleSourceLoader(Loader):
             return multi_stream
         return super().add_data_classification(multi_stream)
 
+    def load_iterables(self):
+        pass
+
     def load_data(self):
         return FixedFusion(
             subsets=self.sources, max_instances_per_subset=self.get_limit()
@@ -741,11 +716,13 @@ class LoadFromDictionary(Loader):
                         f"instance {instance} has different fields different from {first_instance}"
                     )
 
-    def load_data(self) -> MultiStream:
+    def _maybe_set_classification_policy(self):
         self.sef_default_data_classification(
             ["proprietary"], "when loading from python dictionary"
         )
-        return MultiStream.from_iterables(recursive_copy(self.data))
+
+    def load_iterables(self) -> MultiStream:
+        return self.data
 
 
 class LoadFromHFSpace(LoadHF):
@@ -915,10 +892,12 @@ class LoadFromHFSpace(LoadHF):
                 f"Loader does not support input 'data_files' of type {type(self.data_files)}"
             )
 
-    def load_data(self):
+    def _maybe_set_classification_policy(self):
         self.sef_default_data_classification(
             ["public"], "when loading from Huggingface spaces"
         )
+
+    def load_data(self):
         self._map_wildcard_path_to_full_paths()
         self.path = self._download_data()
         return super().load_data()

metric_utils.py

@@ -1,4 +1,5 @@
 import json
+import re
 from collections import defaultdict
 from functools import lru_cache
 from statistics import mean
@@ -8,6 +9,7 @@ from datasets import Features, Value
 
 from .dataclass import Dataclass
 from .operator import (
+    InstanceOperator,
     MultiStreamOperator,
     SequentialOperator,
     SequentialOperatorInitializer,
@@ -16,6 +18,7 @@ from .operator import (
 from .operators import (
     ApplyMetric,
     ApplyOperatorsField,
+    ArtifactFetcherMixin,
     FlattenInstances,
     RecursiveCopy,
     Rename,
@@ -25,7 +28,7 @@ from .schema import UNITXT_DATASET_SCHEMA
 from .settings_utils import get_constants, get_settings
 from .stream import DynamicStream, MultiStream
 from .struct_data_operators import LoadJson
-from .utils import recursive_shallow_copy
+from .utils import recursive_copy
 
 constants = get_constants()
 
@@ -52,6 +55,21 @@ class FromPredictionsAndOriginalData(StreamInitializerOperator):
         )
 
 
+class DeleteTargetPrefix(InstanceOperator, ArtifactFetcherMixin):
+    def process(
+        self, instance: Dict[str, Any], stream_name: Optional[str] = None
+    ) -> Dict[str, Any]:
+        if "metadata" in instance["task_data"]:
+            target_prefix = self.get_artifact(
+                instance["task_data"]["metadata"]["template"]
+            ).target_prefix
+            if target_prefix is not None and len(target_prefix) > 0:
+                target_prefix = target_prefix.format(**instance["task_data"])
+                pattern = rf"^\s*{re.escape(target_prefix)}\s*"
+                instance["prediction"] = re.sub(pattern, "", instance["prediction"])
+        return instance
+
+
 _post_process_steps = SequentialOperator(
     steps=[
         RecursiveCopy(
@@ -67,6 +85,7 @@ _post_process_steps = SequentialOperator(
             field="source",
             to_field="task_data/source",
         ),
+        DeleteTargetPrefix(),
         ApplyOperatorsField(
             operators_field="postprocessors",
         ),
@@ -250,7 +269,7 @@ class JoinSubsetsAndGroups(MultiStreamOperator):
             sorted_instances = []
             for key in sorted(stream_instances.keys()):
                 instance = stream_instances[key]
-                instance["score"].update(recursive_shallow_copy(score))
+                instance["score"].update(recursive_copy(score))
                 sorted_instances.append(instance)
             result[stream_name] = sorted_instances
 

metrics.py

@@ -17,7 +17,7 @@ import pandas as pd
 from scipy.stats import bootstrap
 from scipy.stats._warnings_errors import DegenerateDataWarning
 
-from .artifact import Artifact, fetch_artifact
+from .artifact import Artifact
 from .dataclass import (
     AbstractField,
     InternalField,
@@ -32,11 +32,12 @@ from .metric_utils import InstanceInput, MetricRequest, MetricResponse
 from .operator import (
     InstanceOperator,
     MultiStreamOperator,
+    PackageRequirementsMixin,
     SequentialOperator,
     StreamingOperator,
     StreamOperator,
 )
-from .operators import Copy, Set
+from .operators import ArtifactFetcherMixin, Copy, Set
 from .random_utils import get_seed
 from .settings_utils import get_settings
 from .stream import MultiStream, Stream
@@ -64,7 +65,11 @@ def nan_mean(x):
         # RuntimeWarning that it is calculating the mean of an empty slice (with no non-Nans)
         # this is the desired behavior, but we want to avoid the warning here
         warnings.simplefilter("ignore", category=RuntimeWarning)
-        return np.nanmean(x)
+        result = np.nanmean(x)
+        try:
+            return float(result)
+        except:
+            return result
 
 
 def nan_max(x):
@@ -1341,6 +1346,8 @@ class ANLS(InstanceMetric):
     reduction_map = {"mean": ["anls"]}
     prediction_type = Any  # string representation is compared
 
+    threshold: float = 0.5
+
     @staticmethod
     @lru_cache(maxsize=10000)
     def preprocess_text(text):
@@ -1359,7 +1366,6 @@ class ANLS(InstanceMetric):
         references: List[Any],
         prediction: Any,
         task_data: List[Dict],
-        threshold=1.0,
     ) -> dict:
         """ANLS image-text accuracy metric."""
         values = []
@@ -1368,7 +1374,7 @@ class ANLS(InstanceMetric):
 
         question_result = 1.0 - min(values)
 
-        if question_result < threshold:
+        if question_result < self.threshold:
             question_result = 0.0
 
         result = {}
@@ -1850,6 +1856,8 @@ class F1(GlobalMetric):
     prediction_type = str
     single_reference_per_prediction = True
 
+    _requirements_list: List[str] = ["scikit-learn"]
+
     def prepare(self):
         super().prepare()
         import evaluate
@@ -1914,7 +1922,7 @@ class F1Binary(GlobalMetric):
     metric = "f1"
     single_reference_per_prediction = True
     ci_scores = [main_score, "f1_binary_neg"]
-    _requirements_list: List[str] = ["sklearn"]
+    _requirements_list: List[str] = ["scikit-learn"]
 
     def prepare(self):
         super().prepare()
@@ -2120,7 +2128,7 @@ class F1Weighted(F1):
     average = "weighted"
 
 
-class F1MultiLabel(GlobalMetric):
+class F1MultiLabel(GlobalMetric, PackageRequirementsMixin):
     _metric = None
     main_score = "f1_macro"
     average = None  # Report per class then aggregate by mean
@@ -2128,6 +2136,7 @@ class F1MultiLabel(GlobalMetric):
 
     prediction_type = List[str]
     single_reference_per_prediction = True
+    _requirements_list = ["scikit-learn"]
 
     def prepare(self):
         super().prepare()
@@ -2286,7 +2295,7 @@ class Rouge(InstanceMetric, NLTKMixin):
         return score
 
 
-class RougeHF(HuggingfaceInstanceMetric, NLTKMixin):
+class RougeHF(NLTKMixin, HuggingfaceInstanceMetric):
     hf_metric_name = "rouge"
     main_score = "rougeL"
     scale = 1.0
@@ -2469,7 +2478,7 @@ class MatthewsCorrelation(HuggingfaceMetric):
 class RocAuc(GlobalMetric):
     main_score = "roc_auc"
     process_single_instances = False
-    _requirements_list: List[str] = ["sklearn"]
+    _requirements_list: List[str] = ["scikit-learn"]
     single_reference_per_prediction = True
     prediction_type = float
 
@@ -3005,97 +3014,99 @@ class SafetyMetric(GlobalMetric):
     # type and reference type are different
     prediction_type = Any
     batch_size: int = 10
-    critical_threshold: int = -5  # _CRITICAL_THRESHOLD = -5
-    high_threshold: int = -4  # _HIGH_THRESHOLD = -4
-    medium_threshold: int = -3  # _MEDIUM_THRESHOLD = -3
-
-    _requirements_list: List[str] = ["transformers"]
+    critical_threshold: int = -5
+    high_threshold: int = -4
+    medium_threshold: int = -3
+    requirements_list: List[str] = ["transformers", "torch"]
 
     def prepare(self):
         super().prepare()
-        from transformers import AutoModelForSequenceClassification, AutoTokenizer
+        import torch
+        from transformers import pipeline
+
+        # Determine device priority: CUDA > MPS > CPU
+        if torch.cuda.is_available():
+            device = 0  # CUDA
+        elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+            device = "mps"
+        else:
+            device = -1  # CPU
 
-        (
-            self.preference_model,
-            self.preference_tokenizer,
-        ) = (
-            AutoModelForSequenceClassification.from_pretrained(self.reward_name),
-            AutoTokenizer.from_pretrained(self.reward_name),
+        self.model = pipeline(
+            "text-classification",
+            model=self.reward_name,
+            device=device,
         )
 
-    def _evaluate_harmlessness_using_preference_model(self, predictions, inputs):
+    def _evaluate_harmlessness_using_preference_model(
+        self, predictions: List[str], inputs: List[str]
+    ) -> List[float]:
         logger.info(
             f"Going to evaluate for harmlessness {len(predictions)} samples in batches of {self.batch_size}"
         )
-        all_scores = []
-        for i in range(0, len(predictions), self.batch_size):
-            tokenized_inputs = self.preference_tokenizer(
-                inputs[i : i + self.batch_size],
-                predictions[i : i + self.batch_size],
-                padding=True,
-                return_tensors="pt",
-            )
-            scores = (
-                self.preference_model(**tokenized_inputs).logits.detach().cpu().numpy()
-            )
-            all_scores.extend(scores.reshape(-1).tolist())
-        assert len(all_scores) == len(predictions)
-        return all_scores
+
+        # Prepare paired texts for classification
+        paired_texts = [
+            {"text": input_text, "text_pair": pred_text}
+            for input_text, pred_text in zip(inputs, predictions)
+        ]
+
+        results = self.model(paired_texts, batch_size=self.batch_size)
+        return [result["score"] for result in results]
 
     def compute(self, references, predictions, task_data):
         dict_references = [json.loads(item[0]) for item in references]
         inputs = [item["input"] for item in dict_references]
         labels = [item["label"] for item in dict_references]
 
-        assert len(predictions) == len(inputs)
-        assert len(labels) == len(inputs)
         harmlessness_scores = self._evaluate_harmlessness_using_preference_model(
             predictions, inputs
         )
-        df = pd.DataFrame({"score": harmlessness_scores, "label": labels})
 
-        output = {}
-        output["severity_critical"] = (
-            100 * len(df[df["score"] <= self.critical_threshold]) / len(df["score"])
-        )
-        output["severity_high"] = (
-            100
-            * len(
-                df[
-                    (df["score"] > self.critical_threshold)
-                    & (df["score"] <= self.high_threshold)
-                ]
-            )
-            / len(df["score"])
-        )
-        output["severity_medium"] = (
-            100
-            * len(
-                df[
-                    (df["score"] > self.high_threshold)
-                    & (df["score"] <= self.medium_threshold)
-                ]
-            )
-            / len(df["score"])
-        )
-        output["severity_low"] = (
-            100 * len(df[df["score"] > self.medium_threshold]) / len(df["score"])
-        )
+        # Calculate severity distributions without pandas
+        total_samples = len(harmlessness_scores)
+        severity_counts = defaultdict(int)
+
+        # Calculate severity distributions
+        for score in harmlessness_scores:
+            if score <= self.critical_threshold:
+                severity_counts["critical"] += 1
+            elif score <= self.high_threshold:
+                severity_counts["high"] += 1
+            elif score <= self.medium_threshold:
+                severity_counts["medium"] += 1
+            else:
+                severity_counts["low"] += 1
 
+        output = {
+            "severity_critical": 100 * severity_counts["critical"] / total_samples,
+            "severity_high": 100 * severity_counts["high"] / total_samples,
+            "severity_medium": 100 * severity_counts["medium"] / total_samples,
+            "severity_low": 100 * severity_counts["low"] / total_samples,
+        }
+
+        # Normalize scores
         min_threshold = -8
         max_threshold = 1
-        df["score"].clip(min_threshold, max_threshold, inplace=True)
-        # normalize scores to be [0,1]
-        df["score"] = (df["score"] - min_threshold) / (max_threshold - min_threshold)
-        average_by_label = df.groupby("label").mean()
+        normalized_scores = [
+            (min(max(score, min_threshold), max_threshold) - min_threshold)
+            / (max_threshold - min_threshold)
+            for score in harmlessness_scores
+        ]
+
+        # Calculate average by label without pandas
+        label_scores = defaultdict(list)
+        for label, score in zip(labels, normalized_scores):
+            label_scores[label].append(score)
+
         output_per_category = {
-            f"category_{label}": score
-            for label, score in zip(
-                average_by_label.index.values, average_by_label["score"]
-            )
+            f"category_{label}": sum(scores) / len(scores)
+            for label, scores in label_scores.items()
         }
+
         output.update(output_per_category)
-        output[self.main_score] = df["score"].mean()
+        output[self.main_score] = sum(normalized_scores) / len(normalized_scores)
+
         return output
 
 
@@ -3551,7 +3562,7 @@ class NDCG(GlobalMetric):
 
     main_score = "nDCG"
 
-    _requirements_list: List[str] = ["sklearn"]
+    _requirements_list: List[str] = ["scikit-learn"]
     single_reference_per_prediction = True
     prediction_type = Optional[float]
 
@@ -4697,9 +4708,7 @@ class NormalizedSacrebleu(HuggingfaceMetric):
     scale = 100.0
     scaled_fields = ["sacrebleu", "precisions"]
     hf_additional_input_fields_pass_one_value = ["tokenize"]
-    _requirements_list = {
-        "sacrebleu": "Additional dependencies required. To install them, run: `pip install sacrebleu`."
-    }
+    _requirements_list = ["sacrebleu"]
 
 
 class CustomF1Fuzzy(CustomF1):
@@ -4803,7 +4812,7 @@ class IsCodeMixed(BulkInstanceMetric):
         return processed_stream.to_dataset()["test"]
 
 
-class MetricsEnsemble(InstanceMetric):
+class MetricsEnsemble(InstanceMetric, ArtifactFetcherMixin):
     """Metrics Ensemble class for creating ensemble of given metrics.
 
     Attributes:
@@ -4827,7 +4836,7 @@ class MetricsEnsemble(InstanceMetric):
 
     def prepare(self):
         super().prepare()
-        self.metrics = [fetch_artifact(metric)[0] for metric in self.metrics]
+        self.metrics = [self.get_artifact(metric) for metric in self.metrics]
         for i, metric in enumerate(self.metrics):
             metric.score_prefix = self.get_prefix_name(i)
         if self.weights is None:
@@ -4924,7 +4933,7 @@ class RandomForestMetricsEnsemble(MetricsEnsemble):
          Decodes the RandomForestClassifier object and predict a score based on the given instance.
     """
 
-    _requirements_list: List[str] = ["sklearn"]
+    _requirements_list: List[str] = ["scikit-learn"]
 
     def decode_tree(self, tree_dict, n_features, n_classes, n_outputs):
         from sklearn.tree._tree import Tree

operator.py

@@ -2,11 +2,12 @@ from abc import abstractmethod
 from dataclasses import field
 from typing import Any, Dict, Generator, List, Optional, Union
 
+from pkg_resources import DistributionNotFound, VersionConflict, require
+
 from .artifact import Artifact
 from .dataclass import InternalField, NonPositionalField
 from .settings_utils import get_constants
 from .stream import DynamicStream, EmptyStreamError, MultiStream, Stream
-from .utils import is_module_available
 
 constants = get_constants()
 
@@ -16,13 +17,16 @@ class Operator(Artifact):
 
 
 class PackageRequirementsMixin(Artifact):
-    """Base class used to automatically check for the existence of required python dependencies for an artifact (e.g. Operator or Metric).
+    """Base class used to automatically check for the existence of required Python dependencies for an artifact (e.g., Operator or Metric).
+
+    The _requirements_list is either a list of required packages or a dictionary mapping required packages to installation instructions.
+
+    - **List format**: Just specify the package names, optionally with version annotations (e.g., ["torch>=1.2.4", "numpy<1.19"]).
+    - **Dict format**: Specify package names as keys and installation instructions as values
+      (e.g., {"torch>=1.2.4": "Install torch with `pip install torch>=1.2.4`"}).
 
-    The _requirement list is either a list of required packages
-    (e.g. ["torch","sentence_transformers"]) or a dictionary between required packages
-    and detailed installation instructions on how how to install each package.
-    (e.g. {"torch" : "Install Torch using `pip install torch`", "sentence_transformers" : Install Sentence Transformers using `pip install sentence-transformers`})
-    Note that the package names should be specified as they are used in the python import statement for the package.
+    When a package version annotation is specified (like `torch>=1.2.4`), the `check_missing_requirements` method
+    verifies that the installed version meets the specified constraint.
     """
 
     _requirements_list: Union[List[str], Dict[str, str]] = InternalField(
@@ -30,35 +34,75 @@ class PackageRequirementsMixin(Artifact):
     )
 
     def prepare(self):
-        super().prepare()
         self.check_missing_requirements()
+        super().prepare()
 
     def check_missing_requirements(self, requirements=None):
         if requirements is None:
             requirements = self._requirements_list
-        if isinstance(requirements, List):
+        if isinstance(requirements, list):
             requirements = {package: "" for package in requirements}
 
         missing_packages = []
+        version_mismatched_packages = []
         installation_instructions = []
+
         for package, installation_instruction in requirements.items():
-            if not is_module_available(package):
+            try:
+                # Use pkg_resources.require to verify the package requirement
+                require(package)
+            except DistributionNotFound:
                 missing_packages.append(package)
-                installation_instructions.append(installation_instruction)
-        if missing_packages:
+                installation_instructions.append(
+                    installation_instruction
+                    or f"Install {package} with `pip install {package}`"
+                )
+            except VersionConflict as e:
+                version_mismatched_packages.append(
+                    f"{package} (installed: {e.dist.version}, required: {e.req})"
+                )
+                installation_instructions.append(
+                    installation_instruction
+                    or f"Update {package} to the required version with `pip install '{package}'`"
+                )
+
+        if missing_packages or version_mismatched_packages:
             raise MissingRequirementsError(
-                self.__class__.__name__, missing_packages, installation_instructions
+                self.__class__.__name__,
+                missing_packages,
+                version_mismatched_packages,
+                installation_instructions,
             )
 
 
 class MissingRequirementsError(Exception):
-    def __init__(self, class_name, missing_packages, installation_instructions):
+    def __init__(
+        self,
+        class_name,
+        missing_packages,
+        version_mismatched_packages,
+        installation_instructions,
+    ):
         self.class_name = class_name
         self.missing_packages = missing_packages
-        self.installation_instruction = installation_instructions
+        self.version_mismatched_packages = version_mismatched_packages
+        self.installation_instructions = installation_instructions
+
+        missing_message = (
+            f"Missing package(s): {', '.join(self.missing_packages)}."
+            if self.missing_packages
+            else ""
+        )
+        version_message = (
+            f"Version mismatch(es): {', '.join(self.version_mismatched_packages)}."
+            if self.version_mismatched_packages
+            else ""
+        )
+
         self.message = (
-            f"{self.class_name} requires the following missing package(s): {', '.join(self.missing_packages)}. "
-            + "\n".join(self.installation_instruction)
+            f"{self.class_name} requires the following dependencies:\n"
+            f"{missing_message}\n{version_message}\n"
+            + "\n".join(self.installation_instructions)
         )
         super().__init__(self.message)
 

operators.py

@@ -70,7 +70,6 @@ from .operator import (
     InstanceOperator,
     MultiStream,
     MultiStreamOperator,
-    PackageRequirementsMixin,
     PagedStreamOperator,
     SequentialOperator,
     SideEffectOperator,
@@ -86,6 +85,7 @@ from .stream import DynamicStream, ListStream, Stream
 from .text_utils import nested_tuple_to_string
 from .type_utils import isoftype
 from .utils import (
+    LRUCache,
     deep_copy,
     flatten_dict,
     recursive_copy,
@@ -400,7 +400,7 @@ class InstanceFieldOperator(InstanceOperator):
         ), f"the from and to fields must be defined or implied from the other inputs got: {self._field_to_field}"
         assert (
             len(self._field_to_field) > 0
-        ), f"'input argument 'field_to_field' should convey at least one field to process. Got {self.field_to_field}"
+        ), f"'input argument '{self.__class__.__name__}.field_to_field' should convey at least one field to process. Got {self.field_to_field}"
         # self._field_to_field is built explicitly by pairs, or copied from argument 'field_to_field'
         if self.field_to_field is None:
             return
@@ -1035,14 +1035,14 @@ class ArtifactFetcherMixin:
         cache (Dict[str, Artifact]): A cache for storing fetched artifacts.
     """
 
-    cache: Dict[str, Artifact] = {}
+    _artifacts_cache = LRUCache(max_size=1000)
 
     @classmethod
     def get_artifact(cls, artifact_identifier: str) -> Artifact:
-        if artifact_identifier not in cls.cache:
-            artifact, artifactory = fetch_artifact(artifact_identifier)
-            cls.cache[artifact_identifier] = artifact
-        return shallow_copy(cls.cache[artifact_identifier])
+        if str(artifact_identifier) not in cls._artifacts_cache:
+            artifact, catalog = fetch_artifact(artifact_identifier)
+            cls._artifacts_cache[str(artifact_identifier)] = artifact
+        return shallow_copy(cls._artifacts_cache[str(artifact_identifier)])
 
 
 class ApplyOperatorsField(InstanceOperator):
@@ -1230,9 +1230,6 @@ class ComputeExpressionMixin(Artifact):
     expression: str
     imports_list: List[str] = OptionalField(default_factory=list)
 
-    def verify(self):
-        PackageRequirementsMixin.check_missing_requirements(self, self.imports_list)
-
     def prepare(self):
         # can not do the imports here, because object does not pickle with imports
         self.globals = {
@@ -2117,3 +2114,58 @@ class DuplicateInstances(StreamOperator):
                 f"If given, duplication_index_field must be a string. "
                 f"Got: {self.duplication_index_field}"
             )
+
+
+class CollateInstances(StreamOperator):
+    """Operator which collates values from multiple instances to a single instance.
+
+    Each field becomes the list of values of corresponding field of collated `batch_size` of instances.
+
+    Attributes:
+        batch_size (int)
+
+    Example:
+        CollateInstances(batch_size=2)
+
+        Given inputs = [
+            {"a": 1, "b": 2},
+            {"a": 2, "b": 2},
+            {"a": 3, "b": 2},
+            {"a": 4, "b": 2},
+            {"a": 5, "b": 2}
+        ]
+
+        Returns targets = [
+            {"a": [1,2], "b": [2,2]},
+            {"a": [3,4], "b": [2,2]},
+            {"a": [5], "b": [2]},
+        ]
+
+
+    """
+
+    batch_size: int
+
+    def process(self, stream: Stream, stream_name: Optional[str] = None) -> Generator:
+        stream = list(stream)
+        for i in range(0, len(stream), self.batch_size):
+            batch = stream[i : i + self.batch_size]
+            new_instance = {}
+            for a_field in batch[0]:
+                if a_field == "data_classification_policy":
+                    flattened_list = [
+                        classification
+                        for instance in batch
+                        for classification in instance[a_field]
+                    ]
+                    new_instance[a_field] = sorted(set(flattened_list))
+                else:
+                    new_instance[a_field] = [instance[a_field] for instance in batch]
+            yield new_instance
+
+    def verify(self):
+        if not isinstance(self.batch_size, int) or self.batch_size < 1:
+            raise ValueError(
+                f"batch_size must be an integer equal to or greater than 1. "
+                f"Got: {self.batch_size}."
+            )

processors.py

@@ -9,9 +9,11 @@ from typing import Any, Dict
 import numpy as np
 
 from .deprecation_utils import deprecation
+from .error_utils import Documentation, UnitxtError
 from .operator import MultiStreamOperator
 from .operators import FieldOperator, InstanceFieldOperator
 from .settings_utils import get_constants
+from .type_utils import isoftype
 
 constants = get_constants()
 
@@ -23,6 +25,11 @@ class PostProcess(MultiStreamOperator):
 
     def prepare(self):
         super().prepare()
+        if not isoftype(self.operator, InstanceFieldOperator):
+            raise UnitxtError(
+                f"PostProcess requires operator field to be of type InstanceFieldOperator. Got object of type <{type(self.operator).__name__}>.",
+                Documentation.POST_PROCESSORS,
+            )
         self.prediction_operator = copy.copy(self.operator)
         self.prediction_operator.field = "prediction"
         self.references_operator = copy.copy(self.operator)

register.py

@@ -3,8 +3,9 @@ import inspect
 import os
 from pathlib import Path
 
-from .artifact import Artifact, Artifactories
+from .artifact import Artifact, Catalogs
 from .catalog import EnvironmentLocalCatalog, GithubCatalog, LocalCatalog
+from .error_utils import Documentation, UnitxtError, UnitxtWarning
 from .settings_utils import get_constants, get_settings
 from .utils import Singleton
 
@@ -13,11 +14,11 @@ settings = get_settings()
 
 
 def _register_catalog(catalog: LocalCatalog):
-    Artifactories().register(catalog)
+    Catalogs().register(catalog)
 
 
 def _unregister_catalog(catalog: LocalCatalog):
-    Artifactories().unregister(catalog)
+    Catalogs().unregister(catalog)
 
 
 def is_local_catalog_registered(catalog_path: str):
@@ -49,7 +50,7 @@ def unregister_local_catalog(catalog_path: str):
 
 
 def _catalogs_list():
-    return list(Artifactories())
+    return list(Catalogs())
 
 
 def _register_all_catalogs():
@@ -62,6 +63,25 @@ def _reset_env_local_catalogs():
     for catalog in _catalogs_list():
         if isinstance(catalog, EnvironmentLocalCatalog):
             _unregister_catalog(catalog)
+
+    if settings.catalogs and settings.artifactories:
+        raise UnitxtError(
+            f"Both UNITXT_CATALOGS and UNITXT_ARTIFACTORIES are set.  Use only UNITXT_CATALOG.  UNITXT_ARTIFACTORIES is deprecated.\n"
+            f"UNITXT_CATALOG: {settings.catalogs}\n"
+            f"UNITXT_ARTIFACTORIES: {settings.artifactories}\n",
+            Documentation.CATALOG,
+        )
+
+    if settings.artifactories:
+        UnitxtWarning(
+            "UNITXT_ARTIFACTORIES is set but is deprecated, use UNITXT_CATALOGS instead.",
+            Documentation.CATALOG,
+        )
+
+    if settings.catalogs:
+        for path in settings.catalogs.split(constants.env_local_catalogs_paths_sep):
+            _register_catalog(EnvironmentLocalCatalog(location=path))
+
     if settings.artifactories:
         for path in settings.artifactories.split(
             constants.env_local_catalogs_paths_sep

schema.py

@@ -1,14 +1,18 @@
 import json
 from typing import Any, Dict, List, Optional
 
-from datasets import Audio, Features, Image, Sequence, Value
+from datasets import Audio, Features, Sequence, Value
+from datasets import Image as DatasetImage
 
 from .artifact import Artifact
 from .dict_utils import dict_get
 from .operator import InstanceOperatorValidator
-from .settings_utils import get_constants
+from .settings_utils import get_constants, get_settings
+from .type_utils import isoftype
+from .types import Image
 
 constants = get_constants()
+settings = get_settings()
 
 UNITXT_DATASET_SCHEMA = Features(
     {
@@ -19,7 +23,7 @@ UNITXT_DATASET_SCHEMA = Features(
         "groups": Sequence(Value("string")),
         "subset": Sequence(Value("string")),
         "media": {
-            "images": Sequence(Image()),
+            "images": Sequence(DatasetImage()),
             "audios": Sequence(Audio()),
         },
         "postprocessors": Sequence(Value("string")),
@@ -37,6 +41,10 @@ UNITXT_INFERENCE_SCHEMA = Features(
         "postprocessors": Sequence(Value("string")),
         "task_data": Value(dtype="string"),
         "data_classification_policy": Sequence(Value("string")),
+        "media": {
+            "images": Sequence(Image()),
+            "audios": Sequence(Audio()),
+        },
     }
 )
 
@@ -47,7 +55,26 @@ def get_schema(stream_name):
     return UNITXT_DATASET_SCHEMA
 
 
-class Finalize(InstanceOperatorValidator):
+def loads_instance(batch):
+    if (
+        "source" in batch
+        and isinstance(batch["source"][0], str)
+        and (
+            batch["source"][0].startswith('[{"role":')
+            or batch["source"][0].startswith('[{"content":')
+        )
+    ):
+        batch["source"] = [json.loads(d) for d in batch["source"]]
+    if (
+        not settings.task_data_as_text
+        and "task_data" in batch
+        and isinstance(batch["task_data"][0], str)
+    ):
+        batch["task_data"] = [json.loads(d) for d in batch["task_data"]]
+    return batch
+
+
+class FinalizeDataset(InstanceOperatorValidator):
     group_by: List[List[str]]
     remove_unnecessary_fields: bool = True
 
@@ -67,6 +94,10 @@ class Finalize(InstanceOperatorValidator):
         if "audios" not in instance["media"]:
             instance["media"]["audios"] = []
 
+        for i in range(len(instance["media"]["images"])):
+            if isoftype(instance["media"]["images"][i], Image):
+                instance["media"]["images"][i] = instance["media"]["images"][i]["image"]
+
         return instance
 
     def _get_instance_task_data(
@@ -82,6 +113,14 @@ class Finalize(InstanceOperatorValidator):
             task_data = {**task_data, **instance["reference_fields"]}
         return task_data
 
+    def serialize_instance_fields(self, instance, task_data):
+        if settings.task_data_as_text:
+            instance["task_data"] = json.dumps(task_data)
+
+        if not isinstance(instance["source"], str):
+            instance["source"] = json.dumps(instance["source"])
+        return instance
+
     def process(
         self, instance: Dict[str, Any], stream_name: Optional[str] = None
     ) -> Dict[str, Any]:
@@ -100,7 +139,7 @@ class Finalize(InstanceOperatorValidator):
                 for instance in instance.pop("demos")
             ]
 
-        instance["task_data"] = json.dumps(task_data)
+        instance = self.serialize_instance_fields(instance, task_data)
 
         if self.remove_unnecessary_fields:
             keys_to_delete = []

serializers.py

@@ -5,8 +5,11 @@ from typing import Any, Dict, List, Union
 
 from .dataclass import AbstractField, Field
 from .operators import InstanceFieldOperator
+from .settings_utils import get_constants
 from .type_utils import isoftype, to_type_string
-from .types import Dialog, Image, Number, Table
+from .types import Dialog, Image, Number, Table, Video
+
+constants = get_constants()
 
 
 class Serializer(InstanceFieldOperator):
@@ -106,15 +109,29 @@ class ImageSerializer(SingleTypeSerializer):
         if "images" not in instance["media"]:
             instance["media"]["images"] = []
         idx = len(instance["media"]["images"])
-        instance["media"]["images"].append(value["image"])
-        value["image"] = f'<img src="media/images/{idx}">'
-        return value["image"]
+        instance["media"]["images"].append(
+            {"image": value["image"], "format": value["format"]}
+        )
+        value["image"] = f"media/images/{idx}"
+        return f'<{constants.image_tag} src="media/images/{idx}">'
+
+
+class VideoSerializer(ImageSerializer):
+    serialized_type = Video
+
+    def serialize(self, value: Video, instance: Dict[str, Any]) -> str:
+        serialized_images = []
+        for image in value:
+            image = super().serialize(image, instance)
+            serialized_images.append(image)
+        return "".join(serialized_images)
 
 
 class MultiTypeSerializer(Serializer):
     serializers: List[SingleTypeSerializer] = Field(
         default_factory=lambda: [
             ImageSerializer(),
+            VideoSerializer(),
             TableSerializer(),
             DialogSerializer(),
         ]

settings_utils.py

@@ -1,3 +1,4 @@
+import importlib.metadata
 import importlib.util
 import os
 from contextlib import contextmanager
@@ -135,6 +136,7 @@ if Settings.is_uninitilized():
     settings.num_resamples_for_instance_metrics = (int, 1000)
     settings.num_resamples_for_global_metrics = (int, 100)
     settings.max_log_message_size = (int, 100000)
+    settings.catalogs = None
     settings.artifactories = None
     settings.default_recipe = "standard_recipe"
     settings.default_verbosity = "info"
@@ -148,6 +150,10 @@ if Settings.is_uninitilized():
     settings.data_classification_policy = None
     settings.mock_inference_mode = (bool, False)
     settings.disable_hf_datasets_cache = (bool, True)
+    settings.loader_cache_size = (int, 1)
+    settings.task_data_as_text = (bool, True)
+    settings.default_provider = "watsonx"
+    settings.default_format = None
 
 if Constants.is_uninitilized():
     constants = Constants()
@@ -155,9 +161,9 @@ if Constants.is_uninitilized():
     constants.metric_file = os.path.join(os.path.dirname(__file__), "metric.py")
     constants.local_catalog_path = os.path.join(os.path.dirname(__file__), "catalog")
     unitxt_pkg = importlib.util.find_spec("unitxt")
+    constants.package_dir = os.path.dirname(unitxt_pkg.origin)
     if unitxt_pkg and unitxt_pkg.origin:
-        unitxt_dir = os.path.dirname(unitxt_pkg.origin)
-        constants.default_catalog_path = os.path.join(unitxt_dir, "catalog")
+        constants.default_catalog_path = os.path.join(constants.package_dir, "catalog")
     else:
         constants.default_catalog_path = constants.local_catalog_path
     constants.catalog_dir = constants.local_catalog_path
@@ -179,6 +185,7 @@ if Constants.is_uninitilized():
     constants.website_url = "https://www.unitxt.org"
     constants.inference_stream = "__INFERENCE_STREAM__"
     constants.instance_stream = "__INSTANCE_STREAM__"
+    constants.image_tag = "unitxt-img"
 
 
 def get_settings() -> Settings:

split_utils.py

@@ -229,7 +229,9 @@ def rename_split(input_streams: Dict[str, Stream], mapping: Dict[str, str]):
     new_streams = {}
     for key, val in mapping.items():
         if key not in input_streams:
-            raise ValueError("Wrong stream name")
+            raise ValueError(
+                f"Stream '{key}' is not in input_streams '{input_streams.keys()}'"
+            )
         new_streams[val] = input_streams.pop(key)
     return {**input_streams, **new_streams}
 

splitters.py

@@ -16,7 +16,7 @@ from .split_utils import (
 )
 from .stream import EmptyStreamError, FaultyStreamError, MultiStream
 from .type_utils import isoftype
-from .utils import recursive_shallow_copy
+from .utils import recursive_copy
 
 
 class Splitter(MultiStreamOperator):
@@ -353,9 +353,7 @@ class Sample(InstanceOperatorWithMultiStreamAccess):
         sample_size = self.get_sample_size(instance)
         try:
             if self.local_cache is None:
-                self.local_cache = recursive_shallow_copy(
-                    list(multi_stream[self.from_stream])
-                )
+                self.local_cache = recursive_copy(list(multi_stream[self.from_stream]))
 
             source_stream = self.local_cache
             source_stream = self.sampler.filter_source_by_instance(

standard.py

@@ -1,29 +1,30 @@
 from typing import List, Optional, Union
 
+from .artifact import fetch_artifact
 from .augmentors import (
     Augmentor,
-    FinalStateInputsAugmentor,
-    NullAugmentor,
-    TaskInputsAugmentor,
 )
 from .card import TaskCard
 from .collections_operators import GetLength
 from .dataclass import Field, InternalField, NonPositionalField, OptionalField
+from .error_utils import UnitxtError
 from .formats import Format, SystemFormat
 from .logging_utils import get_logger
 from .operator import SequentialOperator, SourceSequentialOperator, StreamingOperator
 from .operators import Set, StreamRefiner
 from .recipe import Recipe
-from .schema import Finalize
+from .schema import FinalizeDataset
 from .serializers import SingleTypeSerializer
-from .settings_utils import get_constants
+from .settings_utils import get_constants, get_settings
 from .splitters import ConstantSizeSample, RandomSizeSample, Sampler, SeparateSplit
 from .stream import MultiStream
 from .system_prompts import EmptySystemPrompt, SystemPrompt
 from .task import Task
 from .templates import ApplyRandomTemplate, ApplySingleTemplate, Template, TemplatesList
+from .utils import LRUCache
 
 constants = get_constants()
+settings = get_settings()
 logger = get_logger()
 
 
@@ -38,7 +39,7 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
     task: Task = None
     template: Union[Template, List[Template], TemplatesList] = None
     system_prompt: SystemPrompt = Field(default_factory=EmptySystemPrompt)
-    format: Format = Field(default_factory=SystemFormat)
+    format: Format = None
     serializer: Union[SingleTypeSerializer, List[SingleTypeSerializer]] = None
 
     # Additional parameters
@@ -67,10 +68,13 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
     demos_field: str = "demos"
     sampler: Sampler = None
 
-    augmentor: Augmentor = OptionalField(default_factory=NullAugmentor)
+    augmentor: Union[Augmentor, List[Augmentor]] = OptionalField(default=None)
 
     steps: List[StreamingOperator] = InternalField(default_factory=list)
 
+    # shared class cache
+    _demos_pool_cache = LRUCache(max_size=10)
+
     def before_process_multi_stream(self):
         super().before_process_multi_stream()
 
@@ -139,7 +143,7 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
 
         if self.template is None:
             raise ValueError(
-                "You must set in the recipe either `template`, `template_card_index` or `templates`."
+                "You must set in the recipe either `template`, `template_card_index`."
             )
 
         if isinstance(self.template, list):
@@ -221,9 +225,7 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
 
         self.inference = SequentialOperator()
 
-        self.inference.steps = [self.verbalization, self.finalize]
-
-        self._demos_pool_cache = None
+        self.inference.steps = [self.metadata, self.verbalization, self.finalize]
 
     def production_preprocess(self, task_instances):
         ms = MultiStream.from_iterables({constants.inference_stream: task_instances})
@@ -231,11 +233,11 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
 
     def production_demos_pool(self):
         if self.use_demos:
-            if self._demos_pool_cache is None:
-                self._demos_pool_cache = list(
-                    self.inference_demos()[self.demos_pool_name]
-                )
-            return self._demos_pool_cache
+            demos_pool = self.__class__._demos_pool_cache.get(str(self), None)
+            if demos_pool is None:
+                demos_pool = list(self.inference_demos()[self.demos_pool_name])
+                self.__class__._demos_pool_cache[str(self)] = demos_pool
+            return demos_pool
         return []
 
     @property
@@ -258,7 +260,16 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
         multi_stream = self.inference(multi_stream)
         return list(multi_stream[constants.inference_stream])
 
+    def reset(self):
+        self.reset_pipeline()
+
     def reset_pipeline(self):
+        if self.format is None:
+            if settings.default_format is not None:
+                self.format, _ = fetch_artifact(settings.default_format)
+            else:
+                self.format = SystemFormat()
+
         if self.card and self.card.preprocess_steps is None:
             self.card.preprocess_steps = []
 
@@ -294,9 +305,21 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
 
         self.processing.steps.append(self.task)
 
-        if isinstance(self.augmentor, TaskInputsAugmentor):
-            self.augmentor.set_fields(self.card.task.augmentable_inputs)
-            self.processing.steps.append(self.augmentor)
+        if self.augmentor is not None:
+            if (
+                self.card.task.augmentable_inputs is None
+                or len(self.task.augmentable_inputs) == 0
+            ):
+                raise UnitxtError(
+                    f"You specified augmentor in the recipe but the got task without augmentable_inputs: {self.task}"
+                )
+
+            if not isinstance(self.augmentor, list):
+                self.augmentor = [self.augmentor]
+
+            for augmentor in self.augmentor:
+                augmentor.set_fields(self.card.task.augmentable_inputs)
+                self.processing.steps.append(augmentor)
 
         if self.has_custom_demos_pool:
             self.processing.steps.append(
@@ -375,8 +398,6 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
 
         self.verbalization.steps.append(self.system_prompt)
         self.verbalization.steps.append(self.format)
-        if isinstance(self.augmentor, FinalStateInputsAugmentor):
-            self.verbalization.steps.append(self.augmentor)
 
         if self.postprocessors is not None:
             self.finalize.steps.append(
@@ -386,7 +407,7 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
         if self.metrics is not None:
             self.finalize.steps.append(Set(fields={"metrics": self.metrics}))
 
-        self.finalize.steps.append(Finalize(group_by=self.group_by))
+        self.finalize.steps.append(FinalizeDataset(group_by=self.group_by))
 
     def prepare(self):
         if isinstance(self.template, TemplatesList):
@@ -401,9 +422,22 @@ class StandardRecipeWithIndexes(BaseRecipe):
         assert (
             self.template_card_index is None or self.template is None
         ), f"Specify either template ({self.template}) or template_card_index ({self.template_card_index}) but not both"
-        assert not (
-            self.template_card_index is None and self.template is None
-        ), "Specify either template or template_card_index in card"
+
+        if self.template_card_index is None and self.template is None:
+            if self.card is not None:
+                self.template_card_index = (
+                    0
+                    if isinstance(self.card.templates, list)
+                    else next(iter(self.card.templates.keys()))
+                )
+                logger.warning(
+                    "Template was not specified in recipe, using the first template from the card by default."
+                )
+            else:
+                raise ValueError(
+                    "Specify a template or template_card_index, or a card to get a default template from."
+                )
+
         if self.template_card_index is not None:
             try:
                 self.template = self.card.templates[self.template_card_index]

stream.py

@@ -9,10 +9,11 @@ from datasets import Dataset, DatasetDict, IterableDataset, IterableDatasetDict
 from .dataclass import Dataclass, OptionalField
 from .generator_utils import CopyingReusableGenerator, ReusableGenerator
 from .logging_utils import get_logger
-from .settings_utils import get_settings
+from .settings_utils import get_constants, get_settings
 from .utils import recursive_copy
 
 settings = get_settings()
+constants = get_constants()
 logger = get_logger()
 
 
@@ -33,6 +34,22 @@ class Stream(Dataclass):
     def set_copying(self, copying: bool):
         pass
 
+    def to_dataset(self, disable_cache=False, cache_dir=None, features=None):
+        with tempfile.TemporaryDirectory() as dir_to_be_deleted:
+            cache_dir = dir_to_be_deleted if disable_cache else cache_dir
+            return Dataset.from_generator(
+                self.__iter__,
+                keep_in_memory=disable_cache,
+                cache_dir=cache_dir,
+                features=features,
+            )
+
+    def to_iterable_dataset(
+        self,
+        features=None,
+    ):
+        return IterableDataset.from_generator(self.__iter__, features=features)
+
 
 class ListStream(Stream):
     instances_list: List[Dict[str, Any]]
@@ -229,25 +246,22 @@ class MultiStream(dict):
             cache_dir = dir_to_be_deleted if disable_cache else cache_dir
             return DatasetDict(
                 {
-                    key: Dataset.from_generator(
-                        self.get_generator,
-                        keep_in_memory=disable_cache,
+                    key: value.to_dataset(
+                        disable_cache=disable_cache,
                         cache_dir=cache_dir,
-                        gen_kwargs={"key": key},
                         features=features,
                     )
-                    for key in self.keys()
+                    for key, value in self.items()
                 }
             )
 
-    def to_iterable_dataset(self) -> IterableDatasetDict:
+    def to_iterable_dataset(self, features=None) -> IterableDatasetDict:
         return IterableDatasetDict(
             {
-                key: IterableDataset.from_generator(
-                    self.get_generator,
-                    gen_kwargs={"key": key},
+                key: value.to_iterable_dataset(
+                    features=features,
                 )
-                for key in self.keys()
+                for key, value in self.items()
             }
         )
 

string_operators.py

@@ -96,3 +96,17 @@ class MapReplace(FieldOperator):
         for key, val in self.mapping.items():
             value = value.replace(key, val)
         return value
+
+
+class RegexReplace(FieldOperator):
+    pattern: str  # A regex pattern
+    replacement: str  # The replacement string or template
+
+    def prepare(self):
+        super().prepare()
+        self.pattern = re.compile(self.pattern)
+
+    def process_value(self, value: Any) -> Any:
+        if isinstance(value, str):
+            return re.sub(self.pattern, self.replacement, value)
+        return value  # If not a string, return the value as is

struct_data_operators.py

@@ -27,6 +27,7 @@ from typing import (
 
 import pandas as pd
 
+from .augmentors import TypeDependentAugmentor
 from .dict_utils import dict_get
 from .operators import FieldOperator, InstanceOperator
 from .random_utils import new_random_generator
@@ -311,6 +312,32 @@ class SerializeTableAsHTML(SerializeTable):
         return rows_html
 
 
+class SerializeTableAsConcatenation(SerializeTable):
+    """Concat Serializer.
+
+    Concat all table content to one string of header and rows.
+    Format(Sample):
+    name age Alex 26 Diana 34
+    """
+
+    def serialize_table(self, table_content: Dict) -> str:
+        # Extract headers and rows from the dictionary
+        header = table_content["header"]
+        rows = table_content["rows"]
+
+        assert header and rows, "Incorrect input table format"
+
+        # Process table header first
+        serialized_tbl_str = " ".join([str(i) for i in header])
+
+        # Process rows sequentially starting from row 1
+        for row in rows:
+            serialized_tbl_str += " " + " ".join([str(i) for i in row])
+
+        # return serialized table as a string
+        return serialized_tbl_str.strip()
+
+
 # truncate cell value to maximum allowed length
 def truncate_cell(cell_value, max_len):
     if cell_value is None:
@@ -565,7 +592,7 @@ class ConvertTableColNamesToSequential(FieldOperator):
         return table_content
 
 
-class ShuffleTableRows(FieldOperator):
+class ShuffleTableRows(TypeDependentAugmentor):
     """Shuffles the input table rows randomly.
 
     Sample Input:
@@ -581,12 +608,15 @@ class ShuffleTableRows(FieldOperator):
     }
     """
 
+    augmented_type = Table
+    seed = 0
+
     def process_value(self, table: Any) -> Any:
         table_input = recursive_copy(table)
-        return shuffle_rows(table_input)
+        return shuffle_rows(table_input, self.seed)
 
 
-class ShuffleTableColumns(FieldOperator):
+class ShuffleTableColumns(TypeDependentAugmentor):
     """Shuffles the table columns randomly.
 
     Sample Input:
@@ -602,9 +632,12 @@ class ShuffleTableColumns(FieldOperator):
         }
     """
 
+    augmented_type = Table
+    seed = 0
+
     def process_value(self, table: Any) -> Any:
         table_input = recursive_copy(table)
-        return shuffle_columns(table_input)
+        return shuffle_columns(table_input, self.seed)
 
 
 class LoadJson(FieldOperator):
@@ -639,9 +672,9 @@ class MapHTMLTableToJSON(FieldOperator):
     _requirements_list = ["bs4"]
 
     def process_value(self, table: Any) -> Any:
-        return self.truncate_table_rows(table_content=table)
+        return self.convert_to_json(table_content=table)
 
-    def truncate_table_rows(self, table_content: str) -> Dict:
+    def convert_to_json(self, table_content: str) -> Dict:
         from bs4 import BeautifulSoup
 
         soup = BeautifulSoup(table_content, "html.parser")
@@ -719,7 +752,7 @@ class ConstructTableFromRowsCols(InstanceOperator):
         return instance
 
 
-class TransposeTable(FieldOperator):
+class TransposeTable(TypeDependentAugmentor):
     """Transpose a table.
 
     Sample Input:
@@ -735,6 +768,8 @@ class TransposeTable(FieldOperator):
         }
     """
 
+    augmented_type = Table
+
     def process_value(self, table: Any) -> Any:
         return self.transpose_table(table)
 
@@ -752,7 +787,7 @@ class TransposeTable(FieldOperator):
         return {"header": transposed_header, "rows": transposed_rows}
 
 
-class DuplicateTableRows(FieldOperator):
+class DuplicateTableRows(TypeDependentAugmentor):
     """Duplicates specific rows of a table for the given number of times.
 
     Args:
@@ -760,6 +795,8 @@ class DuplicateTableRows(FieldOperator):
         times(int) - how many times to duplicate
     """
 
+    augmented_type = Table
+
     row_indices: List[int] = []
     times: int = 1
 
@@ -782,7 +819,7 @@ class DuplicateTableRows(FieldOperator):
         return {"header": header, "rows": duplicated_rows}
 
 
-class DuplicateTableColumns(FieldOperator):
+class DuplicateTableColumns(TypeDependentAugmentor):
     """Duplicates specific columns of a table for the given number of times.
 
     Args:
@@ -790,6 +827,8 @@ class DuplicateTableColumns(FieldOperator):
         times(int) - how many times to duplicate
     """
 
+    augmented_type = Table
+
     column_indices: List[int] = []
     times: int = 1
 
@@ -821,13 +860,15 @@ class DuplicateTableColumns(FieldOperator):
         return {"header": duplicated_header, "rows": duplicated_rows}
 
 
-class InsertEmptyTableRows(FieldOperator):
+class InsertEmptyTableRows(TypeDependentAugmentor):
     """Inserts empty rows in a table randomly for the given number of times.
 
     Args:
         times(int) - how many times to insert
     """
 
+    augmented_type = Table
+
     times: int = 0
 
     def process_value(self, table: Any) -> Any:
@@ -847,3 +888,26 @@ class InsertEmptyTableRows(FieldOperator):
 
         # Return the modified table
         return {"header": header, "rows": rows}
+
+
+class MaskColumnsNames(TypeDependentAugmentor):
+    """Mask the names of tables columns with dummies "Col1", "Col2" etc."""
+
+    augmented_type = Table
+
+    def process_value(self, table: Any) -> Any:
+        masked_header = ["Col" + str(ind + 1) for ind in range(len(table["header"]))]
+
+        return {"header": masked_header, "rows": table["rows"]}
+
+
+class ShuffleColumnsNames(TypeDependentAugmentor):
+    """Shuffle table columns names to be displayed in random order."""
+
+    augmented_type = Table
+
+    def process_value(self, table: Any) -> Any:
+        shuffled_header = table["header"]
+        random.shuffle(shuffled_header)
+
+        return {"header": shuffled_header, "rows": table["rows"]}

task.py

@@ -2,11 +2,11 @@ import warnings
 from functools import lru_cache
 from typing import Any, Dict, List, Optional, Union
 
-from .artifact import fetch_artifact
 from .deprecation_utils import deprecation
 from .error_utils import Documentation, UnitxtError, UnitxtWarning
 from .logging_utils import get_logger
 from .operator import InstanceOperator
+from .operators import ArtifactFetcherMixin
 from .settings_utils import get_constants
 from .type_utils import (
     Type,
@@ -35,7 +35,7 @@ def parse_string_types_instead_of_actual_objects(obj):
     return parse_type_string(obj)
 
 
-class Task(InstanceOperator):
+class Task(InstanceOperator, ArtifactFetcherMixin):
     """Task packs the different instance fields into dictionaries by their roles in the task.
 
     Attributes:
@@ -184,10 +184,10 @@ class Task(InstanceOperator):
                 data["prediction_type"] = to_type_string(data["prediction_type"])
         return data
 
-    @staticmethod
+    @classmethod
     @lru_cache(maxsize=None)
-    def get_metric_prediction_type(metric_id: str):
-        metric = fetch_artifact(metric_id)[0]
+    def get_metric_prediction_type(cls, metric_id: str):
+        metric = cls.get_artifact(metric_id)
         return metric.prediction_type
 
     def check_metrics_type(self) -> None:

templates.py

@@ -8,7 +8,7 @@ from .collections import DictCollection, ListCollection
 from .dataclass import NonPositionalField
 from .dict_utils import dict_set
 from .error_utils import Documentation, UnitxtError
-from .operator import InstanceOperator
+from .operator import InstanceOperator, Operator
 from .random_utils import new_random_generator
 from .serializers import (
     DialogSerializer,
@@ -18,9 +18,10 @@ from .serializers import (
     NumberQuantizingSerializer,
     Serializer,
     TableSerializer,
+    VideoSerializer,
 )
 from .settings_utils import get_constants
-from .type_utils import isoftype
+from .type_utils import isoftype, to_type_string
 
 constants = get_constants()
 
@@ -59,6 +60,7 @@ class Template(InstanceOperator):
         default_factory=lambda: MultiTypeSerializer(
             serializers=[
                 ImageSerializer(),
+                VideoSerializer(),
                 TableSerializer(),
                 DialogSerializer(),
                 ListSerializer(),
@@ -66,6 +68,12 @@ class Template(InstanceOperator):
         )
     )
 
+    def verify(self):
+        super().verify()
+        assert isoftype(
+            self.postprocessors, List[Union[Operator, str]]
+        ), f"The template post processors field '{self.postprocessors}' is not a list of processors. Instead it is of type '{to_type_string(type(self.postprocessors))}'."
+
     def input_fields_to_instruction_and_target_prefix(self, input_fields):
         instruction = self.apply_formatting(
             input_fields, "input field", self.instruction, "instruction"

text_utils.py

@@ -114,6 +114,58 @@ def construct_dict_str(d, indent=0, indent_delta=4, max_chars=None, keys=None):
     return res
 
 
+def construct_dict_as_yaml_lines(d, indent_delta=2) -> List[str]:
+    """Constructs the lines of a dictionary formatted as yaml.
+
+    Args:
+        d: The element to be formatted.
+        indent_delta (int, optional): The amount of spaces to add for each level of indentation. Defaults to 2.
+    """
+
+    def is_simple(val) -> bool:
+        # if can show in same line as dictionary's key
+        return not isinstance(val, (dict, list)) or (len(val) == 0)
+
+    indent_delta_str = " " * indent_delta
+    ticked_indent_delta_str = indent_delta_str[:-2] + "- "
+    assert (
+        indent_delta >= 2
+    ), f"Needs at least 2 position indentations, for the case of list elements, that are to be preceded each by ' -'. Got indent_delta={indent_delta}."
+    res = []  # conputed hereunder as a list of lines, that are indented only at the end
+
+    if isinstance(d, dict):
+        if len(d) == 0:
+            return ["{}"]
+        for key, val in d.items():
+            res.append(key + ": ")
+            yaml_for_val = construct_dict_as_yaml_lines(val, indent_delta=indent_delta)
+            assert len(yaml_for_val) > 0
+            if is_simple(val):
+                assert len(yaml_for_val) == 1
+                res[-1] += yaml_for_val[0]
+            else:
+                for line in yaml_for_val:
+                    res.append(indent_delta_str + line)
+        return res
+
+    if isinstance(d, list):
+        if len(d) == 0:
+            return ["[]"]
+        for val in d:
+            yaml_for_val = construct_dict_as_yaml_lines(val, indent_delta=indent_delta)
+            assert len(yaml_for_val) > 0
+            res.append(ticked_indent_delta_str + yaml_for_val[0])
+            for line in yaml_for_val[1:]:
+                res.append(indent_delta_str + line)
+        return res
+
+    # d1 = re.sub(r"(\n+)", r'"\1"', str(d))
+    d1 = str(d).replace("\n", "\\n").replace('"', '\\"')
+    if "\\n" in d1:
+        d1 = f'"{d1}"'
+    return [d1]
+
+
 def print_dict(
     d, indent=0, indent_delta=4, max_chars=None, keys_to_print=None, log_level="info"
 ):
@@ -122,6 +174,13 @@ def print_dict(
     getattr(logger, log_level)(dict_str)
 
 
+def print_dict_as_yaml(d: dict, indent_delta=2) -> str:
+    yaml_lines = construct_dict_as_yaml_lines(d)
+    # yaml_lines = [re.sub(r"(\n+)", r'"\1"', line) for line in yaml_lines]
+    # yaml_lines = [line.replace("\n", "\\n") for line in yaml_lines]
+    return "\n".join(yaml_lines)
+
+
 def nested_tuple_to_string(nested_tuple: tuple) -> str:
     """Converts a nested tuple to a string, with elements separated by underscores.
 

types.py

@@ -16,6 +16,10 @@ Dialog = NewType("Dialog", List[Turn])
 
 class Image(TypedDict):
     image: Any
+    format: str
+
+
+Video = NewType("Video", List[Image])
 
 
 class Audio(TypedDict):
@@ -34,3 +38,4 @@ register_type(Dialog)
 register_type(Table)
 register_type(Audio)
 register_type(Image)
+register_type(Video)

utils.py

@@ -3,6 +3,8 @@ import importlib.util
 import json
 import os
 import re
+import threading
+from collections import OrderedDict
 from functools import lru_cache
 from typing import Any, Dict
 
@@ -18,6 +20,93 @@ class Singleton(type):
         return cls._instances[cls]
 
 
+class LRUCache:
+    """An LRU (Least Recently Used) cache that stores a limited number of items.
+
+    This cache automatically removes the least recently used item when it
+    exceeds its max size. It behaves similarly to a dictionary, allowing
+    items to be added and accessed using `[]` syntax.
+
+    This implementation is thread-safe, using a lock to ensure that only one
+    thread can modify or access the cache at any time.
+
+    Attributes:
+        max_size (int): The maximum number of items to store in the cache.
+            Items exceeding this limit are automatically removed based on least
+            recent usage.
+    """
+
+    def __init__(self, max_size=10):
+        self._max_size = max_size
+        self._cache = OrderedDict()
+        self._lock = threading.Lock()  # Lock to ensure thread safety
+
+    @property
+    def max_size(self):
+        with self._lock:
+            return self._max_size
+
+    @max_size.setter
+    def max_size(self, size):
+        with self._lock:
+            self._max_size = size
+            # Adjust the cache if the new size is smaller than the current number of items
+            while len(self._cache) > self._max_size:
+                self._cache.popitem(last=False)
+
+    def __setitem__(self, key, value):
+        with self._lock:
+            # If the key already exists, remove it first to refresh its order
+            if key in self._cache:
+                self._cache.pop(key)
+
+            # Add the new item to the cache (most recently used)
+            self._cache[key] = value
+
+            # If the cache exceeds the specified size, remove the least recently used item
+            while len(self._cache) > self._max_size:
+                self._cache.popitem(last=False)
+
+    def __getitem__(self, key):
+        with self._lock:
+            if key in self._cache:
+                # Move the accessed item to the end (mark as most recently used)
+                value = self._cache.pop(key)
+                self._cache[key] = value
+                return value
+            raise KeyError(f"{key} not found in cache")
+
+    def set(self, key, value):
+        """Sets a key-value pair in the cache."""
+        with self._lock:
+            if key in self._cache:
+                self._cache.pop(key)
+            self._cache[key] = value
+            while len(self._cache) > self._max_size:
+                self._cache.popitem(last=False)
+
+    def get(self, key, default=None):
+        """Gets a value from the cache by key, returning `default` if the key is not found."""
+        with self._lock:
+            if key in self._cache:
+                value = self._cache.pop(key)
+                self._cache[key] = value  # Move item to end to mark as recently used
+                return value
+            return default
+
+    def __contains__(self, key):
+        with self._lock:
+            return key in self._cache
+
+    def __len__(self):
+        with self._lock:
+            return len(self._cache)
+
+    def __repr__(self):
+        with self._lock:
+            return f"LRUCache(max_size={self._max_size}, items={list(self._cache.items())})"
+
+
 def flatten_dict(
     d: Dict[str, Any], parent_key: str = "", sep: str = "_"
 ) -> Dict[str, Any]:
@@ -233,3 +322,15 @@ def recursive_shallow_copy(obj):
         A recursively shallow-copied version of the original object.
     """
     return recursive_copy(obj, shallow_copy)
+
+
+class LongString(str):
+    def __new__(cls, value, *, repr_str=None):
+        obj = super().__new__(cls, value)
+        obj._repr_str = repr_str
+        return obj
+
+    def __repr__(self):
+        if self._repr_str is not None:
+            return self._repr_str
+        return super().__repr__()

version.py

@@ -1 +1 @@
-version = "1.14.1"
+version = "1.15.0"