dataeval 0.86.1__tar.gz → 0.86.2__tar.gz

{dataeval-0.86.1 → dataeval-0.86.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.86.1
+Version: 0.86.2
 Summary: DataEval provides a simple interface to characterize image data and its impact on model performance across classification and object-detection tasks
 Home-page: https://dataeval.ai/
 License: MIT
@@ -29,6 +29,7 @@ Requires-Dist: numba (>=0.59.1)
 Requires-Dist: numpy (>=1.24.2)
 Requires-Dist: pandas (>=2.0)
 Requires-Dist: pillow (>=10.3.0)
+Requires-Dist: polars (>=1.0.0)
 Requires-Dist: requests
 Requires-Dist: scikit-learn (>=1.5.0)
 Requires-Dist: scipy (>=1.10)

{dataeval-0.86.1 → dataeval-0.86.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dataeval"
-version = "0.86.1" # dynamic
+version = "0.86.2" # dynamic
 description = "DataEval provides a simple interface to characterize image data and its impact on model performance across classification and object-detection tasks"
 license = "MIT"
 readme = "README.md"
@@ -49,6 +49,7 @@ numba = {version = ">=0.59.1"}
 numpy = {version = ">=1.24.2"}
 pandas = {version = ">=2.0"}
 pillow = {version = ">=10.3.0"}
+polars = {version = ">=1.0.0"}
 requests = {version = "*"}
 scipy = {version = ">=1.10"}
 scikit-learn = {version = ">=1.5.0"}

{dataeval-0.86.1 → dataeval-0.86.2}/src/dataeval/__init__.py

@@ -8,7 +8,7 @@ shifts that impact performance of deployed models.
 from __future__ import annotations
 
 __all__ = ["config", "detectors", "log", "metrics", "typing", "utils", "workflows"]
-__version__ = "0.86.1"
+__version__ = "0.86.2"
 
 import logging
 

dataeval-0.86.2/src/dataeval/data/_metadata.py

@@ -0,0 +1,392 @@
+from __future__ import annotations
+
+__all__ = []
+
+import warnings
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Iterable, Literal, Mapping, Sequence, Sized
+
+import numpy as np
+import polars as pl
+from numpy.typing import NDArray
+
+from dataeval.typing import (
+    AnnotatedDataset,
+    Array,
+    ObjectDetectionTarget,
+)
+from dataeval.utils._array import as_numpy
+from dataeval.utils._bin import bin_data, digitize_data
+from dataeval.utils.data.metadata import merge
+
+if TYPE_CHECKING:
+    from dataeval.data import Targets
+else:
+    from dataeval.data._targets import Targets
+
+
+@dataclass
+class FactorInfo:
+    factor_type: Literal["categorical", "continuous", "discrete"] | None = None
+    discretized_col: str | None = None
+
+
+class Metadata:
+    """
+    Class containing binned metadata using Polars DataFrames.
+
+    Parameters
+    ----------
+    dataset : ImageClassificationDataset or ObjectDetectionDataset
+        Dataset to access original targets and metadata from.
+    continuous_factor_bins : Mapping[str, int | Sequence[float]] | None, default None
+        Mapping from continuous factor name to the number of bins or bin edges
+    auto_bin_method : Literal["uniform_width", "uniform_count", "clusters"], default "uniform_width"
+        Method for automatically determining the number of bins for continuous factors
+    exclude : Sequence[str] | None, default None
+        Filter metadata factors to exclude the specified factors, cannot be set with `include`
+    include : Sequence[str] | None, default None
+        Filter metadata factors to include the specified factors, cannot be set with `exclude`
+    """
+
+    def __init__(
+        self,
+        dataset: AnnotatedDataset[tuple[Any, Any, dict[str, Any]]],
+        *,
+        continuous_factor_bins: Mapping[str, int | Sequence[float]] | None = None,
+        auto_bin_method: Literal["uniform_width", "uniform_count", "clusters"] = "uniform_width",
+        exclude: Sequence[str] | None = None,
+        include: Sequence[str] | None = None,
+    ) -> None:
+        self._targets: Targets
+        self._class_labels: NDArray[np.intp]
+        self._class_names: list[str]
+        self._image_indices: NDArray[np.intp]
+        self._factors: dict[str, FactorInfo]
+        self._dropped_factors: dict[str, list[str]]
+        self._dataframe: pl.DataFrame
+
+        self._is_structured = False
+        self._is_binned = False
+
+        self._dataset = dataset
+        self._continuous_factor_bins = dict(continuous_factor_bins) if continuous_factor_bins else {}
+        self._auto_bin_method: Literal["uniform_width", "uniform_count", "clusters"] = auto_bin_method
+
+        if exclude is not None and include is not None:
+            raise ValueError("Filters for `exclude` and `include` are mutually exclusive.")
+
+        self._exclude = set(exclude or ())
+        self._include = set(include or ())
+
+    @property
+    def targets(self) -> Targets:
+        """Target information for the dataset."""
+        self._structure()
+        return self._targets
+
+    @property
+    def raw(self) -> list[dict[str, Any]]:
+        """The raw list of metadata dictionaries for the dataset."""
+        self._structure()
+        return self._raw
+
+    @property
+    def exclude(self) -> set[str]:
+        """Factors to exclude from the metadata."""
+        return self._exclude
+
+    @exclude.setter
+    def exclude(self, value: Sequence[str]) -> None:
+        exclude = set(value)
+        if self._exclude != exclude:
+            self._exclude = exclude
+            self._include = set()
+            self._is_binned = False
+
+    @property
+    def include(self) -> set[str]:
+        """Factors to include from the metadata."""
+        return self._include
+
+    @include.setter
+    def include(self, value: Sequence[str]) -> None:
+        include = set(value)
+        if self._include != include:
+            self._include = include
+            self._exclude = set()
+            self._is_binned = False
+
+    @property
+    def continuous_factor_bins(self) -> Mapping[str, int | Sequence[float]]:
+        """Map of factor names to bin counts or bin edges."""
+        return self._continuous_factor_bins
+
+    @continuous_factor_bins.setter
+    def continuous_factor_bins(self, bins: Mapping[str, int | Sequence[float]]) -> None:
+        if self._continuous_factor_bins != bins:
+            self._continuous_factor_bins = dict(bins)
+            self._reset_bins(bins)
+
+    @property
+    def auto_bin_method(self) -> Literal["uniform_width", "uniform_count", "clusters"]:
+        """Binning method to use when continuous_factor_bins is not defined."""
+        return self._auto_bin_method
+
+    @auto_bin_method.setter
+    def auto_bin_method(self, method: Literal["uniform_width", "uniform_count", "clusters"]) -> None:
+        if self._auto_bin_method != method:
+            self._auto_bin_method = method
+            self._reset_bins()
+
+    @property
+    def dataframe(self) -> pl.DataFrame:
+        """Dataframe containing target information and metadata factors."""
+        self._structure()
+        return self._dataframe
+
+    @property
+    def dropped_factors(self) -> dict[str, list[str]]:
+        """Factors that were dropped during preprocessing and the reasons why they were dropped."""
+        self._structure()
+        return self._dropped_factors
+
+    @property
+    def discretized_data(self) -> NDArray[np.int64]:
+        """Factor data with continuous data discretized."""
+        if not self.factor_names:
+            return np.array([], dtype=np.int64)
+
+        self._bin()
+        return (
+            self.dataframe.select([info.discretized_col or name for name, info in self.factor_info.items()])
+            .to_numpy()
+            .astype(np.int64)
+        )
+
+    @property
+    def factor_names(self) -> list[str]:
+        """Factor names of the metadata."""
+        self._structure()
+        return list(self._factors)
+
+    @property
+    def factor_info(self) -> dict[str, FactorInfo]:
+        """Factor types of the metadata."""
+        self._bin()
+        return self._factors
+
+    @property
+    def factor_data(self) -> NDArray[Any]:
+        """Factor data as a NumPy array."""
+        if not self.factor_names:
+            return np.array([], dtype=np.float64)
+
+        # Extract continuous columns and convert to NumPy array
+        return self.dataframe.select(self.factor_names).to_numpy()
+
+    @property
+    def class_labels(self) -> NDArray[np.intp]:
+        """Class labels as a NumPy array."""
+        self._structure()
+        return self._class_labels
+
+    @property
+    def class_names(self) -> list[str]:
+        """Class names as a list of strings."""
+        self._structure()
+        return self._class_names
+
+    @property
+    def image_indices(self) -> NDArray[np.intp]:
+        """Indices of images as a NumPy array."""
+        self._bin()
+        return self._image_indices
+
+    @property
+    def image_count(self) -> int:
+        self._bin()
+        return int(self._image_indices.max() + 1)
+
+    def _reset_bins(self, cols: Iterable[str] | None = None) -> None:
+        if self._is_binned:
+            columns = self._dataframe.columns
+            for col in (col for col in cols or columns if f"{col}[|]" in columns):
+                self._dataframe.drop_in_place(f"{col}[|]")
+                self._factors[col] = FactorInfo()
+            self._is_binned = False
+
+    def _structure(self) -> None:
+        if self._is_structured:
+            return
+
+        raw: list[dict[str, Any]] = []
+
+        labels = []
+        bboxes = []
+        scores = []
+        srcidx = []
+        is_od = None
+        for i in range(len(self._dataset)):
+            _, target, metadata = self._dataset[i]
+
+            raw.append(metadata)
+
+            if is_od_target := isinstance(target, ObjectDetectionTarget):
+                target_labels = as_numpy(target.labels)
+                target_len = len(target_labels)
+                labels.extend(target_labels.tolist())
+                bboxes.extend(as_numpy(target.boxes).tolist())
+                scores.extend(as_numpy(target.scores).tolist())
+                srcidx.extend([i] * target_len)
+            elif isinstance(target, Array):
+                target_len = 1
+                labels.append(int(np.argmax(as_numpy(target))))
+                scores.append(target)
+            else:
+                raise TypeError("Encountered unsupported target type in dataset")
+
+            is_od = is_od_target if is_od is None else is_od
+            if is_od != is_od_target:
+                raise ValueError("Encountered unexpected target type in dataset")
+
+        labels = as_numpy(labels).astype(np.intp)
+        scores = as_numpy(scores).astype(np.float32)
+        bboxes = as_numpy(bboxes).astype(np.float32) if is_od else None
+        srcidx = as_numpy(srcidx).astype(np.intp) if is_od else None
+
+        target_dict = {
+            "image_index": srcidx if srcidx is not None else np.arange(len(labels)),
+            "class_label": labels,
+            "score": scores,
+            "box": bboxes if bboxes is not None else [None] * len(labels),
+        }
+
+        self._targets = Targets(labels, scores, bboxes, srcidx)
+        self._raw = raw
+
+        index2label = self._dataset.metadata.get("index2label", {})
+        self._class_labels = labels
+        self._class_names = [index2label.get(i, str(i)) for i in np.unique(self._class_labels)]
+        self._image_indices = target_dict["image_index"]
+
+        targets_per_image = None if srcidx is None else np.unique(srcidx, return_counts=True)[1].tolist()
+        merged = merge(raw, return_dropped=True, ignore_lists=False, targets_per_image=targets_per_image)
+
+        reserved = ["image_index", "class_label", "score", "box"]
+        factor_dict = {f"metadata_{k}" if k in reserved else k: v for k, v in merged[0].items() if k != "_image_index"}
+
+        self._factors = dict.fromkeys(factor_dict, FactorInfo())
+        self._dataframe = pl.DataFrame({**target_dict, **factor_dict})
+        self._dropped_factors = merged[1]
+        self._is_structured = True
+
+    def _bin(self) -> None:
+        """Populate factor info and bin non-categorical factors."""
+        if self._is_binned:
+            return
+
+        # Start with an empty set of factor info
+        factor_info: dict[str, FactorInfo] = {}
+
+        # Create a mutable DataFrame for updates
+        df = self.dataframe.clone()
+        factor_bins = self.continuous_factor_bins
+
+        # Check for invalid keys
+        invalid_keys = set(factor_bins.keys()) - set(df.columns)
+        if invalid_keys:
+            warnings.warn(
+                f"The keys - {invalid_keys} - are present in the `continuous_factor_bins` dictionary "
+                "but are not columns in the metadata DataFrame. Unknown keys will be ignored."
+            )
+
+        column_set = set(df.columns)
+        for col in (col for col in self.factor_names if f"{col}[|]" not in column_set):
+            # Get data as numpy array for processing
+            data = df[col].to_numpy()
+            col_dz = f"{col}[|]"
+            if col in factor_bins:
+                # User provided binning
+                bins = factor_bins[col]
+                df = df.with_columns(pl.Series(name=col_dz, values=digitize_data(data, bins).astype(np.int64)))
+                factor_info[col] = FactorInfo("continuous", col_dz)
+            else:
+                # Check if data is numeric
+                unique, ordinal = np.unique(data, return_inverse=True)
+                if not np.issubdtype(data.dtype, np.number) or unique.size <= max(20, data.size * 0.01):
+                    # Non-numeric data or small number of unique values - convert to categorical
+                    df = df.with_columns(pl.Series(name=col_dz, values=ordinal.astype(np.int64)))
+                    factor_info[col] = FactorInfo("categorical", col_dz)
+                elif data.dtype == float:
+                    # Many unique values - discretize by binning
+                    warnings.warn(
+                        f"A user defined binning was not provided for {col}. "
+                        f"Using the {self.auto_bin_method} method to discretize the data. "
+                        "It is recommended that the user rerun and supply the desired "
+                        "bins using the continuous_factor_bins parameter.",
+                        UserWarning,
+                    )
+                    # Create binned version
+                    binned_data = bin_data(data, self.auto_bin_method)
+                    df = df.with_columns(pl.Series(name=col_dz, values=binned_data.astype(np.int64)))
+                    factor_info[col] = FactorInfo("continuous", col_dz)
+                else:
+                    factor_info[col] = FactorInfo("discrete", col_dz)
+
+        # Store the results
+        self._dataframe = df
+        self._factors.update(factor_info)
+        self._is_binned = True
+
+    def get_factors_by_type(self, factor_type: Literal["categorical", "continuous", "discrete"]) -> list[str]:
+        """
+        Get the names of factors of a specific type.
+
+        Parameters
+        ----------
+        factor_type : Literal["categorical", "continuous", "discrete"]
+            The type of factors to retrieve.
+
+        Returns
+        -------
+        list[str]
+            List of factor names of the specified type.
+        """
+        self._bin()
+        return [name for name, info in self.factor_info.items() if info.factor_type == factor_type]
+
+    def add_factors(self, factors: Mapping[str, Any]) -> None:
+        """
+        Add additional factors to the metadata.
+
+        The number of measures per factor must match the number of images
+        in the dataset or the number of detections in the dataset.
+
+        Parameters
+        ----------
+        factors : Mapping[str, ArrayLike]
+            Dictionary of factors to add to the metadata.
+        """
+        self._structure()
+
+        targets = len(self.targets.source) if self.targets.source is not None else len(self.targets)
+        images = self.image_count
+        lengths = {k: len(v if isinstance(v, Sized) else np.atleast_1d(as_numpy(v))) for k, v in factors.items()}
+        targets_match = all(f == targets for f in lengths.values())
+        images_match = targets_match if images == targets else all(f == images for f in lengths.values())
+        if not targets_match and not images_match:
+            raise ValueError(
+                "The lists/arrays in the provided factors have a different length than the current metadata factors."
+            )
+
+        new_columns = []
+        for k, v in factors.items():
+            v = as_numpy(v)
+            data = v if (self.targets.source is None or lengths[k] == targets) else v[self.targets.source]
+            new_columns.append(pl.Series(name=k, values=data))
+            self._factors[k] = FactorInfo()
+
+        if new_columns:
+            self._dataframe = self.dataframe.with_columns(new_columns)
+            self._is_binned = False

{dataeval-0.86.1 → dataeval-0.86.2}/src/dataeval/data/_split.py

@@ -207,8 +207,8 @@ def get_groups(metadata: Metadata, split_on: Sequence[str] | None) -> NDArray[np
         return None
 
     split_set = set(split_on)
-    indices = [i for i, name in enumerate(metadata.discrete_factor_names) if name in split_set]
-    binned_features = metadata.discrete_data[:, indices]
+    indices = [i for i, name in enumerate(metadata.factor_names) if name in split_set]
+    binned_features = metadata.discretized_data[:, indices]
     return np.unique(binned_features, axis=0, return_inverse=True)[1]
 
 

{dataeval-0.86.1 → dataeval-0.86.2}/src/dataeval/metadata/_distance.py

@@ -80,14 +80,17 @@ def metadata_distance(metadata1: Metadata, metadata2: Metadata) -> MetadataDista
     MetadataDistanceValues(statistic=1.0, location=0.44354838709677413, dist=2.7, pvalue=0.0)
     """
 
-    _compare_keys(metadata1.continuous_factor_names, metadata2.continuous_factor_names)
-    fnames = metadata1.continuous_factor_names
+    _compare_keys(metadata1.factor_names, metadata2.factor_names)
+    cont_fnames = metadata1.get_factors_by_type("continuous")
 
-    cont1 = np.atleast_2d(metadata1.continuous_data)  # (S, F)
-    cont2 = np.atleast_2d(metadata2.continuous_data)  # (S, F)
+    if not cont_fnames:
+        return MetadataDistanceOutput({})
 
-    _validate_factors_and_data(fnames, cont1)
-    _validate_factors_and_data(fnames, cont2)
+    cont1 = np.atleast_2d(metadata1.dataframe[cont_fnames].to_numpy())  # (S, F)
+    cont2 = np.atleast_2d(metadata2.dataframe[cont_fnames].to_numpy())  # (S, F)
+
+    _validate_factors_and_data(cont_fnames, cont1)
+    _validate_factors_and_data(cont_fnames, cont2)
 
     N = len(cont1)
     M = len(cont2)
@@ -104,7 +107,7 @@ def metadata_distance(metadata1: Metadata, metadata2: Metadata) -> MetadataDista
     results: dict[str, MetadataDistanceValues] = {}
 
     # Per factor
-    for i, fname in enumerate(fnames):
+    for i, fname in enumerate(cont_fnames):
         fdata1 = cont1[:, i]  # (S, 1)
         fdata2 = cont2[:, i]  # (S, 1)
 

{dataeval-0.86.1 → dataeval-0.86.2}/src/dataeval/metadata/_ood.py

@@ -15,95 +15,6 @@ from dataeval.outputs import MostDeviatedFactorsOutput, OODOutput, OODPredictorO
 from dataeval.outputs._base import set_metadata
 
 
-def _combine_discrete_continuous(metadata: Metadata) -> tuple[list[str], NDArray[np.float64]]:
-    """Combines the discrete and continuous data of a :class:`Metadata` object
-
-    Returns
-    -------
-    Tuple[list[str], NDArray]
-        The combined list of factors names and the combined discrete and continuous data
-
-    Note
-    ----
-    Discrete and continuous data must have the same number of samples
-    """
-    names = []
-    data = []
-
-    if metadata.discrete_factor_names and metadata.discrete_data.size != 0:
-        names.extend(metadata.discrete_factor_names)
-        data.append(metadata.discrete_data)
-
-    if metadata.continuous_factor_names and metadata.continuous_data.size != 0:
-        names.extend(metadata.continuous_factor_names)
-        data.append(metadata.continuous_data)
-
-    return names, np.hstack(data, dtype=np.float64) if data else np.array([], dtype=np.float64)
-
-
-def _combine_metadata(
-    metadata_1: Metadata, metadata_2: Metadata
-) -> tuple[list[str], list[NDArray[np.float64 | np.int64]], list[NDArray[np.int64 | np.float64]]]:
-    """
-    Combines the factor names and data arrays of metadata_1 and metadata_2 when the names
-    match exactly and data has the same number of columns (factors).
-
-    Parameters
-    ----------
-    metadata_1 : Metadata
-        The set of factor names used as reference to determine the correct factor names and length of data
-    metadata_2 : Metadata
-        The compared set of factor names and data that must match metadata_1
-
-    Returns
-    -------
-    list[str]
-        The combined discrete and continuous factor names in that order.
-    list[NDArray]
-        Combined discrete and continuous data of metadata_1
-    list[NDArray]
-        Combined discrete and continuous data of metadata_2
-
-    Raises
-    ------
-    ValueError
-        If keys do not match in metadata_1 and metadata_2
-    ValueError
-        If the length of keys do not match the length of the data
-    """
-    factor_names: list[str] = []
-    m1_data: list[NDArray[np.int64 | np.float64]] = []
-    m2_data: list[NDArray[np.int64 | np.float64]] = []
-
-    # Both metadata must have the same number of factors (cols), but not necessarily samples (row)
-    if metadata_1.total_num_factors != metadata_2.total_num_factors:
-        raise ValueError(
-            f"Number of factors differs between metadata_1 ({metadata_1.total_num_factors}) "
-            f"and metadata_2 ({metadata_2.total_num_factors})"
-        )
-
-    # Validate and attach discrete data
-    if metadata_1.discrete_factor_names:
-        _compare_keys(metadata_1.discrete_factor_names, metadata_2.discrete_factor_names)
-        _validate_factors_and_data(metadata_1.discrete_factor_names, metadata_1.discrete_data)
-
-        factor_names.extend(metadata_1.discrete_factor_names)
-        m1_data.append(metadata_1.discrete_data)
-        m2_data.append(metadata_2.discrete_data)
-
-    # Validate and attach continuous data
-    if metadata_1.continuous_factor_names:
-        _compare_keys(metadata_1.continuous_factor_names, metadata_2.continuous_factor_names)
-        _validate_factors_and_data(metadata_1.continuous_factor_names, metadata_1.continuous_data)
-
-        factor_names.extend(metadata_1.continuous_factor_names)
-        m1_data.append(metadata_1.continuous_data)
-        m2_data.append(metadata_2.continuous_data)
-
-    # Turns list of discrete and continuous into one array
-    return factor_names, m1_data, m2_data
-
-
 def _calc_median_deviations(reference: NDArray, test: NDArray) -> NDArray:
     """
     Calculates deviations of the test data from the median of the reference data
@@ -207,16 +118,13 @@ def find_most_deviated_factors(
     if not any(ood_mask):
         return MostDeviatedFactorsOutput([])
 
-    # Combines reference and test factor names and data if exists and match exactly
-    # shape -> (samples, factors)
-    factor_names, md_1, md_2 = _combine_metadata(
-        metadata_1=metadata_ref,
-        metadata_2=metadata_tst,
-    )
+    factor_names = metadata_ref.factor_names
+    ref_data = metadata_ref.factor_data
+    tst_data = metadata_tst.factor_data
 
-    # Stack discrete and continuous factors as separate factors. Must have equal sample counts
-    ref_data = np.hstack(md_1) if md_1 else np.array([])  # (S, Fd + Fc)
-    tst_data = np.hstack(md_2) if md_2 else np.array([])  # (S, Fd + Fc)
+    _compare_keys(factor_names, metadata_tst.factor_names)
+    _validate_factors_and_data(factor_names, ref_data)
+    _validate_factors_and_data(factor_names, tst_data)
 
     if len(ref_data) < 3:
         warnings.warn(
@@ -256,6 +164,7 @@ which is what many library functions return, multiply it by _NATS2BITS to get it
 """
 
 
+@set_metadata
 def find_ood_predictors(
     metadata: Metadata,
     ood: OODOutput,
@@ -305,8 +214,8 @@ def find_ood_predictors(
 
     ood_mask: NDArray[np.bool_] = ood.is_ood
 
-    discrete_features_count = len(metadata.discrete_factor_names)
-    factors, data = _combine_discrete_continuous(metadata)  # (F, ), (S, F) => F = Fd + Fc
+    factors = metadata.factor_names
+    data = metadata.factor_data
 
     # No metadata correlated with out of distribution data, return 0.0 for all factors
     if not any(ood_mask):
@@ -320,14 +229,13 @@ def find_ood_predictors(
     # Calculate mean, std of each factor over all samples
     scaled_data = (data - np.mean(data, axis=0)) / np.std(data, axis=0, ddof=1)  # (S, F)
 
-    discrete_features = np.zeros_like(factors, dtype=np.bool_)
-    discrete_features[:discrete_features_count] = True
+    discrete_features = [info.factor_type != "continuous" for info in metadata.factor_info.values()]
 
     mutual_info_values = (
         mutual_info_classif(
             X=scaled_data,
             y=ood_mask,
-            discrete_features=discrete_features,  # type: ignore -> sklearn issue - NDArray[bool] not of accepted type Union[ArrayLike, 'auto']
+            discrete_features=discrete_features,  # type: ignore - sklearn function not typed
             random_state=get_seed(),
         )
         * _NATS2BITS