dataeval 0.65.0__py3-none-any.whl → 0.66.0__py3-none-any.whl

dataeval/_internal/metrics/parity.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 import warnings
 from dataclasses import dataclass
-from typing import Dict, Generic, Mapping, Optional, Tuple, TypeVar
+from typing import Generic, Mapping, TypeVar
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -44,8 +46,8 @@ def digitize_factor_bins(continuous_values: NDArray, bins: int, factor_name: str
     -------
     NDArray
         The digitized values
-
     """
+
     if not np.all([np.issubdtype(type(n), np.number) for n in continuous_values]):
         raise TypeError(
             f"Encountered a non-numeric value for factor {factor_name}, but the factor"
@@ -60,8 +62,8 @@ def digitize_factor_bins(continuous_values: NDArray, bins: int, factor_name: str
 
 
 def format_discretize_factors(
-    data_factors: Dict[str, NDArray], continuous_factor_bincounts: Dict[str, int]
-) -> Tuple[Dict[str, NDArray], NDArray]:
+    data_factors: dict[str, NDArray], continuous_factor_bincounts: dict[str, int]
+) -> tuple[dict[str, NDArray], NDArray]:
     """
     Sets up the internal list of metadata factors.
 
@@ -83,6 +85,7 @@ def format_discretize_factors(
           Each key is a metadata factor, whose value is the discrete per-image factor values.
         - Per-image labels, whose ith element is the label for the ith element of the dataset.
     """
+
     invalid_keys = set(continuous_factor_bincounts.keys()) - set(data_factors.keys())
     if invalid_keys:
         raise KeyError(
@@ -114,6 +117,35 @@ def format_discretize_factors(
 
 
 def normalize_expected_dist(expected_dist: NDArray, observed_dist: NDArray) -> NDArray:
+    """
+    Normalize the expected label distribution to match the total number of labels in the observed distribution.
+
+    This function adjusts the expected distribution so that its sum equals the sum of the observed distribution.
+    If the expected distribution is all zeros, an error is raised.
+
+    Parameters
+    ----------
+    expected_dist : np.ndarray
+        The expected label distribution. This array represents the anticipated distribution of labels.
+    observed_dist : np.ndarray
+        The observed label distribution. This array represents the actual distribution of labels in the dataset.
+
+    Returns
+    -------
+    np.ndarray
+        The normalized expected distribution, scaled to have the same sum as the observed distribution.
+
+    Raises
+    ------
+    ValueError
+        If the expected distribution is all zeros.
+
+    Notes
+    -----
+    The function ensures that the total number of labels in the expected distribution matches the total
+    number of labels in the observed distribution by scaling the expected distribution.
+    """
+
     exp_sum = np.sum(expected_dist)
     obs_sum = np.sum(observed_dist)
 
@@ -148,6 +180,7 @@ def validate_dist(label_dist: NDArray, label_name: str):
     Warning
         If any elements of label_dist are less than 5
     """
+
     if not len(label_dist):
         raise ValueError(f"No labels found in the {label_name} dataset")
     if np.any(label_dist < 5):
@@ -159,17 +192,17 @@ def validate_dist(label_dist: NDArray, label_name: str):
 
 
 @set_metadata("dataeval.metrics")
-def parity(
+def label_parity(
     expected_labels: ArrayLike,
     observed_labels: ArrayLike,
-    num_classes: Optional[int] = None,
+    num_classes: int | None = None,
 ) -> ParityOutput[np.float64]:
     """
-    Perform a one-way chi-squared test between observation frequencies and expected frequencies that
-    tests the null hypothesis that the observed data has the expected frequencies.
+    Calculate the chi-square statistic to assess the parity between expected and observed label distributions.
 
-    This function acts as an interface to the scipy.stats.chisquare method, which is documented at
-    https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.chisquare.html
+    This function computes the frequency distribution of classes in both expected and observed labels, normalizes
+    the expected distribution to match the total number of observed labels, and then calculates the chi-square
+    statistic to determine if there is a significant difference between the two distributions.
 
     Parameters
     ----------
@@ -177,9 +210,9 @@ def parity(
         List of class labels in the expected dataset
     observed_labels : ArrayLike
         List of class labels in the observed dataset
-    num_classes : Optional[int]
-        The number of unique classes in the datasets. If this is not specified, it will
-        be inferred from the set of unique labels in expected_labels and observed_labels
+    num_classes : int | None, default None
+        The number of unique classes in the datasets. If not provided, the function will infer it
+        from the set of unique labels in expected_labels and observed_labels
 
     Returns
     -------
@@ -189,8 +222,31 @@ def parity(
     Raises
     ------
     ValueError
-        If x is empty
+        If expected label distribution is empty, is all zeros, or if there is a mismatch in the number
+        of unique classes between the observed and expected distributions.
+
+
+    Notes
+    -----
+    - Providing ``num_classes`` can be helpful if there are classes with zero instances in one of the distributions.
+    - The function first validates the observed distribution and normalizes the expected distribution so that it
+      has the same total number of labels as the observed distribution.
+    - It then performs a chi-square test to determine if there is a statistically significant difference between
+      the observed and expected label distributions.
+    - This function acts as an interface to the scipy.stats.chisquare method, which is documented at
+      https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.chisquare.html
+
+
+    Examples
+    --------
+    Randomly creating some label distributions using ``np.random.default_rng``
+
+    >>> expected_labels = np_random_gen.choice([0, 1, 2, 3, 4], (100))
+    >>> observed_labels = np_random_gen.choice([2, 3, 0, 4, 1], (100))
+    >>> label_parity(expected_labels, observed_labels)
+    ParityOutput(score=14.007374204742625, p_value=0.0072715574616218)
     """
+
     # Calculate
     if not num_classes:
         num_classes = 0
@@ -223,27 +279,27 @@ def parity(
 
 
 @set_metadata("dataeval.metrics")
-def parity_metadata(
+def parity(
     data_factors: Mapping[str, ArrayLike],
-    continuous_factor_bincounts: Optional[Dict[str, int]] = None,
+    continuous_factor_bincounts: dict[str, int] | None = None,
 ) -> ParityOutput[NDArray[np.float64]]:
     """
-    Evaluates the statistical independence of metadata factors from class labels.
-    This performs a chi-square test, which provides a score and a p-value for
-    statistical independence between each pair of a metadata factor and a class label.
-    A high score with a low p-value suggests that a metadata factor is strongly
-    correlated with a class label.
+    Calculate chi-square statistics to assess the relationship between multiple factors and class labels.
+
+    This function computes the chi-square statistic for each metadata factor to determine if there is
+    a significant relationship between the factor values and class labels. The function handles both categorical
+    and discretized continuous factors.
 
     Parameters
     ----------
     data_factors: Mapping[str, ArrayLike]
         The dataset factors, which are per-image attributes including class label and metadata.
         Each key of dataset_factors is a factor, whose value is the per-image factor values.
-    continuous_factor_bincounts : Optional[Dict[str, int]], default None
-        The factors in data_factors that have continuous values and the array of bin counts to
-        discretize values into. All factors are treated as having discrete values unless they
-        are specified as keys in this dictionary. Each element of this array must occur as a key
-        in data_factors.
+    continuous_factor_bincounts : Dict[str, int] | None, default None
+        A dictionary specifying the number of bins for discretizing the continuous factors.
+        The keys should correspond to the names of continuous factors in `data_factors`,
+        and the values should be the number of bins to use for discretization.
+        If not provided, no discretization is applied.
 
     Returns
     -------
@@ -251,7 +307,39 @@ def parity_metadata(
         Arrays of length (num_factors) whose (i)th element corresponds to the
         chi-square score and p-value for the relationship between factor i and
         the class labels in the dataset.
+
+    Raises
+    ------
+    Warning
+        If any cell in the contingency matrix has a value between 0 and 5, a warning is issued because this can
+        lead to inaccurate chi-square calculations. It is recommended to ensure that each label co-occurs with
+        factor values either 0 times or at least 5 times. Alternatively, continuous-valued factors can be digitized
+        into fewer bins.
+
+    Notes
+    -----
+    - Each key of the ``continuous_factor_bincounts`` dictionary must occur as a key in data_factors.
+    - A high score with a low p-value suggests that a metadata factor is strongly correlated with a class label.
+    - The function creates a contingency matrix for each factor, where each entry represents the frequency of a
+      specific factor value co-occurring with a particular class label.
+    - Rows containing only zeros in the contingency matrix are removed before performing the chi-square test
+      to prevent errors in the calculation.
+
+    Examples
+    --------
+    Randomly creating some "continuous" and categorical variables using ``np.random.default_rng``
+
+    >>> data_factors = {
+    ...     "age": np_random_gen.choice([25, 30, 35, 45], (100)),
+    ...     "income": np_random_gen.choice([50000, 65000, 80000], (100)),
+    ...     "gender": np_random_gen.choice(["M", "F"], (100)),
+    ...     "class": np_random_gen.choice([0, 1, 2], (100)),
+    ... }
+    >>> continuous_factor_bincounts = {"age": 4, "income": 3}
+    >>> parity(data_factors, continuous_factor_bincounts)
+    ParityOutput(score=array([2.82329785, 1.60625584, 1.38377236]), p_value=array([0.83067563, 0.80766733, 0.5006309 ]))
     """
+
     data_factors_np = {k: to_numpy(v) for k, v in data_factors.items()}
     continuous_factor_bincounts = continuous_factor_bincounts if continuous_factor_bincounts else {}
 

dataeval/_internal/metrics/stats.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, Iterable, List
+from typing import Any, Callable, Iterable
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -62,8 +64,8 @@ class StatsOutput(OutputMetadata):
         Per-channel mapping of indices for each metric
     """
 
-    xxhash: List[str]
-    pchash: List[str]
+    xxhash: list[str]
+    pchash: list[str]
     width: NDArray[np.uint16]
     height: NDArray[np.uint16]
     channels: NDArray[np.uint8]
@@ -82,7 +84,7 @@ class StatsOutput(OutputMetadata):
     percentiles: NDArray[np.float16]
     histogram: NDArray[np.uint32]
     entropy: NDArray[np.float16]
-    ch_idx_map: Dict[int, List[int]]
+    ch_idx_map: dict[int, list[int]]
 
     def dict(self):
         return {k: v for k, v in self.__dict__.items() if not k.startswith("_") and len(v) > 0}
@@ -90,7 +92,7 @@ class StatsOutput(OutputMetadata):
 
 QUARTILES = (0, 25, 50, 75, 100)
 
-IMAGESTATS_FN_MAP: Dict[ImageStat, Callable[[NDArray], Any]] = {
+IMAGESTATS_FN_MAP: dict[ImageStat, Callable[[NDArray], Any]] = {
     ImageStat.XXHASH: lambda x: xxhash(x),
     ImageStat.PCHASH: lambda x: pchash(x),
     ImageStat.WIDTH: lambda x: np.uint16(x.shape[-1]),
@@ -113,7 +115,7 @@ IMAGESTATS_FN_MAP: Dict[ImageStat, Callable[[NDArray], Any]] = {
     ImageStat.ENTROPY: lambda x: np.float16(entropy(x)),
 }
 
-CHANNELSTATS_FN_MAP: Dict[ImageStat, Callable[[NDArray], Any]] = {
+CHANNELSTATS_FN_MAP: dict[ImageStat, Callable[[NDArray], Any]] = {
     ImageStat.MEAN: lambda x: np.float16(np.mean(x, axis=1)),
     ImageStat.STD: lambda x: np.float16(np.std(x, axis=1)),
     ImageStat.VAR: lambda x: np.float16(np.var(x, axis=1)),
@@ -128,18 +130,62 @@ CHANNELSTATS_FN_MAP: Dict[ImageStat, Callable[[NDArray], Any]] = {
 def run_stats(
     images: Iterable[ArrayLike],
     flags: ImageStat,
-    fn_map: Dict[ImageStat, Callable[[NDArray], Any]],
+    fn_map: dict[ImageStat, Callable[[NDArray], Any]],
     flatten: bool,
 ):
+    """
+    Compute specified statistics on a set of images.
+
+    This function applies a set of statistical operations to each image in the input iterable,
+    based on the specified flags. The function dynamically determines which statistics to apply
+    using a flag system and a corresponding function map. It also supports optional image
+    flattening for pixel-wise calculations.
+
+    Parameters
+    ----------
+    images : ArrayLike
+        An iterable of images (e.g., list of arrays), where each image is represented as an
+        array-like structure (e.g., NumPy arrays).
+    flags : ImageStat
+        A bitwise flag or set of flags specifying the statistics to compute for each image.
+        These flags determine which functions in `fn_map` to apply.
+    fn_map : dict[ImageStat, Callable]
+        A dictionary mapping `ImageStat` flags to functions that compute the corresponding statistics.
+        Each function accepts a NumPy array (representing an image or rescaled pixel data) and returns a result.
+    flatten : bool
+        If True, the image is flattened into a 2D array for pixel-wise operations. Otherwise, the
+        original image dimensions are preserved.
+
+    Returns
+    -------
+    list[dict[str, NDArray]]
+        A list of dictionaries, where each dictionary contains the computed statistics for an image.
+        The dictionary keys correspond to the names of the statistics, and the values are NumPy arrays
+        with the results of the computations.
+
+    Raises
+    ------
+    ValueError
+        If unsupported flags are provided that are not present in `fn_map`.
+
+    Notes
+    -----
+    - The function performs image normalization (rescaling the image values)
+      before applying some of the statistics.
+    - Pixel-level statistics (e.g., brightness, entropy) are computed after
+      rescaling and, optionally, flattening the images.
+    - For statistics like histograms and entropy, intermediate results may
+      be reused to avoid redundant computation.
+    """
     verify_supported(flags, fn_map)
     flag_dict = to_distinct(flags)
 
-    results_list: List[Dict[str, NDArray]] = []
+    results_list: list[dict[str, NDArray]] = []
     for image in to_numpy_iter(images):
         normalized = normalize_image_shape(image)
         scaled = None
         hist = None
-        output: Dict[str, NDArray] = {}
+        output: dict[str, NDArray] = {}
         for flag, stat in flag_dict.items():
             if flag & (ImageStat.ALL_PIXELSTATS | ImageStat.BRIGHTNESS):
                 if scaled is None:
@@ -161,16 +207,53 @@ def imagestats(images: Iterable[ArrayLike], flags: ImageStat = ImageStat.ALL_STA
     """
     Calculates image and pixel statistics for each image
 
+    This function computes various statistical metrics (e.g., mean, standard deviation, entropy)
+    on the images as a whole, based on the specified flags. It supports multiple types of statistics
+    that can be selected using the `flags` argument.
+
     Parameters
     ----------
-    images : Iterable[ArrayLike]
+    images : ArrayLike
         Images to run statistical tests on
     flags : ImageStat, default ImageStat.ALL_STATS
-        Metric(s) to calculate for each image
+        Metric(s) to calculate for each image. The default flag ``ImageStat.ALL_STATS``
+        computes all available statistics.
 
     Returns
     -------
-    Dict[str, Any]
+    StatsOutput
+        A dictionary-like object containing the computed statistics for each image. The keys correspond
+        to the names of the statistics (e.g., 'mean', 'std'), and the values are lists of results for
+        each image or numpy arrays when the results are multi-dimensional.
+
+    Notes
+    -----
+    - All metrics in the ImageStat.ALL_PIXELSTATS flag are scaled based on the perceived bit depth
+      (which is derived from the largest pixel value) to allow for better comparison
+      between images stored in different formats and different resolutions.
+    - ImageStat.ZERO and ImageStat.MISSING are presented as a percentage of total pixel counts
+
+    Examples
+    --------
+    Calculating the statistics on the images, whose shape is (C, H, W)
+
+    >>> results = imagestats(images, flags=ImageStat.MEAN | ImageStat.ALL_VISUALS)
+    >>> print(results.mean)
+    [0.16650391 0.52050781 0.05471802 0.07702637 0.09875488 0.12188721
+     0.14440918 0.16711426 0.18859863 0.21264648 0.2355957  0.25854492
+     0.27978516 0.3046875  0.32788086 0.35131836 0.37255859 0.39819336
+     0.42163086 0.4453125  0.46630859 0.49267578 0.51660156 0.54052734
+     0.56152344 0.58837891 0.61230469 0.63671875 0.65771484 0.68505859
+     0.70947266 0.73388672 0.75488281 0.78271484 0.80712891 0.83203125
+     0.85302734 0.88134766 0.90625    0.93115234]
+    >>> print(results.zero)
+    [0.12561035 0.         0.         0.         0.11730957 0.
+     0.         0.         0.10986328 0.         0.         0.
+     0.10266113 0.         0.         0.         0.09570312 0.
+     0.         0.         0.08898926 0.         0.         0.
+     0.08251953 0.         0.         0.         0.07629395 0.
+     0.         0.         0.0703125  0.         0.         0.
+     0.0645752  0.         0.         0.        ]
     """
     stats = run_stats(images, flags, IMAGESTATS_FN_MAP, False)
     output = {}
@@ -190,17 +273,72 @@ def channelstats(images: Iterable[ArrayLike], flags=ImageStat.ALL_PIXELSTATS) ->
     """
     Calculates pixel statistics for each image per channel
 
+    This function computes pixel-level statistics (e.g., mean, variance, etc.) on a per-channel basis
+    for each image. The statistics can be selected using the `flags` argument, and the results will
+    be grouped by the number of channels (e.g., RGB channels) in each image.
+
     Parameters
     ----------
-    images : Iterable[ArrayLike]
+    images : ArrayLike
         Images to run statistical tests on
     flags: ImageStat, default ImageStat.ALL_PIXELSTATS
-        Statistic(s) to calculate for each image per channel
-        Only flags in the ImageStat.ALL_PIXELSTATS category are supported
+        Metric(s) to calculate for each image per channel.
+        Only flags within the ``ImageStat.ALL_PIXELSTATS`` category are supported.
 
     Returns
     -------
-    Dict[str, Any]
+    StatsOutput
+        A dictionary-like object containing the computed statistics for each image per channel. The keys
+        correspond to the names of the statistics (e.g., 'mean', 'variance'), and the values are numpy arrays
+        with results for each channel of each image.
+
+    Notes
+    -----
+    - All metrics in the ImageStat.ALL_PIXELSTATS flag are scaled based on the perceived bit depth
+      (which is derived from the largest pixel value) to allow for better comparison
+      between images stored in different formats and different resolutions.
+
+    Examples
+    --------
+    Calculating the statistics on a per channel basis for images, whose shape is (N, C, H, W)
+
+    >>> results = channelstats(images, flags=ImageStat.MEAN | ImageStat.VAR)
+    >>> print(results.mean)
+    {3: array([[0.01617, 0.5303 , 0.06525, 0.09735, 0.1295 , 0.1616 , 0.1937 ,
+            0.2258 , 0.2578 , 0.29   , 0.322  , 0.3542 , 0.3865 , 0.4185 ,
+            0.4507 , 0.4827 , 0.5146 , 0.547  , 0.579  , 0.6113 , 0.643  ,
+            0.6753 , 0.7075 , 0.7397 , 0.7715 , 0.8037 , 0.836  , 0.868  ,
+            0.9004 , 0.932  ],
+           [0.04828, 0.562  , 0.06726, 0.09937, 0.1315 , 0.1636 , 0.1957 ,
+            0.2278 , 0.26   , 0.292  , 0.3242 , 0.3562 , 0.3884 , 0.4204 ,
+            0.4526 , 0.4846 , 0.5166 , 0.549  , 0.581  , 0.6133 , 0.6455 ,
+            0.6772 , 0.7095 , 0.7417 , 0.774  , 0.8057 , 0.838  , 0.87   ,
+            0.9023 , 0.934  ],
+           [0.0804 , 0.594  , 0.0693 , 0.1014 , 0.1334 , 0.1656 , 0.1978 ,
+            0.2299 , 0.262  , 0.294  , 0.3262 , 0.3584 , 0.3904 , 0.4226 ,
+            0.4546 , 0.4868 , 0.519  , 0.551  , 0.583  , 0.615  , 0.6475 ,
+            0.679  , 0.7114 , 0.7437 , 0.776  , 0.808  , 0.84   , 0.872  ,
+            0.9043 , 0.9365 ]], dtype=float16)}
+    >>> print(results.var)
+    {3: array([[0.00010103, 0.01077   , 0.0001621 , 0.0003605 , 0.0006375 ,
+            0.000993  , 0.001427  , 0.001939  , 0.00253   , 0.003199  ,
+            0.003944  , 0.004772  , 0.005676  , 0.006657  , 0.007717  ,
+            0.00886   , 0.01008   , 0.01137   , 0.01275   , 0.0142    ,
+            0.01573   , 0.01733   , 0.01903   , 0.0208    , 0.02264   ,
+            0.02457   , 0.02657   , 0.02864   , 0.0308    , 0.03305   ],
+           [0.0001798 , 0.0121    , 0.0001721 , 0.0003753 , 0.0006566 ,
+            0.001017  , 0.001455  , 0.001972  , 0.002565  , 0.003239  ,
+            0.00399   , 0.00482   , 0.00573   , 0.006714  , 0.007782  ,
+            0.00893   , 0.01015   , 0.011444  , 0.012825  , 0.01428   ,
+            0.01581   , 0.01743   , 0.01912   , 0.02089   , 0.02274   ,
+            0.02466   , 0.02667   , 0.02875   , 0.03091   , 0.03314   ],
+           [0.000337  , 0.0135    , 0.0001824 , 0.0003903 , 0.0006766 ,
+            0.00104   , 0.001484  , 0.002005  , 0.002604  , 0.00328   ,
+            0.004036  , 0.00487   , 0.005783  , 0.006775  , 0.00784   ,
+            0.00899   , 0.010216  , 0.01152   , 0.0129    , 0.01436   ,
+            0.0159    , 0.01752   , 0.01921   , 0.02098   , 0.02283   ,
+            0.02477   , 0.02676   , 0.02885   , 0.03102   , 0.03326   ]],
+          dtype=float16)}
     """
     stats = run_stats(images, flags, CHANNELSTATS_FN_MAP, True)
 

dataeval/_internal/metrics/uap.py

@@ -40,13 +40,39 @@ def uap(labels: ArrayLike, scores: ArrayLike) -> UAPOutput:
 
     Returns
     -------
-    Dict[str, float]
-        uap : The empirical mean precision estimate
+    UAPOutput
+        The empirical mean precision estimate, float
 
     Raises
     ------
     ValueError
         If unique classes M < 2
+
+    Notes
+    -----
+    This function calculates the empirical mean precision using the
+    ``average_precision_score`` from scikit-learn, weighted by the class distribution.
+
+    Examples
+    --------
+    >>> y_true = np.array([0, 0, 1, 1])
+    >>> y_scores = np.array([0.1, 0.4, 0.35, 0.8])
+    >>> uap(y_true, y_scores)
+    UAPOutput(uap=0.8333333333333333)
+
+    >>> y_true = np.array([0, 0, 1, 1, 2, 2])
+    >>> y_scores = np.array(
+    ...     [
+    ...         [0.7, 0.2, 0.1],
+    ...         [0.4, 0.3, 0.3],
+    ...         [0.1, 0.8, 0.1],
+    ...         [0.2, 0.3, 0.5],
+    ...         [0.4, 0.4, 0.2],
+    ...         [0.1, 0.2, 0.7],
+    ...     ]
+    ... )
+    >>> uap(y_true, y_scores)
+    UAPOutput(uap=0.7777777777777777)
     """
 
     precision = float(average_precision_score(to_numpy(labels), to_numpy(scores), average="weighted"))

dataeval/_internal/metrics/utils.py

@@ -1,4 +1,6 @@
-from typing import Any, Callable, Dict, List, Literal, NamedTuple, Optional, Sequence, Tuple, Union
+from __future__ import annotations
+
+from typing import Any, Callable, Literal, NamedTuple, Sequence
 
 import numpy as np
 import xxhash as xxh
@@ -19,22 +21,22 @@ HASH_SIZE = 8
 MAX_FACTOR = 4
 
 
-def get_method(method_map: Dict[str, Callable], method: str) -> Callable:
+def get_method(method_map: dict[str, Callable], method: str) -> Callable:
     if method not in method_map:
         raise ValueError(f"Specified method {method} is not a valid method: {method_map}.")
     return method_map[method]
 
 
 def get_counts(
-    data: NDArray, names: List[str], is_categorical: List[bool], subset_mask: Optional[NDArray[np.bool_]] = None
-) -> tuple[Dict, Dict]:
+    data: NDArray, names: list[str], is_categorical: list[bool], subset_mask: NDArray[np.bool_] | None = None
+) -> tuple[dict, dict]:
     """
     Initialize dictionary of histogram counts --- treat categorical values
     as histogram bins.
 
     Parameters
     ----------
-    subset_mask: Optional[NDArray[np.bool_]]
+    subset_mask: NDArray[np.bool_] | None
         Boolean mask of samples to bin (e.g. when computing per class).  True -> include in histogram counts
 
     Returns
@@ -68,10 +70,10 @@ def get_counts(
 
 def entropy(
     data: NDArray,
-    names: List[str],
-    is_categorical: List[bool],
+    names: list[str],
+    is_categorical: list[bool],
     normalized: bool = False,
-    subset_mask: Optional[NDArray[np.bool_]] = None,
+    subset_mask: NDArray[np.bool_] | None = None,
 ) -> NDArray[np.float64]:
     """
     Meant for use with Bias metrics, Balance, Diversity, ClasswiseBalance,
@@ -84,7 +86,7 @@ def entropy(
     ----------
     normalized: bool
         Flag that determines whether or not to normalize entropy by log(num_bins)
-    subset_mask: Optional[NDArray[np.bool_]]
+    subset_mask: NDArray[np.bool_] | None
         Boolean mask of samples to bin (e.g. when computing per class).  True -> include in histogram counts
 
     Notes
@@ -120,7 +122,7 @@ def entropy(
 
 
 def get_num_bins(
-    data: NDArray, names: List[str], is_categorical: List[bool], subset_mask: Optional[NDArray[np.bool_]] = None
+    data: NDArray, names: list[str], is_categorical: list[bool], subset_mask: NDArray[np.bool_] | None = None
 ) -> NDArray[np.float64]:
     """
     Number of bins or unique values for each metadata factor, used to
@@ -128,7 +130,7 @@ def get_num_bins(
 
     Parameters
     ----------
-    subset_mask: Optional[NDArray[np.bool_]]
+    subset_mask: NDArray[np.bool_] | None
         Boolean mask of samples to bin (e.g. when computing per class).  True -> include in histogram counts
 
     Returns
@@ -144,7 +146,7 @@ def get_num_bins(
     return num_bins
 
 
-def infer_categorical(X: NDArray, threshold: float = 0.5) -> NDArray:
+def infer_categorical(X: NDArray, threshold: float = 0.2) -> NDArray:
     """
     Compute fraction of feature values that are unique --- intended to be used
     for inferring whether variables are categorical.
@@ -160,10 +162,10 @@ def infer_categorical(X: NDArray, threshold: float = 0.5) -> NDArray:
 
 
 def preprocess_metadata(
-    class_labels: Sequence[int], metadata: List[Dict], cat_thresh: float = 0.2
-) -> Tuple[NDArray, List[str], List[bool]]:
+    class_labels: Sequence[int], metadata: list[dict], cat_thresh: float = 0.2
+) -> tuple[NDArray, list[str], list[bool]]:
     # convert class_labels and list of metadata dicts to dict of ndarrays
-    metadata_dict: Dict[str, NDArray] = {
+    metadata_dict: dict[str, NDArray] = {
         "class_label": np.asarray(class_labels, dtype=int),
         **{k: np.array([d[k] for d in metadata]) for k in metadata[0]},
     }
@@ -223,7 +225,7 @@ def minimum_spanning_tree(X: NDArray) -> Any:
     return mst(eudist_csr)
 
 
-def get_classes_counts(labels: NDArray) -> Tuple[int, int]:
+def get_classes_counts(labels: NDArray) -> tuple[int, int]:
     """
     Returns the classes and counts of from an array of labels
 
@@ -303,8 +305,8 @@ def compute_neighbors(
 
 class BitDepth(NamedTuple):
     depth: int
-    pmin: Union[float, int]
-    pmax: Union[float, int]
+    pmin: float | int
+    pmax: float | int
 
 
 def get_bitdepth(image: NDArray) -> BitDepth: