Upload folder using huggingface_hub

api.py

@@ -6,8 +6,9 @@ from datasets import DatasetDict
 from .artifact import fetch_artifact
 from .dataset_utils import get_dataset_artifact
 from .logging_utils import get_logger
-from .metric_utils import _compute, _post_process
+from .metric_utils import _compute, _inference_post_process
 from .operator import SourceOperator
+from .schema import UNITXT_DATASET_SCHEMA
 from .standard import StandardRecipe
 
 logger = get_logger()
@@ -22,21 +23,60 @@ def load(source: Union[SourceOperator, str]) -> DatasetDict:
     return source().to_dataset()
 
 
-def _load_dataset_from_query(dataset_query: str) -> DatasetDict:
+def _get_recipe_from_query(dataset_query: str) -> StandardRecipe:
     dataset_query = dataset_query.replace("sys_prompt", "instruction")
-    dataset_stream = get_dataset_artifact(dataset_query)
-    return dataset_stream().to_dataset()
+    try:
+        dataset_stream, _ = fetch_artifact(dataset_query)
+    except:
+        dataset_stream = get_dataset_artifact(dataset_query)
+    return dataset_stream
 
 
-def _load_dataset_from_dict(dataset_params: Dict[str, Any]) -> DatasetDict:
+def _get_recipe_from_dict(dataset_params: Dict[str, Any]) -> StandardRecipe:
     recipe_attributes = list(StandardRecipe.__dict__["__fields__"].keys())
     for param in dataset_params.keys():
         assert param in recipe_attributes, (
             f"The parameter '{param}' is not an attribute of the 'StandardRecipe' class. "
             f"Please check if the name is correct. The available attributes are: '{recipe_attributes}'."
         )
-    recipe = StandardRecipe(**dataset_params)
-    return recipe().to_dataset()
+    return StandardRecipe(**dataset_params)
+
+
+def _verify_dataset_args(dataset_query: Optional[str] = None, dataset_args=None):
+    if dataset_query and dataset_args:
+        raise ValueError(
+            "Cannot provide 'dataset_query' and key-worded arguments at the same time. "
+            "If you want to load dataset from a card in local catalog, use query only. "
+            "Otherwise, use key-worded arguments only to specify properties of dataset."
+        )
+
+    if dataset_query:
+        if not isinstance(dataset_query, str):
+            raise ValueError(
+                f"If specified, 'dataset_query' must be a string, however, "
+                f"'{dataset_query}' was provided instead, which is of type "
+                f"'{type(dataset_query)}'."
+            )
+
+    if not dataset_query and not dataset_args:
+        raise ValueError(
+            "Either 'dataset_query' or key-worded arguments must be provided."
+        )
+
+
+def load_recipe(dataset_query: Optional[str] = None, **kwargs) -> StandardRecipe:
+    if isinstance(dataset_query, StandardRecipe):
+        return dataset_query
+
+    _verify_dataset_args(dataset_query, kwargs)
+
+    if dataset_query:
+        recipe = _get_recipe_from_query(dataset_query)
+
+    if kwargs:
+        recipe = _get_recipe_from_dict(kwargs)
+
+    return recipe
 
 
 def load_dataset(dataset_query: Optional[str] = None, **kwargs) -> DatasetDict:
@@ -47,7 +87,7 @@ def load_dataset(dataset_query: Optional[str] = None, **kwargs) -> DatasetDict:
     Alternatively, dataset is loaded from a provided card based on explicitly given parameters.
 
     Args:
-        dataset_query (str, optional): A string query which specifies dataset to load from local catalog.
+        dataset_query (str, optional): A string query which specifies a dataset to load from local catalog or name of specific recipe or benchmark in the catalog.
             For example:
             "card=cards.wnli,template=templates.classification.multi_class.relation.default".
         **kwargs: Arguments used to load dataset from provided card, which is not present in local catalog.
@@ -65,26 +105,9 @@ def load_dataset(dataset_query: Optional[str] = None, **kwargs) -> DatasetDict:
         loader_limit = 10
         dataset = load_dataset(card=card, template=template, loader_limit=loader_limit)
     """
-    if dataset_query and kwargs:
-        raise ValueError(
-            "Cannot provide 'dataset_query' and key-worded arguments at the same time. "
-            "If you want to load dataset from a card in local catalog, use query only. "
-            "Otherwise, use key-worded arguments only to specify properties of dataset."
-        )
-
-    if dataset_query:
-        if not isinstance(dataset_query, str):
-            raise ValueError(
-                f"If specified, 'dataset_query' must be a string, however, "
-                f"'{dataset_query}' was provided instead, which is of type "
-                f"'{type(dataset_query)}'."
-            )
-        return _load_dataset_from_query(dataset_query)
-
-    if kwargs:
-        return _load_dataset_from_dict(kwargs)
+    recipe = load_recipe(dataset_query, **kwargs)
 
-    raise ValueError("Either 'dataset_query' or key-worded arguments must be provided.")
+    return recipe().to_dataset(features=UNITXT_DATASET_SCHEMA)
 
 
 def evaluate(predictions, data) -> List[Dict[str, Any]]:
@@ -92,26 +115,40 @@ def evaluate(predictions, data) -> List[Dict[str, Any]]:
 
 
 def post_process(predictions, data) -> List[Dict[str, Any]]:
-    return _post_process(predictions=predictions, references=data)
+    return _inference_post_process(predictions=predictions, references=data)
 
 
 @lru_cache
-def _get_produce_with_cache(recipe_query):
-    return get_dataset_artifact(recipe_query).produce
+def _get_produce_with_cache(dataset_query: Optional[str] = None, **kwargs):
+    return load_recipe(dataset_query, **kwargs).produce
 
 
-def produce(instance_or_instances, recipe_query):
+def produce(instance_or_instances, dataset_query: Optional[str] = None, **kwargs):
     is_list = isinstance(instance_or_instances, list)
     if not is_list:
         instance_or_instances = [instance_or_instances]
-    result = _get_produce_with_cache(recipe_query)(instance_or_instances)
+    result = _get_produce_with_cache(dataset_query, **kwargs)(instance_or_instances)
     if not is_list:
         result = result[0]
     return result
 
 
-def infer(instance_or_instances, recipe, engine):
-    dataset = produce(instance_or_instances, recipe)
+def infer(
+    instance_or_instances,
+    engine,
+    dataset_query: Optional[str] = None,
+    return_data=False,
+    **kwargs,
+):
+    dataset = produce(instance_or_instances, dataset_query, **kwargs)
     engine, _ = fetch_artifact(engine)
-    predictions = engine.infer(dataset)
-    return post_process(predictions, dataset)
+    raw_predictions = engine.infer(dataset)
+    predictions = post_process(raw_predictions, dataset)
+    if return_data:
+        for prediction, raw_prediction, instance in zip(
+            predictions, raw_predictions, dataset
+        ):
+            instance["prediction"] = prediction
+            instance["raw_prediction"] = raw_prediction
+        return dataset
+    return predictions

artifact.py

@@ -439,10 +439,10 @@ def fetch_artifact(artifact_rep) -> Tuple[Artifact, Union[Artifactory, None]]:
     """Loads an artifict from one of possible representations.
 
     (1) If artifact representation is already an Artifact object, return it.
-    (2) If artifact representation is a string location of a local file, load the Artifact from local file.
-    (3) If artifact representation is a string name iin the catalog, load the Artifact from the catalog.
-    (4) If artifact representation is a json string, create dictionary representation from the string and build an Artifact object from it.
-    (5) Otherwise, check the artifact representation is a dictionary and build an Artifact object from it.
+    (2) If artifact representation is a string location of a local file, load the Artifact from the local file.
+    (3) If artifact representation is a string name in the catalog, load the Artifact from the catalog.
+    (4) If artifact representation is a json string, create a dictionary representation from the string and build an Artifact object from it.
+    (5) Otherwise, check that the artifact representation is a dictionary and build an Artifact object from it.
     """
     if isinstance(artifact_rep, Artifact):
         return artifact_rep, None

benchmark.py

@@ -0,0 +1,58 @@
+from typing import Dict, Union
+
+from .dataclass import NonPositionalField
+from .formats import Format
+from .fusion import FixedFusion, WeightedFusion
+from .operator import SourceOperator
+from .standard import StandardRecipe
+from .stream import MultiStream
+from .system_prompts import SystemPrompt
+
+
+class BaseBenchmark(SourceOperator):
+    format: Format = NonPositionalField(default=None)
+    num_demos: int = NonPositionalField(default=None)
+    system_prompt: SystemPrompt = NonPositionalField(default=None)
+    loader_limit: int = NonPositionalField(default=None)
+
+
+class Benchmark(BaseBenchmark):
+    subsets: Dict[str, Union[StandardRecipe, BaseBenchmark]]
+
+    max_total_samples: int = None
+    max_samples_per_subset: int = None
+
+    def verify(self):
+        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:
+            for subset in self.subsets.values():
+                if self.num_demos is not None:
+                    subset.num_demos = self.num_demos
+                if self.format is not None:
+                    subset.format = self.format
+                if self.system_prompt is not None:
+                    subset.system_prompt = self.system_prompt
+                if self.loader_limit is not None:
+                    subset.loader_limit = self.loader_limit
+                subset.prepare()
+
+    def process(
+        self,
+    ) -> MultiStream:
+        if self.max_total_samples is None:
+            operator = FixedFusion(
+                subsets=self.subsets,
+                max_instances_per_subset=self.max_samples_per_subset,
+            )
+        else:
+            operator = WeightedFusion(
+                subsets=self.subsets, max_total_samples=self.max_total_samples
+            )
+
+        return operator()

blocks.py

@@ -13,7 +13,7 @@ from .operators import (
     Copy,
     DivideAllFieldsBy,
     MapInstanceValues,
-    RenameFields,
+    Rename,
     Set,
 )
 from .processors import ToString, ToStringStripped
@@ -21,6 +21,7 @@ from .recipe import SequentialRecipe
 from .splitters import RandomSampler, Sample, SliceSplit, SplitRandomMix
 from .stream import MultiStream
 from .struct_data_operators import (
+    ConstructTableFromRowsCols,
     ListToKeyValPairs,
     MapHTMLTableToJSON,
     SerializeKeyValPairs,

card.py

@@ -10,12 +10,12 @@ from .task import Task
 
 
 class TaskCard(Artifact):
-    """TaskCard delineates the phases in transforming the source dataset into a model-input, and specifies the metrics for evaluation of model-output.
+    """TaskCard delineates the phases in transforming the source dataset into model input, and specifies the metrics for evaluation of model output.
 
     Attributes:
         loader: specifies the source address and the loading operator that can access that source and transform it into a unitxt multistream.
 
-        preprocess_steps: list of unitxt operators to process the data source into a model-input.
+        preprocess_steps: list of unitxt operators to process the data source into model input.
 
         task: specifies the fields (of the already (pre)processed instance) making the inputs, the fields making the outputs, and the metrics to be used for evaluating the model output.
 

catalog.py

@@ -1,3 +1,4 @@
+import json
 import os
 from collections import Counter
 from functools import lru_cache
@@ -195,6 +196,46 @@ def summary():
     return result
 
 
+def _get_tags_from_file(file_path):
+    result = Counter()
+
+    with open(file_path) as f:
+        data = json.load(f)
+        if "__tags__" in data and isinstance(data["__tags__"], dict):
+            tags = data["__tags__"]
+            for key, value in tags.items():
+                if isinstance(value, list):
+                    for item in value:
+                        result[f"{key}:{item}"] += 1
+                else:
+                    result[f"{key}:{value}"] += 1
+
+    return result
+
+
+def count_tags():
+    result = Counter()
+    done = set()
+
+    for local_catalog_path in get_local_catalogs_paths():
+        if local_catalog_path not in done:
+            for root, _, files in os.walk(local_catalog_path):
+                for file in files:
+                    if file.endswith(".json"):
+                        file_path = os.path.join(root, file)
+                        try:
+                            result += _get_tags_from_file(file_path)
+                        except json.JSONDecodeError:
+                            logger.info(f"Error decoding JSON in file: {file_path}")
+                        except OSError:
+                            logger.info(f"Error reading file: {file_path}")
+
+            done.add(local_catalog_path)
+
+    print_dict(result)
+    return result
+
+
 def ls(to_file=None):
     done = set()
     result = []

collections_operators.py

@@ -1,5 +1,6 @@
 from typing import Any, Generator, List, Optional
 
+from .dict_utils import dict_get, dict_set
 from .operators import FieldOperator, StreamOperator
 from .stream import Stream
 from .utils import deepcopy
@@ -66,20 +67,21 @@ class DuplicateByList(StreamOperator):
     def process(self, stream: Stream, stream_name: Optional[str] = None) -> Generator:
         to_field = self.field if self.to_field is None else self.to_field
         for instance in stream:
-            elements = instance[self.field]
+            elements = dict_get(instance, self.field)
             for element in elements:
                 if self.use_deep_copy:
                     instance_copy = deepcopy(instance)
-                    instance_copy[to_field] = element
+
                 else:
-                    instance_copy = {
-                        **instance,
-                        self.field: elements,
-                        to_field: element,
-                    }
+                    instance_copy = {**instance}
+                dict_set(instance_copy, to_field, element)
                 yield instance_copy
 
 
+class Explode(DuplicateByList):
+    pass
+
+
 class DuplicateBySubLists(StreamOperator):
     field: str
     to_field: Optional[str] = None

data.py

@@ -4,6 +4,7 @@ import datasets
 
 from .api import __file__ as _
 from .artifact import __file__ as _
+from .benchmark import __file__ as _
 from .blocks import __file__ as _
 from .card import __file__ as _
 from .catalog import __file__ as _
@@ -23,6 +24,7 @@ from .fusion import __file__ as _
 from .generator_utils import __file__ as _
 from .hf_utils import __file__ as _
 from .hf_utils import verify_versions_compatibility
+from .image_operators import __file__ as _
 from .inference import __file__ as _
 from .instructions import __file__ as _
 from .llm_as_judge import __file__ as _

dataclass.py

@@ -2,7 +2,6 @@ import copy
 import dataclasses
 import functools
 import inspect
-import warnings
 from abc import ABCMeta
 from inspect import Parameter, Signature
 from typing import Any, Dict, List, Optional, final
@@ -38,7 +37,6 @@ class Field:
     final: bool = False
     abstract: bool = False
     required: bool = False
-    deprecated: bool = False
     internal: bool = False
     origin_cls: type = None
     metadata: Dict[str, str] = dataclasses.field(default_factory=dict)
@@ -55,12 +53,6 @@ class FinalField(Field):
         self.final = True
 
 
-@dataclasses.dataclass
-class DeprecatedField(Field):
-    def __post_init__(self):
-        self.deprecated = True
-
-
 @dataclasses.dataclass
 class RequiredField(Field):
     def __post_init__(self):
@@ -251,10 +243,6 @@ def required_fields(cls):
     return [field for field in fields(cls) if field.required]
 
 
-def deprecated_fields(cls):
-    return [field for field in fields(cls) if field.deprecated]
-
-
 def abstract_fields(cls):
     return [field for field in fields(cls) if field.abstract]
 
@@ -267,10 +255,6 @@ def is_final_field(field):
     return field.final
 
 
-def is_deprecated_field(field):
-    return field.deprecated
-
-
 def get_field_default(field):
     if field.default_factory is not None:
         return field.default_factory()
@@ -424,7 +408,6 @@ class Dataclass(metaclass=DataclassMeta):
         """Initialize fields based on kwargs.
 
         Checks for abstract fields when an instance is created.
-        Warn when a deprecated is used
         """
         super().__init__()
         _init_fields = [field for field in fields(self) if field.init]
@@ -433,12 +416,6 @@ class Dataclass(metaclass=DataclassMeta):
             field.name for field in _init_fields if field.also_positional
         ]
 
-        _init_deprecated_fields = [field for field in _init_fields if field.deprecated]
-        for dep_field in _init_deprecated_fields:
-            warnings.warn(
-                dep_field.metadata["deprecation_msg"], DeprecationWarning, stacklevel=2
-            )
-
         for name in _init_positional_fields_names[: len(argv)]:
             if name in kwargs:
                 raise TypeError(

dict_utils.py

@@ -4,8 +4,23 @@ from typing import Any, List, Tuple
 from .text_utils import construct_dict_str
 
 indx = re.compile(r"^(\d+)$")
+
+
+def is_index(string):
+    return bool(indx.match(string))
+
+
 name = re.compile(r"^[\w. -]+$")
 
+
+def is_name(string):
+    return bool(name.match(string))
+
+
+def is_wildcard(string):
+    return string == "*"
+
+
 # formal definition of qpath syntax by which a query is specified:
 # qpath -> A (/A)*
 # A -> name | * | non-neg-int
@@ -51,7 +66,9 @@ name = re.compile(r"^[\w. -]+$")
 
 
 # validate and normalizes into components
-def validate_query_and_break_to_components(query: str) -> List[str]:
+def validate_query_and_break_to_components(
+    query: str, allow_int_index=True
+) -> List[str]:
     if not isinstance(query, str) or len(query) == 0:
         raise ValueError(
             f"invalid query: either not a string or an empty string: {query}"
@@ -69,9 +86,9 @@ def validate_query_and_break_to_components(query: str) -> List[str]:
     components = [component.strip() for component in components]
     for component in components:
         if not (
-            bool(name.match(component))
-            or component == "*"
-            or bool(indx.match(component))
+            is_name(component)
+            or is_wildcard(component)
+            or (is_index(component) and allow_int_index)
         ):
             raise ValueError(
                 f"Component {component} in input query is none of: valid field-name, non-neg-int, or '*'"
@@ -79,10 +96,14 @@ def validate_query_and_break_to_components(query: str) -> List[str]:
     return components
 
 
-def is_subpath(subpath, fullpath):
+def is_subpath(subpath, fullpath, allow_int_index=True):
     # Split the paths into individual components
-    subpath_components = validate_query_and_break_to_components(subpath)
-    fullpath_components = validate_query_and_break_to_components(fullpath)
+    subpath_components = validate_query_and_break_to_components(
+        subpath, allow_int_index=allow_int_index
+    )
+    fullpath_components = validate_query_and_break_to_components(
+        fullpath, allow_int_index=allow_int_index
+    )
 
     # Check if the full path starts with the subpath
     return fullpath_components[: len(subpath_components)] == subpath_components
@@ -100,16 +121,17 @@ def delete_values(
     query: List[str],
     index_into_query: int,
     remove_empty_ancestors=False,
+    allow_int_index=True,
 ) -> Tuple[bool, Any]:
     component = query[index_into_query]
     if index_into_query == -1:
-        if component == "*":
+        if is_wildcard(component):
             # delete all members of the list or dict
             current_element = [] if isinstance(current_element, list) else {}
             return (True, current_element)
         # component is a either a dictionary key or an index into a list,
         # pop the respective element from current_element
-        if indx.match(component):
+        if is_index(component) and allow_int_index:
             component = int(component)
         try:
             current_element.pop(component)
@@ -141,6 +163,7 @@ def delete_values(
                     query=query,
                     index_into_query=index_into_query + 1,
                     remove_empty_ancestors=remove_empty_ancestors,
+                    allow_int_index=allow_int_index,
                 )
                 if not success:
                     continue
@@ -155,7 +178,7 @@ def delete_values(
         return (any_success, current_element)
 
     # current component is index into a list or a key into a dictionary
-    if indx.match(component):
+    if is_index(component) and allow_int_index:
         component = int(component)
     try:
         success, new_val = delete_values(
@@ -163,6 +186,7 @@ def delete_values(
             query=query,
             index_into_query=index_into_query + 1,
             remove_empty_ancestors=remove_empty_ancestors,
+            allow_int_index=allow_int_index,
         )
         if not success:
             return (False, None)
@@ -176,7 +200,11 @@ def delete_values(
 
 
 def dict_delete(
-    dic: dict, query: str, not_exist_ok: bool = False, remove_empty_ancestors=False
+    dic: dict,
+    query: str,
+    not_exist_ok: bool = False,
+    remove_empty_ancestors=False,
+    allow_int_index=True,
 ):
     # We remove from dic the value from each and every element lead to by a path matching the query.
     # If remove_empty_ancestors=True, and the removal of any such value leaves its containing element (list or dict)
@@ -197,7 +225,9 @@ def dict_delete(
         dic.pop(query.strip())
         return
 
-    qpath = validate_query_and_break_to_components(query)
+    qpath = validate_query_and_break_to_components(
+        query, allow_int_index=allow_int_index
+    )
 
     try:
         success, new_val = delete_values(
@@ -205,6 +235,7 @@ def dict_delete(
             query=qpath,
             index_into_query=(-1) * len(qpath),
             remove_empty_ancestors=remove_empty_ancestors,
+            allow_int_index=allow_int_index,
         )
 
         if success:
@@ -225,7 +256,10 @@ def dict_delete(
 # if query includes * then return a list of values reached by all paths that match the query
 # flake8: noqa: C901
 def get_values(
-    current_element: Any, query: List[str], index_into_query: int
+    current_element: Any,
+    query: List[str],
+    index_into_query: int,
+    allow_int_index=True,
 ) -> Tuple[bool, Any]:
     # going down from current_element through query[index_into_query].
     if index_into_query == 0:
@@ -244,7 +278,12 @@ def get_values(
             sub_elements = current_element
         for sub_element in sub_elements:
             try:
-                success, val = get_values(sub_element, query, index_into_query + 1)
+                success, val = get_values(
+                    sub_element,
+                    query,
+                    index_into_query + 1,
+                    allow_int_index=allow_int_index,
+                )
                 if success:
                     to_ret.append(val)
             except:
@@ -253,11 +292,14 @@ def get_values(
         return (len(to_ret) > 0 or index_into_query == -1, to_ret)
         # when * is the last component, it refers to 'all the contents' of an empty list being current_element.
     # next_component is indx or name, current_element must be a list or a dict
-    if indx.match(component):
+    if is_index(component) and allow_int_index:
         component = int(component)
     try:
         success, new_val = get_values(
-            current_element[component], query, index_into_query + 1
+            current_element[component],
+            query,
+            index_into_query + 1,
+            allow_int_index=allow_int_index,
         )
         if success:
             return (True, new_val)
@@ -274,6 +316,7 @@ def set_values(
     index_into_query: int,
     fixed_parameters: dict,
     set_multiple: bool = False,
+    allow_int_index=True,
 ) -> Tuple[bool, Any]:
     if index_into_query == 0:
         return (True, value)  # matched query all along!
@@ -321,6 +364,7 @@ def set_values(
                     index_into_query=index_into_query + 1,
                     set_multiple=False,  # now used, not allowed again,
                     fixed_parameters=fixed_parameters,
+                    allow_int_index=allow_int_index,
                 )
                 if not success:
                     continue
@@ -335,7 +379,7 @@ def set_values(
         )
 
     # component is an index into a list or a key into a dictionary
-    if indx.match(component):
+    if is_index(component) and allow_int_index:
         if current_element is None or not isinstance(current_element, list):
             if not fixed_parameters["generate_if_not_exists"]:
                 return (False, None)
@@ -368,6 +412,7 @@ def set_values(
             index_into_query=index_into_query + 1,
             fixed_parameters=fixed_parameters,
             set_multiple=set_multiple,
+            allow_int_index=allow_int_index,
         )
         if success:
             current_element[component] = new_val
@@ -383,6 +428,7 @@ def dict_get(
     query: str,
     not_exist_ok: bool = False,
     default: Any = None,
+    allow_int_index=True,
 ):
     if len(query.strip()) == 0:
         return dic
@@ -393,7 +439,9 @@ def dict_get(
     if isinstance(dic, dict) and query.strip() in dic:
         return dic[query.strip()]
 
-    components = validate_query_and_break_to_components(query)
+    components = validate_query_and_break_to_components(
+        query, allow_int_index=allow_int_index
+    )
     if len(components) > 1:
         try:
             success, values = get_values(dic, components, -1 * len(components))
@@ -474,6 +522,7 @@ def dict_set(
     value: Any,
     not_exist_ok=True,
     set_multiple=False,
+    allow_int_index=True,
 ):  # sets dic to its new value
     if dic is None or not isinstance(dic, (list, dict)):
         raise ValueError(
@@ -510,7 +559,9 @@ def dict_set(
                 f"set_multiple=True, but value, {value}, can not be broken up, as either it is not a list or it is an empty list"
             )
 
-    components = validate_query_and_break_to_components(query)
+    components = validate_query_and_break_to_components(
+        query, allow_int_index=allow_int_index
+    )
     fixed_parameters = {
         "query": components,
         "generate_if_not_exists": not_exist_ok,
@@ -522,6 +573,7 @@ def dict_set(
             index_into_query=(-1) * len(components),
             fixed_parameters=fixed_parameters,
             set_multiple=set_multiple,
+            allow_int_index=allow_int_index,
         )
         if not success and not not_exist_ok:
             raise ValueError(f"No path in dic {dic} matches query {query}.")

formats.py

@@ -79,13 +79,13 @@ class SystemFormat(BaseFormat):
     Important: formats can use '\N' notations that means new-line if no new-line before and no empty string before.
 
     SystemFormat expects the input instance to contain:
-    1. A field named "system_prompt" whose value is a string (potentially empty) that delivers a task independent opening text.
+    1. A field named "system_prompt" whose value is a string (potentially empty) that delivers a task-independent opening text.
     2. A field named "source" whose value is a string verbalizing the original values in the instance (as read
     from the source dataset), in the context of the underlying task.
     3. A field named "instruction" that contains a (non-None) string.
     4. A field named with the value in arg 'demos_field', containing a list of dicts, each dict with fields "source"
     and "target", representing a single demo.
-    5. A field named "target_prefx" that contains a string to prefix the target in both each demo, and to end the whole generated prompt
+    5. A field named "target_prefix" that contains a string to prefix the target in each demo, and to end the whole generated prompt
 
     SystemFormat formats the above fields into a single string to be inputted to the model. This string overwrites
     field "source" of the instance. Formatting is driven by two args: 'demo_format' and 'model_input_format'.
@@ -200,16 +200,16 @@ class SystemFormat(BaseFormat):
 
 
 class HFSystemFormat(BaseFormat):
-    r"""Formats the complete input for the model using the Hugginface chat template of a given model.
+    r"""Formats the complete input for the model using the HuggingFace chat template of a given model.
 
     HFSystemFormat expects the input instance to contain:
-    1. A field named "system_prompt" whose value is a string (potentially empty) that delivers a task independent opening text.
+    1. A field named "system_prompt" whose value is a string (potentially empty) that delivers a task-independent opening text.
     2. A field named "source" whose value is a string verbalizing the original values in the instance (as read
     from the source dataset), in the context of the underlying task.
     3. A field named "instruction" that contains a (non-None) string.
     4. A field named with the value in arg 'demos_field', containing a list of dicts, each dict with fields "source"
     and "target", representing a single demo.
-    5. A field named "target_prefx" that contains a string to prefix the target in both each demo, and to end the whole generated prompt
+    5. A field named "target_prefix" that contains a string to prefix the target in each demo, and to end the whole generated prompt.
 
     SystemFormat formats the above fields into a single string to be inputted to the model. This string overwrites
     field "source" of the instance.

fusion.py

@@ -12,13 +12,13 @@ class BaseFusion(SourceOperator):
     """BaseFusion operator that combines multiple multistreams into one.
 
     Args:
-        origins: a dict of named SourceOperator objects (each to yield a MultiStream) or a list thereof,
+        subsets: a dict of named SourceOperator objects (each to yield a MultiStream) or a list thereof,
           each is specified along with its input, so can generate a MultiStream
         include_splits: List of splits to include from each input MultiStream.
                 If None, all splits are included.
     """
 
-    origins: Union[List[SourceOperator], Dict[str, SourceOperator]]
+    subsets: Union[List[SourceOperator], Dict[str, SourceOperator]]
     include_splits: Optional[List[str]] = NonPositionalField(default=None)
 
     @abstractmethod
@@ -26,18 +26,18 @@ class BaseFusion(SourceOperator):
         pass
 
     def prepare(self):
-        assert isoftype(self.origins, Dict[str, SourceOperator]) or isoftype(
-            self.origins, List[SourceOperator]
+        assert isoftype(self.subsets, Dict[str, SourceOperator]) or isoftype(
+            self.subsets, List[SourceOperator]
         )
-        self.named_origins = (
-            {i: self.origins[i]() for i in range(len(self.origins))}
-            if isinstance(self.origins, list)
-            else {name: origin() for name, origin in self.origins.items()}
+        self.named_subsets = (
+            {i: self.subsets[i]() for i in range(len(self.subsets))}
+            if isinstance(self.subsets, list)
+            else {name: origin() for name, origin in self.subsets.items()}
         )
 
     def splits(self) -> List[str]:
         splits = []
-        for _, origin in self.named_origins.items():
+        for _, origin in self.named_subsets.items():
             for s in origin.keys():
                 if s not in splits:
                     if self.include_splits is None or s in self.include_splits:
@@ -59,69 +59,69 @@ class FixedFusion(BaseFusion):
     """FixedFusion operator that combines multiple multistreams into one, limiting the number of instances taken from each split of each input multistream.
 
     Args:
-        origins: Dict of named SourceOperator objects (each to yield a MultiStream), or a list thereof
+        subsets: Dict of named SourceOperator objects (each to yield a MultiStream), or a list thereof
         splits: List of splits (stream_names) to include, over all input multistreams. If None, all splits are included.
-        max_instances_per_origin_split: Number of instances to take from each input split of each input multistream.
+        max_instances_per_subset: Number of instances to take from each input split of each input multistream.
             If None, all instances of each split (that is specified in include_splits) are included in the result.
 
     """
 
-    max_instances_per_origin_split: Optional[int] = None
+    max_instances_per_subset: Optional[int] = None
 
     def prepare(self):
         super().prepare()
 
     # flake8: noqa: C901
     def fusion_generator(self, split) -> Generator:
-        for origin_name, origin in self.named_origins.items():
+        for origin_name, origin in self.named_subsets.items():
             if split not in origin:
                 continue
             emitted_from_this_split = 0
-            for instance in origin[split]:
-                if (
-                    self.max_instances_per_origin_split is not None
-                    and emitted_from_this_split >= self.max_instances_per_origin_split
-                ):
-                    break
-                if isinstance(origin_name, str):
-                    # named origins, not anonymous, record in instance
-                    if "group" in instance:
-                        instance["group"] = origin_name + "/" + instance["group"]
-                    else:
-                        instance["group"] = origin_name
-                emitted_from_this_split += 1
-                yield instance
+            try:
+                for instance in origin[split]:
+                    if (
+                        self.max_instances_per_subset is not None
+                        and emitted_from_this_split >= self.max_instances_per_subset
+                    ):
+                        break
+                    if isinstance(origin_name, str):
+                        if "subset" not in instance:
+                            instance["subset"] = []
+                        instance["subset"].insert(0, origin_name)
+                    emitted_from_this_split += 1
+                    yield instance
+            except Exception as e:
+                raise RuntimeError(f"Exception in subset: {origin_name}") from e
 
 
 class WeightedFusion(BaseFusion):
     """Fusion operator that combines multiple MultiStream-s.
 
     Args:
-        origins: Dict of named MultiStream objects, or a list thereof
+        subsets: Dict of named MultiStream objects, or a list thereof
         weights: Dict of named weights for each origin, or a list thereof
         max_total_examples: Total number of instances to return per returned split.
             If None, all instances are returned
     """
 
-    origins: Union[Dict[str, SourceOperator], List[SourceOperator]] = None
+    subsets: Union[Dict[str, SourceOperator], List[SourceOperator]] = None
     weights: Union[Dict[str, Union[float, int]], List[Union[int, float]]] = None
-    max_total_examples: int = None
-    ignore_origin_groups: List[str] = ["unitxt"]
+    max_total_samples: int = None
 
     def verify(self):
         super().verify()
-        assert self.origins is not None, "origins must be specified"
+        assert self.subsets is not None, "subsets must be specified"
         assert self.weights is not None, "weights must be specified"
-        assert len(self.origins) == len(
+        assert len(self.subsets) == len(
             self.weights
-        ), "origins and weights must have the same length"
-        assert isoftype(self.origins, Dict[str, SourceOperator]) or isoftype(
-            self.origins, List[SourceOperator]
+        ), "subsets and weights must have the same length"
+        assert isoftype(self.subsets, Dict[str, SourceOperator]) or isoftype(
+            self.subsets, List[SourceOperator]
         )
         assert isoftype(self.weights, Dict[str, Union[int, float]]) or isoftype(
             self.weights, List[Union[int, float]]
         )
-        assert isinstance(self.origins, dict) == isinstance(self.weights, dict)
+        assert isinstance(self.subsets, dict) == isinstance(self.weights, dict)
 
     def prepare(self):
         super().prepare()
@@ -134,12 +134,12 @@ class WeightedFusion(BaseFusion):
     def fusion_generator(self, split) -> Generator:
         iterators = {
             named_origin: iter(origin[split])
-            for named_origin, origin in self.named_origins.items()
+            for named_origin, origin in self.named_subsets.items()
         }
         total_examples = 0
         random_generator = new_random_generator(sub_seed="weighted_fusion_" + split)
         while (
-            self.max_total_examples is None or total_examples < self.max_total_examples
+            self.max_total_samples is None or total_examples < self.max_total_samples
         ) and len(iterators) > 0:
             population = list(iterators.keys())
             origin_name = random_generator.choices(
@@ -150,13 +150,9 @@ class WeightedFusion(BaseFusion):
             try:
                 instance = next(iterator)
                 if isinstance(origin_name, str):
-                    if (
-                        "group" in instance
-                        and instance["group"] not in self.ignore_origin_groups
-                    ):
-                        instance["group"] = origin_name + "/" + instance["group"]
-                    else:
-                        instance["group"] = origin_name
+                    if "subset" not in instance:
+                        instance["subset"] = []
+                    instance["subset"].insert(0, origin_name)
                 total_examples += 1
                 yield instance
 

image_operators.py

@@ -0,0 +1,26 @@
+import re
+from typing import Any, Dict
+
+from .dict_utils import dict_get
+from .operators import InstanceFieldOperator
+
+
+def extract_images(text, instance):
+    regex = r'<img\s+src=["\'](.*?)["\']'
+    image_sources = re.findall(regex, text)
+    images = []
+    for image_source in image_sources:
+        image = dict_get(instance, image_source)
+        images.append(image)
+    return images
+
+
+class ImageToText(InstanceFieldOperator):
+    def process_instance_value(self, value: Any, instance: Dict[str, Any]):
+        if "media" not in instance:
+            instance["media"] = {}
+        if "images" not in instance["media"]:
+            instance["media"]["images"] = []
+        idx = len(instance["media"]["images"])
+        instance["media"]["images"].append(value)
+        return f'<img src="media/images/{idx}">'

inference.py

@@ -1,12 +1,14 @@
 import abc
 import os
+import re
 from typing import Any, Dict, List, Literal, Optional, Union
 
 from tqdm import tqdm
 
 from .artifact import Artifact
-from .dataclass import InternalField
+from .dataclass import InternalField, NonPositionalField
 from .deprecation_utils import deprecation
+from .image_operators import extract_images
 from .logging_utils import get_logger
 from .operator import PackageRequirementsMixin
 
@@ -61,11 +63,20 @@ class LogProbInferenceEngine(abc.ABC, Artifact):
         return self._infer_log_probs(dataset)
 
 
-class HFPipelineBasedInferenceEngine(InferenceEngine, PackageRequirementsMixin):
+class LazyLoadMixin(Artifact):
+    lazy_load: bool = NonPositionalField(default=False)
+
+    @abc.abstractmethod
+    def _is_loaded(self):
+        pass
+
+
+class HFPipelineBasedInferenceEngine(
+    InferenceEngine, PackageRequirementsMixin, LazyLoadMixin
+):
     model_name: str
     max_new_tokens: int
     use_fp16: bool = True
-    lazy_load: bool = False
 
     _requirements_list = {
         "transformers": "Install huggingface package using 'pip install --upgrade transformers"
@@ -115,11 +126,11 @@ class HFPipelineBasedInferenceEngine(InferenceEngine, PackageRequirementsMixin):
         if not self.lazy_load:
             self._prepare_pipeline()
 
-    def is_pipeline_initialized(self):
+    def _is_loaded(self):
         return hasattr(self, "model") and self.model is not None
 
     def _infer(self, dataset):
-        if not self.is_pipeline_initialized():
+        if not self._is_loaded():
             self._prepare_pipeline()
 
         outputs = []
@@ -497,3 +508,71 @@ class WMLInferenceEngine(
             prompt=dataset["source"],
             params=self.to_dict([WMLInferenceEngineParamsMixin], keep_empty=False),
         )
+
+
+class HFLlavaInferenceEngine(InferenceEngine, LazyLoadMixin):
+    model_name: str
+    max_new_tokens: int
+    lazy_load = True
+
+    _requirements_list = {
+        "transformers": "Install huggingface package using 'pip install --upgrade transformers",
+        "torch": "Install torch, go on PyTorch website for mode details.",
+        "accelerate": "pip install accelerate",
+    }
+
+    def _prepare_engine(self):
+        import torch
+        from transformers import AutoProcessor, LlavaForConditionalGeneration
+
+        self.device = torch.device(
+            "mps"
+            if torch.backends.mps.is_available()
+            else 0
+            if torch.cuda.is_available()
+            else "cpu"
+        )
+
+        self.model = LlavaForConditionalGeneration.from_pretrained(
+            self.model_name,
+            torch_dtype=torch.float16,
+            low_cpu_mem_usage=True,
+        ).to(self.device)
+
+        self.processor = AutoProcessor.from_pretrained(self.model_name)
+
+    def prepare(self):
+        if not self.lazy_load:
+            self._prepare_engine()
+
+    def _is_loaded(self):
+        return hasattr(self, "model") and self.model is not None
+
+    def _infer(self, dataset):
+        if not self._is_loaded():
+            self._prepare_engine()
+
+        import torch
+
+        results = []
+        for instance in 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)
+            if len(images) == 1:
+                images = images[0]
+            inputs = self.processor(
+                images=images, text=model_input, return_tensors="pt"
+            ).to(self.device, torch.float16)
+            input_len = len(inputs["input_ids"][0])
+            output = self.model.generate(
+                **inputs, max_new_tokens=self.max_new_tokens, do_sample=False
+            )
+            result = self.processor.decode(
+                output[0][input_len:], skip_special_tokens=True
+            )
+            results.append(result)
+
+        return results

llm_as_judge.py

@@ -1,28 +1,32 @@
 from typing import Any, Dict, List, Literal, Optional
 
-from .api import evaluate, produce
-from .artifact import Artifact, fetch_artifact, settings
-from .formats import Format
+from .api import infer
+from .artifact import fetch_artifact
+from .dataclass import Field
+from .formats import Format, SystemFormat
 from .inference import InferenceEngine, OpenAiInferenceEngine
 from .metrics import BulkInstanceMetric
 from .operator import SequentialOperator
-from .system_prompts import SystemPrompt
+from .settings_utils import get_settings
+from .system_prompts import EmptySystemPrompt, SystemPrompt
 from .templates import Template
 
+settings = get_settings()
+
 
 class LLMAsJudge(BulkInstanceMetric):
-    """LLM as judge based metric class for evaluating correctness.
+    """LLM-as-judge-based metric class for evaluating correctness.
 
     Attributes:
         main_score (str): The main score label used for evaluation.
-        task (Literal["rating.single_turn"]): The type of task the llm-as-judge runs. This defines the output and input
-         format of the jude model.
+        task (Literal["rating.single_turn"]): The type of task the llm as judge runs. This defines the output and input
+         format of the judge model.
         template (Template): The template used when generating inputs for the judge llm.
         format (Format): The format used when generating inputs for judge llm.
         system_prompt (SystemPrompt): The system prompt used when generating inputs for judge llm.
         strip_system_prompt_and_format_from_inputs (bool): Whether to strip the system prompt and formatting from the
          inputs that the models that is being judges received, when they are inserted to the llm-as-judge prompt.
-        inference_model (InferenceEngine): the module that creates the inference of the judge llm.
+        inference_model (InferenceEngine): The module that creates the inference of the judge llm.
         reduction_map (dict): A dictionary specifying the reduction method for the metric.
         batch_size (int): The size of the bulk.
     """
@@ -34,8 +38,8 @@ class LLMAsJudge(BulkInstanceMetric):
         "pairwise_comparative_rating.single_turn",
     ]
     template: Template
-    format: Format = None
-    system_prompt: SystemPrompt = None
+    system_prompt: SystemPrompt = Field(default_factory=EmptySystemPrompt)
+    format: Format = Field(default_factory=SystemFormat)
     strip_system_prompt_and_format_from_inputs: bool = True
     inference_model: InferenceEngine
     reduction_map: Optional[Dict[str, List[str]]] = None
@@ -72,7 +76,6 @@ class LLMAsJudge(BulkInstanceMetric):
                 {
                     "question": input_instance,
                     "answer": prediction,
-                    "rating": 5.0,  # This is a dummy value that is not used in practice
                 }
                 for input_instance, prediction, reference in zip(
                     input_instances, predictions, references
@@ -84,7 +87,6 @@ class LLMAsJudge(BulkInstanceMetric):
                     "question": input_instance,
                     "answer": prediction,
                     "reference_answer": reference[0],
-                    "rating": 5.0,  # This is a dummy value that is not used in practice
                 }
                 for input_instance, prediction, reference in zip(
                     input_instances, predictions, references
@@ -98,7 +100,6 @@ class LLMAsJudge(BulkInstanceMetric):
                     "answer_b": reference[0],
                     "model_a": "input_model",
                     "model_b": "baseline_model",
-                    "answer_a_preference": 0,  # This is a dummy value that is not used in practice,
                 }
                 for input_instance, prediction, reference in zip(
                     input_instances, predictions, references
@@ -110,15 +111,6 @@ class LLMAsJudge(BulkInstanceMetric):
             )
         return instances
 
-    @staticmethod
-    def _add_metadata_to_judge_instances(
-        instances: List[List[Any]], task_data: List[Dict]
-    ):
-        for instance, data in zip(instances, task_data):
-            instance["data_classification_policy"] = data["metadata"][
-                "data_classification_policy"
-            ]
-
     def prepare(self):
         super().prepare()
         if self.task == "pairwise_comparative_rating.single_turn":
@@ -176,47 +168,38 @@ class LLMAsJudge(BulkInstanceMetric):
         instances = self._get_instance_for_judge_model(
             input_instances, predictions, references
         )
-        self._add_metadata_to_judge_instances(instances, task_data)
-
-        card = f"cards.dynamic_cards_for_llm_judges.{self.task}"
-        recipe_args = {
-            "card": card,
-            "template": self.template,
-            "demos_pool_size": 0,
-            "num_demos": 0,
-            "__type__": settings.default_recipe,
-        }
-        if self.system_prompt:
-            recipe_args["system_prompt"] = self.system_prompt
-        if self.format:
-            recipe_args["format"] = self.format
-        recipe = Artifact.from_dict(recipe_args)
-        dataset = produce(instances, recipe)
-        verdicts = self.inference_model.infer(dataset)
-        meta_scores = evaluate(predictions=verdicts, data=dataset)
-
-        res_list = []
-        for instance, verdict in zip(meta_scores, verdicts):
+        outputs = infer(
+            instances,
+            engine=self.inference_model,
+            task=f"tasks.response_assessment.{self.task}",
+            template=self.template,
+            system_prompt=self.system_prompt,
+            format=self.format,
+            return_data=True,
+        )
+
+        results = []
+        for instance in outputs:
             if self.task == "pairwise_comparative_rating.single_turn":
                 is_model_b_the_baseline = (
                     instance["task_data"]["model_b"] == "baseline_model"
                 )
                 if is_model_b_the_baseline:
-                    model_a_preference_score = instance["processed_prediction"]
+                    model_a_preference_score = instance["prediction"]
                 else:
-                    model_a_preference_score = instance["processed_prediction"] * -1
+                    model_a_preference_score = instance["prediction"] * -1
 
-                res = {
+                result = {
                     self.main_score: model_a_preference_score,
-                    "judge_raw_output": verdict,
+                    "judge_raw_output": instance["raw_prediction"],
                     "judge_raw_input": instance["source"],
                 }
             else:
-                res = {
-                    self.main_score: instance["processed_prediction"],
-                    "judge_raw_output": verdict,
+                result = {
+                    self.main_score: instance["prediction"],
+                    "judge_raw_output": instance["raw_prediction"],
                     "judge_raw_input": instance["source"],
                 }
-            res_list.append(res)
+            results.append(result)
 
-        return res_list
+        return results

loaders.py

@@ -7,23 +7,23 @@ Unitxt is all about readily preparing of any given data source for feeding into
 post-processing the model's output, preparing it for any given evaluator.
 
 Through that journey, the data advances in the form of Unitxt Multistream, undergoing a sequential application
-of various off the shelf operators (i.e, picked from Unitxt catalog), or operators easily implemented by inheriting.
-The journey starts by a Unitxt Loeader bearing a Multistream from the given datasource.
+of various off-the-shelf operators (i.e., picked from Unitxt catalog), or operators easily implemented by inheriting.
+The journey starts by a Unitxt Loader bearing a Multistream from the given datasource.
 A loader, therefore, is the first item on any Unitxt Recipe.
 
 Unitxt catalog contains several loaders for the most popular datasource formats.
-All these loaders inherit from Loader, and hence, implementing a loader to expand over a new type of datasource, is
-straight forward.
+All these loaders inherit from Loader, and hence, implementing a loader to expand over a new type of datasource is
+straightforward.
 
 Available Loaders Overview:
-    - :ref:`LoadHF <unitxt.loaders.LoadHF>` - Loads data from Huggingface datasets.
+    - :ref:`LoadHF <unitxt.loaders.LoadHF>` - Loads data from HuggingFace Datasets.
     - :ref:`LoadCSV <unitxt.loaders.LoadCSV>` - Imports data from CSV (Comma-Separated Values) files.
     - :ref:`LoadFromKaggle <unitxt.loaders.LoadFromKaggle>` - Retrieves datasets from the Kaggle community site.
     - :ref:`LoadFromIBMCloud <unitxt.loaders.LoadFromIBMCloud>` - Fetches datasets hosted on IBM Cloud.
     - :ref:`LoadFromSklearn <unitxt.loaders.LoadFromSklearn>` - Loads datasets available through the sklearn library.
     - :ref:`MultipleSourceLoader <unitxt.loaders.MultipleSourceLoader>` - Combines data from multiple different sources.
     - :ref:`LoadFromDictionary <unitxt.loaders.LoadFromDictionary>` - Loads data from a user-defined Python dictionary.
-    - :ref:`LoadFromHFSpace <unitxt.loaders.LoadFromHFSpace>` - Downloads and loads data from Huggingface Spaces.
+    - :ref:`LoadFromHFSpace <unitxt.loaders.LoadFromHFSpace>` - Downloads and loads data from HuggingFace Spaces.
 
 
 
@@ -64,7 +64,7 @@ class Loader(SourceOperator):
 
     A loader is the first component in the Unitxt Recipe,
     responsible for loading data from various sources and preparing it as a MultiStream for processing.
-    The loader_limit an optional parameter used to control the maximum number of instances to load from the data source.  It is applied for each split separately.
+    The loader_limit is an optional parameter used to control the maximum number of instances to load from the data source.  It is applied for each split separately.
     It is usually provided to the loader via the recipe (see standard.py)
     The loader can use this value to limit the amount of data downloaded from the source
     to reduce loading time.  However, this may not always be possible, so the
@@ -140,13 +140,13 @@ class Loader(SourceOperator):
 
 
 class LoadHF(Loader):
-    """Loads datasets from the Huggingface Hub.
+    """Loads datasets from the HuggingFace Hub.
 
     It supports loading with or without streaming,
-    and can filter datasets upon loading.
+    and it can filter datasets upon loading.
 
     Args:
-        path: The path or identifier of the dataset on the Huggingface Hub.
+        path: The path or identifier of the dataset on the HuggingFace Hub.
         name: An optional dataset name.
         data_dir: Optional directory to store downloaded data.
         split: Optional specification of which split to load.
@@ -652,7 +652,7 @@ class MultipleSourceLoader(Loader):
         sources: A list of loaders that will be combined to form a unified dataset.
 
     Examples:
-        1) Loading the train split from Huggingface hub and the test set from a local file:
+        1) Loading the train split from a HuggingFace Hub and the test set from a local file:
 
         .. code-block:: python
 
@@ -678,12 +678,12 @@ class MultipleSourceLoader(Loader):
 
     def load_data(self):
         return FixedFusion(
-            origins=self.sources, max_instances_per_origin_split=self.get_limit()
+            subsets=self.sources, max_instances_per_subset=self.get_limit()
         ).process()
 
 
 class LoadFromDictionary(Loader):
-    """Allows loading data from dictionary of constants.
+    """Allows loading data from a dictionary of constants.
 
     The loader can be used, for example, when debugging or working with small datasets.
 
@@ -733,29 +733,29 @@ class LoadFromDictionary(Loader):
 
 
 class LoadFromHFSpace(LoadHF):
-    """Used to load data from Huggingface spaces.
+    """Used to load data from HuggingFace Spaces.
 
     Loaders firstly tries to download all files specified in the 'data_files' parameter
-    from the given space and then reads them as a Huggingface dataset.
+    from the given space and then reads them as a HuggingFace Dataset.
 
     Args:
-        space_name (str): Name of the Huggingface space to be accessed to.
+        space_name (str): Name of the HuggingFace Space to be accessed.
         data_files (str | Sequence[str] | Mapping[str, str | Sequence[str]]): Relative
             paths to files within a given repository. If given as a mapping, paths should
             be values, while keys should represent the type of respective files
             (training, testing etc.).
-        path (str, optional): Absolute path to a directory where data should be downloaded to.
+        path (str, optional): Absolute path to a directory where data should be downloaded.
         revision (str, optional): ID of a Git branch or commit to be used. By default, it is
             set to None, thus data is downloaded from the main branch of the accessed
             repository.
-        use_token (bool, optional): Whether token used for authentication when accessing
-            the Huggingface space - if necessary - should be read from the Huggingface
+        use_token (bool, optional): Whether a token is used for authentication when accessing
+            the HuggingFace Space. If necessary, the token is read from the HuggingFace
             config folder.
         token_env (str, optional): Key of an env variable which value will be used for
-            authentication when accessing the Huggingface space - if necessary.
+            authentication when accessing the HuggingFace Space - if necessary.
 
     Example:
-        Loading from Huggingface Space
+        Loading from a HuggingFace Space
 
         .. code-block:: python
 

metric.py

@@ -4,6 +4,7 @@ import evaluate
 
 from .api import __file__ as _
 from .artifact import __file__ as _
+from .benchmark import __file__ as _
 from .blocks import __file__ as _
 from .card import __file__ as _
 from .catalog import __file__ as _
@@ -22,6 +23,7 @@ from .fusion import __file__ as _
 from .generator_utils import __file__ as _
 from .hf_utils import __file__ as _
 from .hf_utils import verify_versions_compatibility
+from .image_operators import __file__ as _
 from .inference import __file__ as _
 from .instructions import __file__ as _
 from .llm_as_judge import __file__ as _

metric_utils.py

@@ -1,11 +1,12 @@
 import json
-from typing import Any, Dict, Generator, Iterable, List, Optional
+from collections import defaultdict
+from functools import lru_cache
+from statistics import mean
+from typing import Any, Dict, Iterable, List, Optional
 
 from datasets import Features, Value
-from numpy import nanmean
 
 from .dataclass import Dataclass
-from .dict_utils import dict_set
 from .operator import (
     MultiStreamOperator,
     SequentialOperator,
@@ -17,111 +18,20 @@ from .operators import (
     ApplyOperatorsField,
     Copy,
     FlattenInstances,
-    MergeStreams,
-    RenameFields,
-    SplitByNestedGroup,
+    Rename,
 )
 from .register import _reset_env_local_catalogs, register_all_artifacts
 from .schema import UNITXT_DATASET_SCHEMA
-from .settings_utils import get_settings
+from .settings_utils import get_constants, get_settings
 from .stream import DynamicStream, MultiStream
 from .struct_data_operators import LoadJson
 from .utils import deepcopy
 
+constants = get_constants()
 
-class MultiStreamScoreMean(MultiStreamOperator):
-    """Given a multi-stream where each stream is already scored globally, generate a nested global score for the whole multi-stream.
-
-    The whole-ms-global-score is a nested structure, specifying (also) the individual global scores of the
-    individual streams participating in the input multi_stream.
-    The instances of all these individual streams are assumed to have the "group" field indicate the stream
-    they belong to.
-    Potentially, these individual streams were produced from a SplitByNestedGroup
-    operator that did not use the full length of the value in field "group" of the instances, but only the
-    first g components thereof, indicated by argument 'number_of_fusion_generations' of operator SplitByNestedGroup.
-    At any rate, a distinguishing prefix of the "group" value is recorded, by operator SplitByNestedGroup, in the stream_name.
-    The nested structure of the whole-ms-global-score is induced by these distinguishing prefixes,
-    by virtue of the global score of each individual stream sitting in the nested whole-ms-global-score,
-    deep in that dictionary, at the leaf lead to by a path being the distinguishing prefix indicated in the stream_name.
-    Thus, the global score of the stream becomes a leaf (though a dict by itself) of the whole-ms-global-score.
-
-    The ancestor nodes of the above leaves, in the whole-ms-global-score, contain each (in addition to dicts
-    leading down to leaves) a field named "score" whose value is set to be the mean of the values
-    sitting in field "score" of its immediate children nodes, and a field named "score_name" whose
-    value is set to be "group_mean".
-
-    When the input multistream consists of one single stream, it is returned as is, mainly for backward compatibility.
-    """
-
-    def update_intermediate_level_scores(self, level: dict) -> float:
-        if "score" in level:
-            return level["score"]
-            # the global score of the stream participating in this MultiStream
-        sub_scores = []
-        for key in level:
-            if isinstance(level[key], dict):
-                sub_scores.append(self.update_intermediate_level_scores(level[key]))
-        level.update({"score": nanmean(sub_scores), "score_name": "groups_mean"})
-        return level["score"]
-
-    def process(self, multi_stream: MultiStream) -> MultiStream:
-        # each stream went through Metric which is a single-stream-operator , and ended up with all
-        # its instance["score"]["global"] linking to the same single dict object.
-        # Here we first generate a new, nested version, for the whole-ms-global_score, and then update
-        # each stream's global score with the new version
-        # but if only one stream in the multistream - we return it as is
-        if len(multi_stream) == 1:
-            return multi_stream
-        global_score = {}
-        first_instances = {}
-        iterators = {}
 
-        for stream_name, stream in multi_stream.items():
-            iterators[stream_name] = iter(stream)
-            try:
-                first_instances[stream_name] = next(iterators[stream_name])
-            except StopIteration:
-                continue  # an empty stream, goto next stream
-            instance = first_instances[stream_name]
-            dict_set(
-                dic=global_score,
-                query=stream_name.split("~")[-1],
-                value=deepcopy(instance["score"]["global"]),
-                not_exist_ok=True,
-            )
-
-        self.update_intermediate_level_scores(global_score)
-        # update the global_score object for each stream. Recall that all instances
-        # in each stream link all to same python dict object
-        for stream_name in multi_stream.keys():
-            instance = first_instances[stream_name]
-            instance["score"]["global"].clear()
-            instance["score"]["global"].update(global_score)
-
-        def never_peek_twice_generator(
-            stream_name: str, first_instances: dict, iterators: dict
-        ) -> Generator:
-            while True:
-                if stream_name in first_instances:
-                    yield first_instances.pop(stream_name)
-                try:
-                    yield next(iterators[stream_name])
-                except StopIteration:
-                    return
-
-        return MultiStream(
-            {
-                stream_name: DynamicStream(
-                    never_peek_twice_generator,
-                    gen_kwargs={
-                        "stream_name": stream_name,
-                        "first_instances": first_instances,
-                        "iterators": iterators,
-                    },
-                )
-                for stream_name in multi_stream.keys()
-            }
-        )
+def nan_mean(scores):
+    return mean(score for score in scores if score == score)
 
 
 class FromPredictionsAndOriginalData(StreamInitializerOperator):
@@ -142,11 +52,6 @@ class FromPredictionsAndOriginalData(StreamInitializerOperator):
         )
 
 
-# The task_data field in the schema is defined as
-# Sequence({"key": Value(dtype="string"), "value": Value("string")})
-# When receiving instances from this scheme, the keys and values are returned as two separate
-# lists, and are converted to a dictionary.
-
 _post_process_steps = SequentialOperator(
     steps=[
         Copy(
@@ -156,6 +61,7 @@ _post_process_steps = SequentialOperator(
         Copy(
             field="references",
             to_field="raw_references",
+            dont_apply_to_streams=[constants.inference_stream],
         ),
         Copy(
             field="source",
@@ -171,11 +77,177 @@ _post_process_steps = SequentialOperator(
         Copy(
             field="references",
             to_field="processed_references",
+            dont_apply_to_streams=[constants.inference_stream],
         ),
     ]
 )
 
 
+@lru_cache(maxsize=None)
+def group_str(json_str):
+    data = json.loads(json_str)
+    return ",".join(f"{k}:{v}" for k, v in data.items())
+
+
+class SplitSubsetsAndGroups(MultiStreamOperator):
+    """Splits a MultiStream that is small - for metrics, hence: whole stream can sit in memory, split by the value of field 'group'.
+
+    Args:
+        number_of_fusion_generations: int
+
+    the value in field group is of the form "sourcen/sourcenminus1/..." describing the sources in which the instance sat
+    when these were fused, potentially several phases of fusion. the name of the most recent source sits first in this value.
+    (See BaseFusion and its extensions)
+    subsets_depth  specifies the depth of the prefix by which to split the stream.
+    """
+
+    subsets_field: str = "subset"
+    groups_field: str = "groups"
+    subset_depth: Optional[int] = None
+
+    def process(self, multi_stream: MultiStream) -> MultiStream:
+        result = defaultdict(list)
+
+        for stream_name, stream in multi_stream.items():
+            for i, instance in enumerate(stream):
+                instance["__idx__"] = i
+
+                for field in [self.subsets_field, self.groups_field]:
+                    if field not in instance:
+                        raise ValueError(
+                            f"Field {field} is missing from instance {instance}"
+                        )
+
+                subset_stream_name = (
+                    stream_name
+                    + "://"
+                    + "/".join(instance[self.subsets_field][: self.subset_depth])
+                )
+
+                result[subset_stream_name].append(instance)
+
+                for group in instance[self.groups_field]:
+                    result[subset_stream_name + "?" + group_str(group)].append(instance)
+
+        return MultiStream.from_iterables(result, copying=True)
+
+
+@lru_cache(maxsize=None)
+def group_str_to_key_value(group_str):
+    keys = []
+    values = []
+    for k_v in group_str.split(","):
+        k, v = k_v.split(":")
+        if v.isdigit():
+            v = int(v)
+        keys.append(k)
+        values.append(v)
+
+    if len(keys) == 1:
+        key = keys[0]
+    else:
+        key = tuple(keys)
+
+    if len(values) == 1:
+        value = values[0]
+    else:
+        value = tuple(values)
+
+    return key, value
+
+
+@lru_cache(maxsize=None)
+def stream_name_to_origin_subset_group(stream_name):
+    origin, subset_group = stream_name.split("://")
+    if "?" in subset_group:
+        subset, group = subset_group.split("?")
+    else:
+        subset, group = subset_group, None
+    return origin, subset, group
+
+
+class JoinSubsetsAndGroups(MultiStreamOperator):
+    def process(self, multi_stream: MultiStream) -> MultiStream:
+        instances = defaultdict(dict)
+        global_scores = defaultdict(dict)
+
+        for stream_name, stream in multi_stream.items():
+            origin, subset, group = stream_name_to_origin_subset_group(stream_name)
+
+            for i, instance in enumerate(stream):
+                global_score = instance["score"].pop("global")
+
+                idx = instance.pop("__idx__")
+                if idx not in instances[origin]:
+                    instances[origin][idx] = instance
+
+                # from here below setting the global scores from that stream
+                # can be done with first instance only
+                if i > 0:
+                    continue
+
+                if not group and not subset:
+                    global_scores[origin]["global"] = global_score
+                else:
+                    path = []
+
+                    if subset:
+                        path += ["subsets", *subset.split("/")]
+
+                    if group:
+                        key, value = group_str_to_key_value(group)
+                        path += ["groups", key, value]
+
+                    target = global_scores[origin]
+                    for part in path[:-1]:
+                        if part not in target:
+                            target[part] = {}
+                        target = target[part]
+                    target[path[-1]] = global_score
+
+        # the leafs always have score_name and score
+        def recursive_mean(dic):
+            if isinstance(dic, dict):
+                if "score" in dic and "score_name" in dic:
+                    return dic
+
+                result = {}
+                all_scores = []
+                for k, v in dic.items():
+                    score = recursive_mean(v)
+                    if score is not None:
+                        all_scores.append(score["score"])
+                        result[k] = score
+
+                result["score"] = nan_mean(all_scores)
+                result["score_name"] = "subsets_mean"
+
+                if result:
+                    return result
+
+            return None
+
+        result = {}
+        for stream_name, stream_instances in instances.items():
+            score = global_scores[stream_name]
+
+            if "subsets" in score:
+                score["subsets"] = recursive_mean(score["subsets"])
+                score["global"] = {
+                    "score": score["subsets"]["score"],
+                    "score_name": score["subsets"]["score_name"],
+                }
+
+            sorted_instances = []
+            for key in sorted(stream_instances.keys()):
+                instance = stream_instances[key]
+                instance["score"].update(deepcopy(score))
+                sorted_instances.append(instance)
+            result[stream_name] = sorted_instances
+
+        return MultiStream.from_iterables(result, copying=True)
+
+
 class PostProcessRecipe(SequentialOperatorInitializer):
     def prepare(self):
         register_all_artifacts()
@@ -185,10 +257,10 @@ class PostProcessRecipe(SequentialOperatorInitializer):
         ]
 
 
-def _post_process(
+def _inference_post_process(
     predictions: List[str],
     references: Iterable,
-    split_name: str = "all",
+    split_name: str = constants.inference_stream,
 ):
     _reset_env_local_catalogs()
     register_all_artifacts()
@@ -203,7 +275,7 @@ def _post_process(
 
 class MetricRecipe(SequentialOperatorInitializer):
     calc_confidence_intervals: bool = True
-    number_of_fusion_generations: int = 2
+    subset_depth: int = 2
 
     def prepare(self):
         register_all_artifacts()
@@ -211,21 +283,19 @@ class MetricRecipe(SequentialOperatorInitializer):
             FromPredictionsAndOriginalData(),
             LoadJson(field="task_data"),
             _post_process_steps,
-            SplitByNestedGroup(
-                field_name_of_group="group",
-                number_of_fusion_generations=self.number_of_fusion_generations,
+            SplitSubsetsAndGroups(
+                subset_depth=self.subset_depth,
             ),
             ApplyMetric(
                 "metrics",
                 calc_confidence_intervals=self.calc_confidence_intervals,
             ),
-            MultiStreamScoreMean(),
-            MergeStreams(),
-            RenameFields(
+            JoinSubsetsAndGroups(),
+            Rename(
                 field="raw_prediction",
                 to_field="prediction",
             ),
-            RenameFields(
+            Rename(
                 field="raw_references",
                 to_field="references",
             ),

metrics.py

@@ -21,7 +21,6 @@ from scipy.stats._warnings_errors import DegenerateDataWarning
 from .artifact import Artifact, fetch_artifact
 from .dataclass import (
     AbstractField,
-    DeprecatedField,
     InternalField,
     NonPositionalField,
     OptionalField,
@@ -1425,11 +1424,7 @@ class MetricPipeline(MultiStreamOperator, Metric):
     main_score: str = None
     preprocess_steps: Optional[List[StreamingOperator]] = field(default_factory=list)
     postprocess_steps: Optional[List[StreamingOperator]] = field(default_factory=list)
-    postpreprocess_steps: Optional[List[StreamingOperator]] = DeprecatedField(
-        metadata={
-            "deprecation_msg": "Field 'postpreprocess_steps' is deprecated. Please use 'postprocess_steps' for the same purpose."
-        }
-    )
+    postpreprocess_steps: Optional[List[StreamingOperator]] = None
     metric: Metric = None
 
     def disable_confidence_interval_calculation(self):
@@ -1446,6 +1441,9 @@ class MetricPipeline(MultiStreamOperator, Metric):
         assert isinstance(
             self.metric, Metric
         ), f"'metric' is not set to a Metric class in {self.get_metric_name()} (type{self.metric})"
+        if self.postpreprocess_steps is not None:
+            depr_message = "Field 'postpreprocess_steps' is deprecated. Please use 'postprocess_steps' for the same purpose."
+            warnings.warn(depr_message, DeprecationWarning, stacklevel=2)
 
     def prepare(self):
         super().prepare()
@@ -4729,3 +4727,170 @@ class MetricsEnsemble(InstanceMetric):
 
     def compute(self, references: List[Any], prediction: Any, task_data: Dict) -> dict:
         return {self.main_score: prediction}
+
+
+class F1Strings(InstanceMetric):
+    main_score = "f1_strings"
+    reduction_map = {"mean": ["f1_strings"]}
+    prediction_type = str
+    single_reference_per_prediction = True
+    _requirements_list = {
+        "spacy": "Please pip install spacy",
+    }
+
+    def prepare(self):
+        super().prepare()
+        import spacy
+
+        try:
+            self.nlp = spacy.load("en_core_web_sm")
+        except OSError:
+            from spacy.cli import download
+
+            download("en_core_web_sm")
+            self.nlp = spacy.load("en_core_web_sm")
+
+    def compute(
+        self,
+        references: List[str],
+        prediction: str,
+        task_data: List[Dict],
+    ) -> dict:
+        doc_ref = self.nlp(references[0])
+        set_ref = Counter([token.text.lower() for token in doc_ref])
+        doc_pred = self.nlp(prediction)
+        set_pred = Counter([token.text.lower() for token in doc_pred])
+
+        true_positives = sum((set_ref & set_pred).values())
+        false_positives = sum((set_ref - set_pred).values())
+        false_negatives = sum((set_pred - set_ref).values())
+
+        if true_positives == 0:
+            f1 = 0.0
+        else:
+            precision = true_positives / (true_positives + false_positives)
+            recall = true_positives / (true_positives + false_negatives)
+            if precision + recall == 0:
+                f1 = 0.0
+            else:
+                f1 = 2 * (precision * recall) / (precision + recall)
+
+        return {self.main_score: [f1], "score_name": self.main_score}
+
+
+class RandomForestMetricsEnsemble(MetricsEnsemble):
+    """This class extends the `MetricsEnsemble` base class and leverages a pre-trained scikit-learn Random Forest classification model to combine and aggregate scores from multiple judges.
+
+    `load_weights` method:
+         Loads model weights from dictionary representation of a random forest classifier.
+    `ensemble` method:
+         Decodes the RandomForestClassifier object and predict a score based on the given instance.
+    """
+
+    _requirements_list: List[str] = ["sklearn"]
+
+    def decode_tree(self, tree_dict, n_features, n_classes, n_outputs):
+        from sklearn.tree._tree import Tree
+
+        tree_dict["nodes"] = [tuple(lst) for lst in tree_dict["nodes"]]
+
+        tree_dict["values"] = np.array(tree_dict["values"])
+        names = [
+            "left_child",
+            "right_child",
+            "feature",
+            "threshold",
+            "impurity",
+            "n_node_samples",
+            "weighted_n_node_samples",
+            "missing_go_to_left",
+        ]
+        tree_dict["nodes"] = np.array(
+            tree_dict["nodes"],
+            dtype=np.dtype({"names": names, "formats": tree_dict["nodes_dtype"]}),
+        )
+
+        tree = Tree(n_features, np.array([n_classes], dtype=np.intp), n_outputs)
+        tree.__setstate__(tree_dict)
+
+        return tree
+
+    def decode_decision_tree(self, model_dict):
+        from sklearn.tree import DecisionTreeClassifier
+
+        decoded_model = DecisionTreeClassifier(**model_dict["params"])
+
+        decoded_model.n_features_in_ = model_dict["n_features_in_"]
+        decoded_model.n_outputs_ = model_dict["n_outputs_"]
+        decoded_model.max_features_ = model_dict["max_features_"]
+        decoded_model.n_classes_ = model_dict["n_classes_"]
+        decoded_model.classes_ = np.array(model_dict["classes_"])
+
+        tree = self.decode_tree(
+            model_dict["tree_"],
+            model_dict["n_features_in_"],
+            model_dict["n_classes_"],
+            model_dict["n_outputs_"],
+        )
+        decoded_model.tree_ = tree
+
+        return decoded_model
+
+    def decode_forest(self, model_dict):
+        from sklearn.ensemble import RandomForestClassifier
+
+        model = RandomForestClassifier(**model_dict["params"])
+        estimators = [
+            self.decode_decision_tree(decision_tree)
+            for decision_tree in model_dict["estimators_"]
+        ]
+        model.estimators_ = np.array(estimators)
+
+        model.n_features_in_ = model_dict["n_features_in_"]
+        model.feature_names_in_ = np.array(model_dict["feature_names_in_"])
+
+        model.min_samples_split = model_dict["min_samples_split"]
+        model.max_depth = model_dict["max_depth"]
+        model.min_samples_leaf = model_dict["min_samples_leaf"]
+        model.min_weight_fraction_leaf = model_dict["min_weight_fraction_leaf"]
+        model.max_features = model_dict["max_features"]
+        model.classes_ = np.array(model_dict["classes_"])
+        model.max_leaf_nodes = model_dict["max_leaf_nodes"]
+        model.min_impurity_decrease = model_dict["min_impurity_decrease"]
+        model.n_outputs_ = model_dict["n_outputs_"]
+
+        if isinstance(model_dict["n_classes_"], list):
+            model.n_classes_ = np.array(model_dict["n_classes_"])
+        else:
+            model.n_classes_ = model_dict["n_classes_"]
+
+        if "oob_score_" in model_dict:
+            model.oob_score_ = model_dict["oob_score_"]
+        if "oob_decision_function_" in model_dict:
+            model.oob_decision_function_ = model_dict["oob_decision_function_"]
+
+        return model
+
+    def prepare(self):
+        super().prepare()
+
+    @staticmethod
+    def load_weights(json_file):
+        with open(json_file) as file:
+            return json.load(file)
+
+    def ensemble(self, instance):
+        assert (
+            self.weights is not None
+        ), "RandomForestMetricsEnsemble must set self.weights before it can be used"
+        ensemble_model = self.decode_forest(self.weights)
+
+        prediction_lst = []
+        for i, metric in enumerate(self.metrics):
+            prediction_lst.append(
+                instance["score"]["instance"][
+                    self.get_prefix_name(i) + metric.main_score
+                ]
+            )
+        score = ensemble_model.predict([prediction_lst])
+        return score.tolist()[0]

operator.py

@@ -4,9 +4,12 @@ from typing import Any, Dict, Generator, List, Optional, Union
 
 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()
+
 
 class Operator(Artifact):
     pass
@@ -135,8 +138,13 @@ class MultiStreamOperator(StreamingOperator):
 
     caching: bool = NonPositionalField(default=None)
 
-    def __call__(self, multi_stream: Optional[MultiStream] = None) -> MultiStream:
+    def __call__(
+        self, multi_stream: Optional[MultiStream] = None, **instance: Dict[str, Any]
+    ) -> Union[MultiStream, Dict[str, Any]]:
         self.before_process_multi_stream()
+        if instance:
+            if multi_stream is not None:
+                return self.process_instance(instance)
         result = self._process_multi_stream(multi_stream)
         if self.caching is not None:
             result.set_caching(self.caching)
@@ -158,11 +166,11 @@ class MultiStreamOperator(StreamingOperator):
     def process(self, multi_stream: MultiStream) -> MultiStream:
         pass
 
-    def process_instance(self, instance, stream_name="tmp"):
+    def process_instance(self, instance, stream_name=constants.instance_stream):
         instance = self.verify_instance(instance)
         multi_stream = MultiStream({stream_name: stream_single(instance)})
         processed_multi_stream = self(multi_stream)
-        return next(iter(processed_multi_stream[stream_name]))
+        return instance_result(processed_multi_stream[stream_name])
 
 
 class SourceOperator(MultiStreamOperator):
@@ -214,6 +222,15 @@ class StreamInitializerOperator(SourceOperator):
         pass
 
 
+def instance_result(result_stream):
+    result = list(result_stream)
+    if len(result) == 0:
+        return None
+    if len(result) == 1:
+        return result[0]
+    return result
+
+
 class StreamOperator(MultiStreamOperator):
     """A class representing a single-stream operator in the streaming system.
 
@@ -277,12 +294,12 @@ class StreamOperator(MultiStreamOperator):
     def process(self, stream: Stream, stream_name: Optional[str] = None) -> Generator:
         pass
 
-    def process_instance(self, instance, stream_name="tmp"):
+    def process_instance(self, instance, stream_name=constants.instance_stream):
         instance = self.verify_instance(instance)
         processed_stream = self._process_single_stream(
             stream_single(instance), stream_name
         )
-        return next(iter(processed_stream))
+        return instance_result(processed_stream)
 
 
 class SingleStreamOperator(StreamOperator):
@@ -323,10 +340,10 @@ class PagedStreamOperator(StreamOperator):
     def process(self, page: List[Dict], stream_name: Optional[str] = None) -> Generator:
         pass
 
-    def process_instance(self, instance, stream_name="tmp"):
+    def process_instance(self, instance, stream_name=constants.instance_stream):
         instance = self.verify_instance(instance)
         processed_stream = self._process_page([instance], stream_name)
-        return next(iter(processed_stream))
+        return instance_result(processed_stream)
 
 
 class SingleStreamReducer(StreamingOperator):
@@ -381,7 +398,7 @@ class InstanceOperator(StreamOperator):
     ) -> Dict[str, Any]:
         pass
 
-    def process_instance(self, instance, stream_name="tmp"):
+    def process_instance(self, instance, stream_name=constants.instance_stream):
         return self._process_instance(instance, stream_name)
 
 
@@ -404,30 +421,13 @@ class InstanceOperatorValidator(InstanceOperator):
         except StopIteration as e:
             raise EmptyStreamError(f"Stream '{stream_name}' is empty") from e
         result = self._process_instance(first_instance, stream_name)
-        self.validate(result)
+        self.validate(result, stream_name)
         yield result
         yield from (
             self._process_instance(instance, stream_name) for instance in iterator
         )
 
 
-class BaseFieldOperator(Artifact):
-    """A class representing a field operator in the streaming system.
-
-    A field operator is a type of `Artifact` that operates on a single field within an instance. It takes an instance and a field name as input, processes the field, and updates the field in the instance with the processed value.
-    """
-
-    def __call__(self, data: Dict[str, Any], field: str) -> dict:
-        data = self.verify_instance(data)
-        value = self.process(data[field])
-        data[field] = value
-        return data
-
-    @abstractmethod
-    def process(self, value: Any) -> Any:
-        pass
-
-
 class InstanceOperatorWithMultiStreamAccess(StreamingOperator):
     """A class representing an instance operator with global access in the streaming system.
 
@@ -436,7 +436,12 @@ class InstanceOperatorWithMultiStreamAccess(StreamingOperator):
     In order to make this efficient and to avoid qudratic complexity, it caches the accessible streams by default.
     """
 
-    def __call__(self, multi_stream: Optional[MultiStream] = None) -> MultiStream:
+    def __call__(
+        self, multi_stream: Optional[MultiStream] = None, **instance: Dict[str, Any]
+    ) -> MultiStream:
+        if instance:
+            raise NotImplementedError("Instance mode is not supported")
+
         result = {}
 
         for stream_name, stream in multi_stream.items():

operators.py

@@ -14,9 +14,9 @@ To enhance the functionality of Unitxt, users are encouraged to develop custom o
 This can be achieved by inheriting from any of the existing operators listed below or from one of the fundamental :class:`base operators<unitxt.operator>`.
 The primary task in any operator development is to implement the `process` function, which defines the unique manipulations the operator will perform.
 
-General or Specelized Operators
+General or Specialized Operators
 --------------------------------
-Some operators are specielized in specific data or specific operations such as:
+Some operators are specialized in specific data or specific operations such as:
 
 - :class:`loaders<unitxt.loaders>` for accessing data from various sources.
 - :class:`splitters<unitxt.splitters>` for fixing data splits.
@@ -28,12 +28,12 @@ Some operators are specielized in specific data or specific operations such as:
 - :class:`span_labeling_operators<unitxt.span_labeling_operators>` for handling strings.
 - :class:`fusion<unitxt.fusion>` for fusing and mixing datasets.
 
-Other specelized operators are used by unitxt internally:
+Other specialized operators are used by unitxt internally:
 
 - :class:`templates<unitxt.templates>` for verbalizing data examples.
 - :class:`formats<unitxt.formats>` for preparing data for models.
 
-The rest of this section is dedicated for general operators.
+The rest of this section is dedicated to general operators.
 
 General Operators List:
 ------------------------
@@ -42,6 +42,7 @@ General Operators List:
 import copy
 import operator
 import uuid
+import warnings
 import zipfile
 from abc import abstractmethod
 from collections import Counter, defaultdict
@@ -63,7 +64,7 @@ from typing import (
 import requests
 
 from .artifact import Artifact, fetch_artifact
-from .dataclass import DeprecatedField, NonPositionalField, OptionalField
+from .dataclass import NonPositionalField, OptionalField
 from .deprecation_utils import deprecation
 from .dict_utils import dict_delete, dict_get, dict_set, is_subpath
 from .operator import (
@@ -81,13 +82,14 @@ from .operator import (
     StreamOperator,
 )
 from .random_utils import new_random_generator
-from .settings_utils import get_settings
+from .settings_utils import get_constants, get_settings
 from .stream import DynamicStream, Stream
 from .text_utils import nested_tuple_to_string
 from .type_utils import isoftype
 from .utils import deepcopy, flatten_dict
 
 settings = get_settings()
+constants = get_constants()
 
 
 class FromIterables(StreamInitializerOperator):
@@ -253,14 +255,15 @@ class Set(InstanceOperator):
     """
 
     fields: Dict[str, object]
-    use_query: bool = DeprecatedField(
-        metadata={
-            "deprecation_msg": "Field 'use_query' is deprecated. From now on, default behavior is compatible to use_query=True. "
-            "Please remove this field from your code."
-        }
-    )
+    use_query: Optional[bool] = None
     use_deepcopy: bool = False
 
+    def verify(self):
+        super().verify()
+        if self.use_query is not None:
+            depr_message = "Field 'use_query' is deprecated. From now on, default behavior is compatible to use_query=True. Please remove this field from your code."
+            warnings.warn(depr_message, DeprecationWarning, stacklevel=2)
+
     def process(
         self, instance: Dict[str, Any], stream_name: Optional[str] = None
     ) -> Dict[str, Any]:
@@ -341,19 +344,37 @@ class InstanceFieldOperator(InstanceOperator):
     field: Optional[str] = None
     to_field: Optional[str] = None
     field_to_field: Optional[Union[List[List[str]], Dict[str, str]]] = None
-    use_query: bool = DeprecatedField(
-        metadata={
-            "deprecation_msg": "Field 'use_query' is deprecated. From now on, default behavior is compatible to use_query=True. "
-            "Please remove this field from your code."
-        }
-    )
+    use_query: Optional[bool] = None
     process_every_value: bool = False
     get_default: Any = None
     not_exist_ok: bool = False
 
     def verify(self):
         super().verify()
+        if self.use_query is not None:
+            depr_message = "Field 'use_query' is deprecated. From now on, default behavior is compatible to use_query=True. Please remove this field from your code."
+            warnings.warn(depr_message, DeprecationWarning, stacklevel=2)
 
+    def verify_field_definition(self):
+        if hasattr(self, "_field_to_field") and self._field_to_field is not None:
+            return
+        assert (
+            (self.field is None) != (self.field_to_field is None)
+        ), "Must uniquely define the field to work on, through exactly one of either 'field' or 'field_to_field'"
+        assert (
+            self.to_field is None or self.field_to_field is None
+        ), f"Can not apply operator to create both {self.to_field} and the to fields in the mapping {self.field_to_field}"
+
+        if self.field_to_field is None:
+            self._field_to_field = [
+                (self.field, self.to_field if self.to_field is not None else self.field)
+            ]
+        else:
+            self._field_to_field = (
+                list(self.field_to_field.items())
+                if isinstance(self.field_to_field, dict)
+                else self.field_to_field
+            )
         assert (
             self.field is not None or self.field_to_field is not None
         ), "Must supply a field to work on"
@@ -363,7 +384,9 @@ class InstanceFieldOperator(InstanceOperator):
         assert (
             self.field is None or self.field_to_field is None
         ), f"Can not apply operator both on {self.field} and on the from fields in the mapping {self.field_to_field}"
-        assert self._field_to_field, f"the from and to fields must be defined or implied from the other inputs got: {self._field_to_field}"
+        assert (
+            self._field_to_field is not None
+        ), 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}"
@@ -402,31 +425,10 @@ class InstanceFieldOperator(InstanceOperator):
     def process_instance_value(self, value: Any, instance: Dict[str, Any]):
         pass
 
-    def prepare(self):
-        super().prepare()
-
-        # prepare is invoked before verify, hence must make some checks here, before the changes done here
-        assert (
-            (self.field is None) != (self.field_to_field is None)
-        ), "Must uniquely define the field to work on, through exactly one of either 'field' or 'field_to_field'"
-        assert (
-            self.to_field is None or self.field_to_field is None
-        ), f"Can not apply operator to create both {self.to_field} and the to fields in the mapping {self.field_to_field}"
-
-        if self.field_to_field is None:
-            self._field_to_field = [
-                (self.field, self.to_field if self.to_field is not None else self.field)
-            ]
-        else:
-            self._field_to_field = (
-                list(self.field_to_field.items())
-                if isinstance(self.field_to_field, dict)
-                else self.field_to_field
-            )
-
     def process(
         self, instance: Dict[str, Any], stream_name: Optional[str] = None
     ) -> Dict[str, Any]:
+        self.verify_field_definition()
         # Need to deep copy instance, because when assigning two dictionary fields,
         # dict_set() the target field dictionary fields.
         # This means that if this target field was assigned to another field before,
@@ -474,23 +476,23 @@ class FieldOperator(InstanceFieldOperator):
         pass
 
 
-class RenameFields(FieldOperator):
+class Rename(FieldOperator):
     """Renames fields.
 
     Move value from one field to another, potentially, if field name contains a /, from one branch into another.
     Remove the from field, potentially part of it in case of / in from_field.
 
     Examples:
-        RenameFields(field_to_field={"b": "c"})
+        Rename(field_to_field={"b": "c"})
         will change inputs [{"a": 1, "b": 2}, {"a": 2, "b": 3}] to [{"a": 1, "c": 2}, {"a": 2, "c": 3}]
 
-        RenameFields(field_to_field={"b": "c/d"})
+        Rename(field_to_field={"b": "c/d"})
         will change inputs [{"a": 1, "b": 2}, {"a": 2, "b": 3}] to [{"a": 1, "c": {"d": 2}}, {"a": 2, "c": {"d": 3}}]
 
-        RenameFields(field_to_field={"b": "b/d"})
+        Rename(field_to_field={"b": "b/d"})
         will change inputs [{"a": 1, "b": 2}, {"a": 2, "b": 3}] to [{"a": 1, "b": {"d": 2}}, {"a": 2, "b": {"d": 3}}]
 
-        RenameFields(field_to_field={"b/c/e": "b/d"})
+        Rename(field_to_field={"b/c/e": "b/d"})
         will change inputs [{"a": 1, "b": {"c": {"e": 2, "f": 20}}}] to [{"a": 1, "b": {"c": {"f": 20}, "d": 2}}]
 
     """
@@ -511,6 +513,11 @@ class RenameFields(FieldOperator):
         return res
 
 
+@deprecation(version="2.0.0", alternative=Rename)
+class RenameFields(Rename):
+    pass
+
+
 class AddConstant(FieldOperator):
     """Adds a constant, being argument 'add', to the processed value.
 
@@ -777,7 +784,7 @@ class Apply(InstanceOperator):
     Args:
         function (str): name of function.
         to_field (str): the field to store the result
-        additional arguments are field names passed to the function
+        any additional arguments are field names whose values will be passed directly to the function specified
 
     Examples:
     Store in field  "b" the uppercase string of the value in field "a"
@@ -846,12 +853,13 @@ class ListFieldValues(InstanceOperator):
 
     fields: List[str]
     to_field: str
-    use_query: bool = DeprecatedField(
-        metadata={
-            "deprecation_msg": "Field 'use_query' is deprecated. From now on, default behavior is compatible to use_query=True. "
-            "Please remove this field from your code."
-        }
-    )
+    use_query: Optional[bool] = None
+
+    def verify(self):
+        super().verify()
+        if self.use_query is not None:
+            depr_message = "Field 'use_query' is deprecated. From now on, default behavior is compatible to use_query=True. Please remove this field from your code."
+            warnings.warn(depr_message, DeprecationWarning, stacklevel=2)
 
     def process(
         self, instance: Dict[str, Any], stream_name: Optional[str] = None
@@ -878,12 +886,13 @@ class ZipFieldValues(InstanceOperator):
     fields: List[str]
     to_field: str
     longest: bool = False
-    use_query: bool = DeprecatedField(
-        metadata={
-            "deprecation_msg": "Field 'use_query' is deprecated. From now on, default behavior is compatible to use_query=True. "
-            "Please remove this field from your code."
-        }
-    )
+    use_query: Optional[bool] = None
+
+    def verify(self):
+        super().verify()
+        if self.use_query is not None:
+            depr_message = "Field 'use_query' is deprecated. From now on, default behavior is compatible to use_query=True. Please remove this field from your code."
+            warnings.warn(depr_message, DeprecationWarning, stacklevel=2)
 
     def process(
         self, instance: Dict[str, Any], stream_name: Optional[str] = None
@@ -950,12 +959,13 @@ class IndexOf(InstanceOperator):
     search_in: str
     index_of: str
     to_field: str
-    use_query: bool = DeprecatedField(
-        metadata={
-            "deprecation_msg": "Field 'use_query' is deprecated. From now on, default behavior is compatible to use_query=True. "
-            "Please remove this field from your code."
-        }
-    )
+    use_query: Optional[bool] = None
+
+    def verify(self):
+        super().verify()
+        if self.use_query is not None:
+            depr_message = "Field 'use_query' is deprecated. From now on, default behavior is compatible to use_query=True. Please remove this field from your code."
+            warnings.warn(depr_message, DeprecationWarning, stacklevel=2)
 
     def process(
         self, instance: Dict[str, Any], stream_name: Optional[str] = None
@@ -972,12 +982,13 @@ class TakeByField(InstanceOperator):
     field: str
     index: str
     to_field: str = None
-    use_query: bool = DeprecatedField(
-        metadata={
-            "deprecation_msg": "Field 'use_query' is deprecated. From now on, default behavior is compatible to use_query=True. "
-            "Please remove this field from your code."
-        }
-    )
+    use_query: Optional[bool] = None
+
+    def verify(self):
+        super().verify()
+        if self.use_query is not None:
+            depr_message = "Field 'use_query' is deprecated. From now on, default behavior is compatible to use_query=True. Please remove this field from your code."
+            warnings.warn(depr_message, DeprecationWarning, stacklevel=2)
 
     def prepare(self):
         if self.to_field is None:
@@ -1060,8 +1071,12 @@ class Copy(FieldOperator):
 
     """
 
+    use_deep_copy: bool = True
+
     def process_value(self, value: Any) -> Any:
-        return copy.deepcopy(value)
+        if self.use_deep_copy:
+            return copy.deepcopy(value)
+        return value
 
 
 @deprecation(version="2.0.0", alternative=Copy)
@@ -1090,6 +1105,31 @@ class AddID(InstanceOperator):
         return instance
 
 
+class Cast(FieldOperator):
+    """Casts specified fields to specified types.
+
+    Args:
+        default (object): A dictionary mapping field names to default values for cases of casting failure.
+        process_every_value (bool): If true, all fields involved must contain lists, and each value in the list is then casted. Defaults to False.
+    """
+
+    to: str
+    failure_default: Optional[Any] = "__UNDEFINED__"
+
+    def prepare(self):
+        self.types = {"int": int, "float": float, "str": str, "bool": bool}
+
+    def process_value(self, value):
+        try:
+            return self.types[self.to](value)
+        except ValueError as e:
+            if self.failure_default == "__UNDEFINED__":
+                raise ValueError(
+                    f'Failed to cast value {value} to type "{self.to}", and no default value is provided.'
+                ) from e
+            return self.failure_default
+
+
 class CastFields(InstanceOperator):
     """Casts specified fields to specified types.
 
@@ -1247,7 +1287,7 @@ class ApplyOperatorsField(InstanceOperator):
 
         # we now have a list of nanes of operators, each is equipped with process_instance method.
         operator = SequentialOperator(steps=operator_names)
-        return operator.process_instance(instance)
+        return operator.process_instance(instance, stream_name=stream_name)
 
 
 class FilterByCondition(StreamOperator):
@@ -1767,7 +1807,7 @@ class ApplyStreamOperatorsField(StreamOperator, ArtifactFetcherMixin):
                 operator, StreamingOperator
             ), f"Operator {operator_name} must be a StreamOperator"
 
-            stream = operator(MultiStream({"tmp": stream}))["tmp"]
+            stream = operator(MultiStream({stream_name: stream}))[stream_name]
 
         yield from stream
 
@@ -1808,7 +1848,7 @@ class ApplyMetric(StreamOperator, ArtifactFetcherMixin):
         # Here we keep all the fields besides the score, and restore them after the metric finishes.
         first_instance = stream.peek()
         keys_to_restore = set(first_instance.keys()).difference({"score"})
-        multi_stream = MultiStream({"tmp": stream})
+        multi_stream = MultiStream({stream_name: stream})
         multi_stream = CopyFields(
             field_to_field={k: f"{k}_orig" for k in keys_to_restore}
         )(multi_stream)
@@ -1830,7 +1870,7 @@ class ApplyMetric(StreamOperator, ArtifactFetcherMixin):
         multi_stream = RemoveFields(fields=[f"{k}_orig" for k in keys_to_restore])(
             multi_stream
         )
-        stream = multi_stream["tmp"]
+        stream = multi_stream[stream_name]
         yield from stream
 
 

processors.py

@@ -1,10 +1,38 @@
 import ast
+import copy
 import json
 import re
 from difflib import get_close_matches
 from typing import Any, Dict
 
+from .deprecation_utils import deprecation
+from .operator import MultiStreamOperator
 from .operators import FieldOperator, InstanceFieldOperator
+from .settings_utils import get_constants
+
+constants = get_constants()
+
+
+class PostProcess(MultiStreamOperator):
+    operator: InstanceFieldOperator
+    process_prediction: bool = True
+    process_references: bool = True
+
+    def prepare(self):
+        super().prepare()
+        self.prediction_operator = copy.deepcopy(self.operator)
+        self.prediction_operator.field = "prediction"
+        self.references_operator = copy.deepcopy(self.operator)
+        self.references_operator.field = "references"
+        self.references_operator.process_every_value = True
+        self.references_operator.dont_apply_to_streams = [constants.inference_stream]
+
+    def process(self, multi_stream):
+        if self.process_prediction:
+            multi_stream = self.prediction_operator(multi_stream)
+        if self.process_references:
+            multi_stream = self.references_operator(multi_stream)
+        return multi_stream
 
 
 class ToString(FieldOperator):
@@ -114,11 +142,16 @@ class LowerCaseTillPunc(FieldOperator):
         return non_empty_line
 
 
-class LowerCase(FieldOperator):
+class Lower(FieldOperator):
     def process_value(self, text: Any) -> Any:
         return text.lower()
 
 
+@deprecation("2.0.0", alternative=Lower)
+class LowerCase(Lower):
+    pass
+
+
 class Capitalize(FieldOperator):
     def process_value(self, text: Any) -> Any:
         return text.capitalize()
@@ -212,7 +245,7 @@ class StanceToProCon(FieldOperator):
         return "none"
 
 
-class StringOrNotString(FieldOperator):
+class StringEquals(FieldOperator):
     string: str
 
     def process_value(self, text: Any) -> Any:
@@ -223,6 +256,11 @@ class StringOrNotString(FieldOperator):
         return text
 
 
+@deprecation("2.0.0", alternative=StringEquals)
+class StringOrNotString(StringEquals):
+    pass
+
+
 class ExtractMtBenchRatingJudgment(FieldOperator):
     def process_value(self, text: Any) -> Any:
         match = re.search(r"\[\[([\d]+\.?[\d]*)\]\]", text)

schema.py

@@ -1,10 +1,14 @@
 import json
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
-from datasets import Features, Sequence, Value
+from datasets import Audio, Features, Image, Sequence, Value
 
 from .artifact import Artifact
+from .dict_utils import dict_get
 from .operator import InstanceOperatorValidator
+from .settings_utils import get_constants
+
+constants = get_constants()
 
 UNITXT_DATASET_SCHEMA = Features(
     {
@@ -12,7 +16,24 @@ UNITXT_DATASET_SCHEMA = Features(
         "target": Value("string"),
         "references": Sequence(Value("string")),
         "metrics": Sequence(Value("string")),
-        "group": Value("string"),
+        "groups": Sequence(Value("string")),
+        "subset": Sequence(Value("string")),
+        "media": {
+            "images": Sequence(Image()),
+            "audios": Sequence(Audio()),
+        },
+        "postprocessors": Sequence(Value("string")),
+        "task_data": Value(dtype="string"),
+        "data_classification_policy": Sequence(Value("string")),
+    }
+)
+
+UNITXT_INFERENCE_SCHEMA = Features(
+    {
+        "source": Value("string"),
+        "metrics": Sequence(Value("string")),
+        "groups": Sequence(Value("string")),
+        "subset": Sequence(Value("string")),
         "postprocessors": Sequence(Value("string")),
         "task_data": Value(dtype="string"),
         "data_classification_policy": Sequence(Value("string")),
@@ -20,7 +41,14 @@ UNITXT_DATASET_SCHEMA = Features(
 )
 
 
+def get_schema(stream_name):
+    if stream_name == constants.inference_stream:
+        return UNITXT_INFERENCE_SCHEMA
+    return UNITXT_DATASET_SCHEMA
+
+
 class Finalize(InstanceOperatorValidator):
+    group_by: List[List[str]]
     remove_unnecessary_fields: bool = True
 
     @staticmethod
@@ -29,33 +57,63 @@ class Finalize(InstanceOperatorValidator):
             return artifact.to_dict()
         return artifact.__id__
 
+    def _prepare_media(self, instance):
+        if "media" not in instance:
+            instance["media"] = {}
+
+        if "images" not in instance["media"]:
+            instance["media"]["images"] = []
+
+        if "audios" not in instance["media"]:
+            instance["media"]["audios"] = []
+
+        return instance
+
     def process(
         self, instance: Dict[str, Any], stream_name: Optional[str] = None
     ) -> Dict[str, Any]:
+        metadata = {
+            "data_classification_policy": instance["data_classification_policy"],
+            "template": self.artifact_to_jsonable(
+                instance["recipe_metadata"]["template"]
+            ),
+            "num_demos": instance["recipe_metadata"]["num_demos"],
+        }
         task_data = {
             **instance["input_fields"],
-            **instance["reference_fields"],
-            "metadata": {
-                "data_classification_policy": instance["data_classification_policy"],
-                "template": self.artifact_to_jsonable(
-                    instance["recipe_metadata"]["template"]
-                ),
-                "num_demos": instance["recipe_metadata"]["num_demos"],
-            },
+            "metadata": metadata,
         }
+
+        if stream_name != constants.inference_stream:
+            task_data = {**task_data, **instance["reference_fields"]}
+
         instance["task_data"] = json.dumps(task_data)
 
         if self.remove_unnecessary_fields:
             keys_to_delete = []
 
             for key in instance.keys():
-                if key not in UNITXT_DATASET_SCHEMA:
+                if key not in get_schema(stream_name):
                     keys_to_delete.append(key)
 
             for key in keys_to_delete:
                 del instance[key]
-        if "group" not in instance:
-            instance["group"] = "unitxt"
+
+        data = {**task_data, **metadata}
+        groups = []
+        for group_attributes in self.group_by:
+            group = {}
+            if isinstance(group_attributes, str):
+                group_attributes = [group_attributes]
+            for attribute in group_attributes:
+                group[attribute] = dict_get(data, attribute)
+            groups.append(json.dumps(group))
+
+        instance["groups"] = groups
+        instance["subset"] = []
+
+        instance = self._prepare_media(instance)
+
         instance["metrics"] = [
             metric.to_json() if isinstance(metric, Artifact) else metric
             for metric in instance["metrics"]
@@ -64,6 +122,7 @@ class Finalize(InstanceOperatorValidator):
             processor.to_json() if isinstance(processor, Artifact) else processor
             for processor in instance["postprocessors"]
         ]
+
         return instance
 
     def validate(self, instance: Dict[str, Any], stream_name: Optional[str] = None):
@@ -72,7 +131,8 @@ class Finalize(InstanceOperatorValidator):
         assert isinstance(
             instance, dict
         ), f"Instance should be a dict, got {type(instance)}"
+        schema = get_schema(stream_name)
         assert all(
-            key in instance for key in UNITXT_DATASET_SCHEMA
-        ), f"Instance should have the following keys: {UNITXT_DATASET_SCHEMA}. Instance is: {instance}"
-        UNITXT_DATASET_SCHEMA.encode_example(instance)
+            key in instance for key in schema
+        ), f"Instance should have the following keys: {schema}. Instance is: {instance}"
+        schema.encode_example(instance)

settings_utils.py

@@ -1,5 +1,6 @@
 import importlib.util
 import os
+from contextlib import contextmanager
 
 from .version import version
 
@@ -87,6 +88,17 @@ class Settings:
             self.environment_variable_key_name(key) for key in self._settings.keys()
         ]
 
+    @contextmanager
+    def context(self, **kwargs):
+        old_values = {key: self._settings.get(key, None) for key in kwargs}
+        try:
+            for key, value in kwargs.items():
+                self.__setattr__(key, value)
+            yield
+        finally:
+            for key, value in old_values.items():
+                self.__setattr__(key, value)
+
 
 class Constants:
     _instance = None
@@ -163,6 +175,8 @@ if Constants.is_uninitilized():
     ]
     constants.codebase_url = "https://github.com/IBM/unitxt"
     constants.website_url = "https://www.unitxt.org"
+    constants.inference_stream = "__INFERENCE_STREAM__"
+    constants.instance_stream = "__INSTANCE_STREAM__"
 
 
 def get_settings():

standard.py

@@ -9,11 +9,14 @@ from .operator import SequentialOperator, SourceSequentialOperator, StreamingOpe
 from .operators import Augmentor, NullAugmentor, Set, StreamRefiner
 from .recipe import Recipe
 from .schema import Finalize
+from .settings_utils import get_constants
 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
 
+constants = get_constants()
 logger = get_logger()
 
 
@@ -24,7 +27,8 @@ class CreateDemosPool(SeparateSplit):
 
 class BaseRecipe(Recipe, SourceSequentialOperator):
     # Base parameters
-    card: TaskCard
+    card: TaskCard = None
+    task: Task = None
     template: Union[Template, List[Template]] = None
     system_prompt: SystemPrompt = Field(default_factory=EmptySystemPrompt)
     format: Format = Field(default_factory=SystemFormat)
@@ -34,6 +38,8 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
     metrics: List[str] = NonPositionalField(default=None)
     postprocessors: List[str] = NonPositionalField(default=None)
 
+    group_by: List[Union[str, List[str]]] = []
+
     loader_limit: int = None
 
     max_train_instances: int = None
@@ -68,6 +74,17 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
 
     def verify(self):
         super().verify()
+
+        if self.task is None and self.card is None:
+            raise ValueError("Set card or task in the recipe")
+
+        if self.card is None and (
+            self.num_demos > 0 or self.demos_pool_size is not None
+        ):
+            raise ValueError(
+                "To use num_demos and demos_pool_size in recipe set a card."
+            )
+
         if self.use_demos:
             if self.demos_pool_size is None or self.demos_pool_size < 1:
                 raise ValueError(
@@ -143,19 +160,18 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
             )
 
     def set_pipelines(self):
-        self.loading = SequentialOperator()
-        self.loading.__description__ = "Loading the data from the data source."
-        self.metadata = SequentialOperator()
-        self.metadata.__description__ = (
-            "Adding metadata (e.g. format, system prompt, template)  "
+        self.loading = SequentialOperator(
+            __description__="Loading the data from the data source."
         )
-        self.standardization = SequentialOperator()
-        self.standardization.__description__ = (
-            "Standardizing the raw dataset fields to task field definition."
+        self.metadata = SequentialOperator(
+            __description__="Adding metadata (e.g. format, system prompt, template)  "
         )
-        self.processing = SequentialOperator()
-        self.processing.__description__ = (
-            "Setting task fields (and selecting demos per sample if needed)."
+        self.standardization = SequentialOperator(
+            __description__="Standardizing the raw dataset fields to task field definition."
+        )
+
+        self.processing = SequentialOperator(
+            __description__="Setting task fields (and selecting demos per sample if needed)."
         )
         self.verbalization = SequentialOperator()
         self.verbalization.__description__ = "Verbalizing the input to the model and gold references to the 'source', 'target' and 'references' fields."
@@ -197,8 +213,8 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
         self._demos_pool_cache = None
 
     def production_preprocess(self, task_instances):
-        ms = MultiStream.from_iterables({"__inference__": task_instances})
-        return list(self.inference_instance(ms)["__inference__"])
+        ms = MultiStream.from_iterables({constants.inference_stream: task_instances})
+        return list(self.inference_instance(ms)[constants.inference_stream])
 
     def production_demos_pool(self):
         if self.use_demos:
@@ -222,30 +238,34 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
         self.before_process_multi_stream()
         multi_stream = MultiStream.from_iterables(
             {
-                "__inference__": self.production_preprocess(task_instances),
+                constants.inference_stream: self.production_preprocess(task_instances),
                 self.demos_pool_name: self.production_demos_pool(),
             }
         )
         multi_stream = self.inference(multi_stream)
-        return list(multi_stream["__inference__"])
+        return list(multi_stream[constants.inference_stream])
 
-    def prepare(self):
-        # To avoid the Python's mutable default list trap, we set the default value to None
-        # and then set it to an empty list if it is None.
-        if self.card.preprocess_steps is None:
+    def reset_pipeline(self):
+        if self.card and self.card.preprocess_steps is None:
             self.card.preprocess_steps = []
 
-        self.set_pipelines()
+        if self.task is None:
+            self.task = self.card.task
 
-        loader = self.card.loader
-        if self.loader_limit:
-            loader.loader_limit = self.loader_limit
-            logger.info(f"Loader line limit was set to  {self.loader_limit}")
-        self.loading.steps.append(loader)
+        self.set_pipelines()
 
-        # This is required in case loader_limit is not enforced by the loader
-        if self.loader_limit:
-            self.loading.steps.append(StreamRefiner(max_instances=self.loader_limit))
+        if self.card is not None:
+            loader = self.card.loader
+            if self.loader_limit:
+                loader.loader_limit = self.loader_limit
+                logger.info(f"Loader line limit was set to  {self.loader_limit}")
+            self.loading.steps.append(loader)
+
+            # This is required in case loader_limit is not enforced by the loader
+            if self.loader_limit:
+                self.loading.steps.append(
+                    StreamRefiner(max_instances=self.loader_limit)
+                )
 
         self.metadata.steps.append(
             Set(
@@ -256,9 +276,10 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
             )
         )
 
-        self.standardization.steps.extend(self.card.preprocess_steps)
+        if self.card:
+            self.standardization.steps.extend(self.card.preprocess_steps)
 
-        self.processing.steps.append(self.card.task)
+        self.processing.steps.append(self.task)
 
         if self.augmentor.augment_task_input:
             self.augmentor.set_task_input_fields(self.card.task.augmentable_inputs)
@@ -352,7 +373,10 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
         if self.metrics is not None:
             self.finalize.steps.append(Set(fields={"metrics": self.metrics}))
 
-        self.finalize.steps.append(Finalize())
+        self.finalize.steps.append(Finalize(group_by=self.group_by))
+
+    def prepare(self):
+        self.reset_pipeline()
 
 
 class StandardRecipeWithIndexes(BaseRecipe):
@@ -395,6 +419,7 @@ class StandardRecipe(StandardRecipeWithIndexes):
         format (SystemFormat, optional): SystemFormat object to be used for the recipe.
         metrics (List[str]): list of catalog metrics to use with this recipe.
         postprocessors (List[str]): list of catalog processors to apply at post processing. (Not recommended to use from here)
+        group_by (List[Union[str, List[str]]]): list of task_data or metadata keys to group global scores by.
         train_refiner (StreamRefiner, optional): Train refiner to be used in the recipe.
         max_train_instances (int, optional): Maximum training instances for the refiner.
         validation_refiner (StreamRefiner, optional): Validation refiner to be used in the recipe.

stream.py

@@ -222,7 +222,9 @@ class MultiStream(dict):
         for stream in self.values():
             stream.set_copying(copying)
 
-    def to_dataset(self, disable_cache=True, cache_dir=None) -> DatasetDict:
+    def to_dataset(
+        self, disable_cache=True, cache_dir=None, features=None
+    ) -> DatasetDict:
         with tempfile.TemporaryDirectory() as dir_to_be_deleted:
             cache_dir = dir_to_be_deleted if disable_cache else cache_dir
             return DatasetDict(
@@ -232,6 +234,7 @@ class MultiStream(dict):
                         keep_in_memory=disable_cache,
                         cache_dir=cache_dir,
                         gen_kwargs={"key": key},
+                        features=features,
                     )
                     for key in self.keys()
                 }
@@ -281,7 +284,10 @@ class MultiStream(dict):
 
     @classmethod
     def from_iterables(
-        cls, iterables: Dict[str, Iterable], caching=False, copying=False
+        cls,
+        iterables: Dict[str, Iterable[Dict[str, Any]]],
+        caching=False,
+        copying=False,
     ):
         """Creates a MultiStream from a dictionary of iterables.
 

struct_data_operators.py

@@ -623,3 +623,40 @@ class MapTableListsToStdTableJSON(FieldOperator):
 
     def map_tablelists_to_stdtablejson_util(self, table_content: str) -> Dict:
         return {"header": table_content[0], "rows": table_content[1:]}
+
+
+class ConstructTableFromRowsCols(InstanceOperator):
+    """Maps column and row field into single table field encompassing both header and rows.
+
+    field[0] = header string as List
+    field[1] = rows string as List[List]
+    field[2] = table caption string(optional)
+    """
+
+    fields: List[str]
+    to_field: str
+
+    def process(
+        self, instance: Dict[str, Any], stream_name: Optional[str] = None
+    ) -> Dict[str, Any]:
+        header = dict_get(instance, self.fields[0])
+        rows = dict_get(instance, self.fields[1])
+
+        if len(self.fields) >= 3:
+            caption = instance[self.fields[2]]
+        else:
+            caption = None
+
+        import ast
+
+        header_processed = ast.literal_eval(header)
+        rows_processed = ast.literal_eval(rows)
+
+        output_dict = {"header": header_processed, "rows": rows_processed}
+
+        if caption is not None:
+            output_dict["caption"] = caption
+
+        instance[self.to_field] = output_dict
+
+        return instance

task.py

@@ -1,11 +1,13 @@
+import warnings
 from functools import lru_cache
 from typing import Any, Dict, List, Optional, Union
 
 from .artifact import fetch_artifact
-from .dataclass import DeprecatedField
 from .deprecation_utils import deprecation
 from .error_utils import Documentation, UnitxtError, UnitxtWarning
+from .logging_utils import get_logger
 from .operator import InstanceOperator
+from .settings_utils import get_constants
 from .type_utils import (
     Type,
     get_args,
@@ -19,6 +21,9 @@ from .type_utils import (
     verify_required_schema,
 )
 
+constants = get_constants()
+logger = get_logger()
+
 
 @deprecation(
     version="2.0.0",
@@ -57,18 +62,8 @@ class Task(InstanceOperator):
 
     input_fields: Optional[Union[Dict[str, Type], Dict[str, str], List[str]]] = None
     reference_fields: Optional[Union[Dict[str, Type], Dict[str, str], List[str]]] = None
-    inputs: Union[Dict[str, Type], Dict[str, str], List[str]] = DeprecatedField(
-        default=None,
-        metadata={
-            "deprecation_msg": "The 'inputs' field is deprecated. Please use 'input_fields' instead."
-        },
-    )
-    outputs: Union[Dict[str, Type], Dict[str, str], List[str]] = DeprecatedField(
-        default=None,
-        metadata={
-            "deprecation_msg": "The 'outputs' field is deprecated. Please use 'reference_fields' instead."
-        },
-    )
+    inputs: Optional[Union[Dict[str, Type], Dict[str, str], List[str]]] = None
+    outputs: Optional[Union[Dict[str, Type], Dict[str, str], List[str]]] = None
     metrics: List[str]
     prediction_type: Optional[Union[Type, str]] = None
     augmentable_inputs: List[str] = []
@@ -108,6 +103,16 @@ class Task(InstanceOperator):
             )
 
     def verify(self):
+        if hasattr(self, "inputs") and self.inputs is not None:
+            depr_message = (
+                "The 'inputs' field is deprecated. Please use 'input_fields' instead."
+            )
+            warnings.warn(depr_message, DeprecationWarning, stacklevel=2)
+
+        if hasattr(self, "outputs") and self.outputs is not None:
+            depr_message = "The 'outputs' field is deprecated. Please use 'reference_fields' instead."
+            warnings.warn(depr_message, DeprecationWarning, stacklevel=2)
+
         if self.input_fields is None:
             raise UnitxtError(
                 "Missing attribute in task: 'input_fields' not set.",
@@ -249,19 +254,26 @@ class Task(InstanceOperator):
         instance = self.set_default_values(instance)
 
         verify_required_schema(self.input_fields, instance)
-        verify_required_schema(self.reference_fields, instance)
-
         input_fields = {key: instance[key] for key in self.input_fields.keys()}
-        reference_fields = {key: instance[key] for key in self.reference_fields.keys()}
         data_classification_policy = instance.get("data_classification_policy", [])
 
-        return {
+        result = {
             "input_fields": input_fields,
-            "reference_fields": reference_fields,
             "metrics": self.metrics,
             "data_classification_policy": data_classification_policy,
+            "media": instance.get("media", {}),
         }
 
+        if stream_name == constants.inference_stream:
+            return result
+
+        verify_required_schema(self.reference_fields, instance)
+        result["reference_fields"] = {
+            key: instance[key] for key in self.reference_fields.keys()
+        }
+
+        return result
+
 
 @deprecation(version="2.0.0", alternative=Task)
 class FormTask(Task):

templates.py

@@ -10,8 +10,11 @@ from .dict_utils import dict_set
 from .error_utils import Documentation, UnitxtError
 from .operator import InstanceOperator
 from .random_utils import new_random_generator
+from .settings_utils import get_constants
 from .type_utils import isoftype
 
+constants = get_constants()
+
 
 class TemplateFormatKeyError(UnitxtError):
     def __init__(self, template, data, data_type, format_str, format_name):
@@ -84,20 +87,30 @@ class Template(InstanceOperator):
         instruction, target_prefix = self.input_fields_to_instruction_and_target_prefix(
             input_fields
         )
-        target, references = self.reference_fields_to_target_and_references(
-            reference_fields
-        )
 
-        return {
+        result = {
             **instance,
             "source": source,
-            "target": target,
-            "references": references,
             "instruction": instruction,
             "target_prefix": target_prefix,
             "postprocessors": self.postprocessors,
         }
 
+        if stream_name == constants.inference_stream:
+            return result
+
+        if reference_fields is None:
+            raise ValueError("Should have reference_fields")
+
+        target, references = self.reference_fields_to_target_and_references(
+            reference_fields
+        )
+
+        result["target"] = target
+        result["references"] = references
+
+        return result
+
     @abstractmethod
     def input_fields_to_source(self, input_fields: Dict[str, object]) -> str:
         pass
@@ -143,8 +156,13 @@ class ApplyTemplate(InstanceOperator):
     def get_template(self, instance: Dict[str, Any]) -> Template:
         pass
 
-    def apply(self, template: Template, instance: Dict[str, Any]):
-        return template.process_instance(instance)
+    def apply(
+        self,
+        template: Template,
+        instance: Dict[str, Any],
+        stream_name: Optional[str] = None,
+    ):
+        return template.process_instance(instance, stream_name)
 
     def process(
         self, instance: Dict[str, Any], stream_name: Optional[str] = None
@@ -155,11 +173,11 @@ class ApplyTemplate(InstanceOperator):
             if self.demos_field not in instance:
                 raise ValueError("Demos field is missing.")
             instance[self.demos_field] = [
-                self.apply(template, demo_instance)
+                self.apply(template, demo_instance, stream_name)
                 for demo_instance in instance[self.demos_field]
             ]
         dict_set(instance, "recipe_metadata/template", template)
-        return self.apply(template, instance)
+        return self.apply(template, instance, stream_name)
 
 
 class ApplySingleTemplate(ApplyTemplate):
@@ -268,6 +286,9 @@ class PairwiseChoiceTemplate(InputOutputTemplate):
     choice_tie_label: str
     shuffle: bool
 
+    def verify(self):
+        super().verify()
+
     def verbalize_answer_field(self, reference_fields: Dict[str, object]):
         answer = reference_fields[self.answer_field]
         assert answer in ["choice_a", "choice_b", "tie"]
@@ -552,34 +573,45 @@ class MultipleChoiceTemplate(Template):
 
         return target, [target]
 
-    def _shuffle_choices(self, instance):
-        target_index = self.outputs_to_target_index(instance["reference_fields"])
-        original_label_choice = instance["reference_fields"][self.choices_field][
-            target_index
-        ]
+    def _shuffle_choices(self, instance, stream_name):
+        if stream_name != constants.inference_stream:
+            target_index = self.outputs_to_target_index(instance["reference_fields"])
+            original_label_choice = instance["reference_fields"][self.choices_field][
+                target_index
+            ]
         choices = instance["input_fields"][self.choices_field]
-        random_generator = new_random_generator(
-            {**instance["input_fields"], **instance["reference_fields"]}
-        )
+
+        random_seed = {**instance["input_fields"]}
+
+        random_generator = new_random_generator(random_seed)
         random_generator.shuffle(choices)
         instance["input_fields"][self.choices_field] = choices
+
+        if stream_name == constants.inference_stream:
+            return instance
+
         instance["reference_fields"][self.choices_field] = choices
         instance["reference_fields"][self.target_field] = choices.index(
             original_label_choice
         )
+
         return instance
 
     def process(
         self, instance: Dict[str, Any], stream_name: Optional[str] = None
     ) -> Dict[str, Any]:
         if self.shuffle_choices:
-            instance = self._shuffle_choices(instance)
+            instance = self._shuffle_choices(instance, stream_name)
         result = super().process(instance, stream_name)
-
-        if "options" not in result["reference_fields"]:
-            result["reference_fields"]["options"] = self.inputs_to_choices(
-                instance["reference_fields"], self.target_choice_format
+        if stream_name == constants.inference_stream:
+            result["input_fields"]["options"] = self.inputs_to_choices(
+                instance["input_fields"], self.target_choice_format
             )
+        else:
+            if "options" not in result["reference_fields"]:
+                result["reference_fields"]["options"] = self.inputs_to_choices(
+                    instance["reference_fields"], self.target_choice_format
+                )
         return result
 
 

version.py

@@ -1 +1 @@
-version = "1.12.3"
+version = "1.12.4"