nnInteractive 2.0.0__py3-none-any.whl

nnInteractive/interaction/point.py

@@ -0,0 +1,166 @@
+from functools import lru_cache
+from typing import Tuple, Optional
+
+import numpy as np
+import torch
+from batchgeneratorsv2.helpers.scalar_type import sample_scalar, RandomScalar
+from scipy.ndimage import distance_transform_edt
+from skimage.morphology import disk, ball
+
+
+@lru_cache(maxsize=5)
+def build_point(radii, use_distance_transform, binarize):
+    max_radius = max(radii)
+    ndim = len(radii)
+
+    # Create a spherical (or circular) structuring element with max_radius
+    if ndim == 2:
+        structuring_element = disk(max_radius)
+    elif ndim == 3:
+        structuring_element = ball(max_radius)
+    else:
+        raise ValueError("Unsupported number of dimensions. Only 2D and 3D are supported.")
+
+    # Convert the structuring element to a tensor
+    structuring_element = torch.from_numpy(structuring_element.astype(np.float32))
+
+    # Create the target shape based on the sampled radii
+    target_shape = [round(2 * r + 1) for r in radii]
+
+    if any([i != j for i, j in zip(target_shape, structuring_element.shape)]):
+        structuring_element_resized = torch.nn.functional.interpolate(
+            structuring_element.unsqueeze(0).unsqueeze(0),  # Add batch and channel dimensions for interpolation
+            size=target_shape,
+            mode="trilinear" if ndim == 3 else "bilinear",
+            align_corners=False,
+        )[
+            0, 0
+        ]  # Remove batch and channel dimensions after interpolation
+    else:
+        structuring_element_resized = structuring_element
+
+    if use_distance_transform:
+        # Convert the structuring element to a binary mask for distance transform computation
+        binary_structuring_element = (structuring_element_resized >= 0.5).numpy()
+
+        # Compute the Euclidean distance transform of the binary structuring element
+        structuring_element_resized = distance_transform_edt(binary_structuring_element)
+
+        # Normalize the distance transform to have values between 0 and 1
+        structuring_element_resized /= structuring_element_resized.max()
+        structuring_element_resized = torch.from_numpy(structuring_element_resized)
+
+    if binarize and not use_distance_transform:
+        # Normalize the resized structuring element to binary (values near 1 are treated as the point region)
+        structuring_element_resized = (structuring_element_resized >= 0.5).float()
+    return structuring_element_resized
+
+
+class PointInteraction_stub:
+    interaction_type = "point"
+
+    def __init__(self, point_radius: RandomScalar, use_distance_transform: bool = False):
+        """
+        Initializes the PointInteraction object.
+
+        Parameters:
+        point_radius (RandomScalar): Specifies the radius for the interaction points.
+        use_distance_transform (bool): Determines whether to use a distance transform for smooth interactions.
+        """
+        super().__init__()
+        self.point_radius = point_radius
+        self.use_distance_transform = use_distance_transform
+
+    def place_point(
+        self,
+        position: Tuple[int, ...],
+        interaction_map,
+        binarize: bool = False,
+        intensity_scale: float = 1.0,
+        channel_idx: Optional[int] = None,
+    ) -> torch.Tensor:
+        """
+        Places a point on the interaction map around the specified position.
+
+        Parameters:
+        position (Tuple[int, ...]): The (x, y, z) coordinates where the point should be placed.
+        interaction_map: A tensor (or blosc2 NDArray when channel_idx is provided) representing
+                         the interaction map where the point should be placed.
+        binarize (bool): If True, inserts a binary mask. If False, may insert smooth values based on distance.
+        intensity_scale (float): Scale factor applied to the structuring element values.
+        channel_idx (int, optional): If provided, interaction_map is treated as a 4D blosc2 NDArray
+                                     and only the structuring element subregion is read/written for
+                                     channel channel_idx. Avoids decompressing the full channel.
+
+        Returns:
+        The updated interaction map (torch.Tensor for the default path; blosc2 NDArray for channel_idx path).
+        """
+        if channel_idx is not None:
+            # blosc2 path: interaction_map is the full 4D NDArray; channel_idx selects the channel.
+            spatial_shape = interaction_map.shape[1:]
+            ndim = len(spatial_shape)
+
+            radius = tuple([sample_scalar(self.point_radius, d, spatial_shape) for d in range(ndim)])
+            strel = build_point(radius, self.use_distance_transform, binarize)
+            if intensity_scale != 1.0:
+                strel = strel * intensity_scale
+
+            bbox = [
+                [position[i] - strel.shape[i] // 2, position[i] + strel.shape[i] // 2 + strel.shape[i] % 2]
+                for i in range(ndim)
+            ]
+
+            # detect if bbox is completely outside interaction_map
+            if any(i[1] < 0 for i in bbox) or any(i[0] > s for i, s in zip(bbox, spatial_shape)):
+                print("Point is outside the interaction map! Ignoring")
+                print(f"Position: {position}")
+                print(f"Interaction map shape: {spatial_shape}")
+                print(f"Point bbox would have been {bbox}")
+                return interaction_map
+
+            slices = tuple(slice(max(0, bbox[i][0]), min(spatial_shape[i], bbox[i][1])) for i in range(ndim))
+            structuring_slices = tuple(
+                slice(max(0, -bbox[i][0]), slices[i].stop - slices[i].start + max(0, -bbox[i][0])) for i in range(ndim)
+            )
+
+            target_slices = (channel_idx, *slices)
+            current_sub = np.asarray(interaction_map[target_slices])
+            strel_np = strel[structuring_slices].numpy().astype(current_sub.dtype)
+            np.maximum(current_sub, strel_np, out=current_sub)
+            interaction_map[target_slices] = current_sub
+            return interaction_map
+
+        # Default torch path: interaction_map is a 3D tensor for a single channel.
+        ndim = interaction_map.ndim
+
+        # Determine the radius for each dimension
+        radius = tuple([sample_scalar(self.point_radius, d, interaction_map.shape) for d in range(ndim)])
+
+        strel = build_point(radius, self.use_distance_transform, binarize)
+        if intensity_scale != 1.0:
+            strel = strel * intensity_scale
+
+        # Calculate slice range in each dimension, ensuring it is within the bounds of the interaction map
+        bbox = [
+            [position[i] - strel.shape[i] // 2, position[i] + strel.shape[i] // 2 + strel.shape[i] % 2]
+            for i in range(ndim)
+        ]
+        # detect if bbox is completely outside interaction_map
+        if any([i[1] < 0 for i in bbox]) or any([i[0] > s for i, s in zip(bbox, interaction_map.shape)]):
+            print("Point is outside the interaction map! Ignoring")
+            print(f"Position: {position}")
+            print(f"Interaction map shape: {interaction_map.shape}")
+            print(f"Point bbox would have been {bbox}")
+            return interaction_map
+        slices = tuple(slice(max(0, bbox[i][0]), min(interaction_map.shape[i], bbox[i][1])) for i in range(ndim))
+
+        # Calculate where the resized structuring element should be placed within the slices
+        structuring_slices = tuple(
+            [slice(max(0, -bbox[i][0]), slices[i].stop - slices[i].start + max(0, -bbox[i][0])) for i in range(ndim)]
+        )
+
+        # Place the resized structuring element into the interaction map
+        torch.maximum(
+            interaction_map[slices], strel[structuring_slices].to(interaction_map.device), out=interaction_map[slices]
+        )
+        return interaction_map

nnInteractive/supervoxel/setup.py

@@ -0,0 +1,4 @@
+import setuptools
+
+if __name__ == "__main__":
+    setuptools.setup()

nnInteractive/supervoxel/src/metadata.py

@@ -0,0 +1,118 @@
+import pandas as pd
+import numpy as np
+import math
+import pickle as pkl
+import os
+from tqdm import tqdm
+
+from reader import BloscReaderWriter
+from typing import List, Tuple, Union
+import multiprocessing as mp
+from functools import partial
+
+
+def sample_foreground_locations(
+    seg: np.ndarray,
+    classes_or_regions: Union[List[int], List[Tuple[int, ...]]],
+    seed: int = 1234,
+    verbose: bool = False,
+):
+    num_samples = 100
+    # sparse
+    rndst = np.random.RandomState(seed)
+    class_locs = {}
+    foreground_mask = seg != 0
+    foreground_coords = np.argwhere(foreground_mask)
+    seg = seg[foreground_mask]
+    del foreground_mask
+    unique_labels = pd.unique(seg.ravel())
+
+    # We don't need more than 1e7 foreground samples. That's insanity. Cap here
+    if len(foreground_coords) > 1e7:
+        take_every = math.floor(len(foreground_coords) / 1e7)
+        # keep computation time reasonable
+        if verbose:
+            print(f"Subsampling foreground pixels 1:{take_every} for computational reasons")
+        foreground_coords = foreground_coords[::take_every]
+        seg = seg[::take_every]
+
+    for c in classes_or_regions:
+        k = c if not isinstance(c, list) else tuple(c)
+
+        # check if any of the labels are in seg, if not skip c
+        if isinstance(c, (tuple, list)):
+            if not any([ci in unique_labels for ci in c]):
+                class_locs[k] = []
+                continue
+        else:
+            if c not in unique_labels:
+                class_locs[k] = []
+                continue
+
+        if isinstance(c, (tuple, list)):
+            mask = seg == c[0]
+            for cc in c[1:]:
+                mask = mask | (seg == cc)
+            all_locs = foreground_coords[mask]
+        else:
+            mask = seg == c
+            all_locs = foreground_coords[mask]
+        if len(all_locs) == 0:
+            class_locs[k] = []
+            continue
+        target_num_samples = min(num_samples, len(all_locs))
+
+        selected = all_locs[rndst.choice(len(all_locs), target_num_samples, replace=False)]
+        class_locs[k] = selected
+        if verbose:
+            print(c, target_num_samples)
+        seg = seg[~mask]
+        foreground_coords = foreground_coords[~mask]
+    return class_locs
+
+
+def process_file(file, supervoxel_folder, bloscio):
+    out_file = os.path.join(supervoxel_folder, file.replace(".b2nd", ".pkl"))
+
+    if os.path.exists(out_file):
+        return
+
+    # Load the supervoxel file
+    supervoxel_arr, _ = bloscio.read(os.path.join(supervoxel_folder, file))
+
+    assert supervoxel_arr.ndim == 4, "The supervoxel array should have 4 dimensions, failed for file: " + file
+
+    all_class_locs = []
+    for submask in supervoxel_arr:
+        assert submask.ndim == 3, "The submask should have 3 dimensions, failed for file: " + file
+        all_class_locs.append(sample_foreground_locations(submask, [1]))
+
+    # Save the foreground locations
+    with open(out_file, "wb") as f:
+        pkl.dump(all_class_locs, f)
+
+
+def generate_fg_locations(supervoxel_folder, num_processes=4):
+    """
+    Generate the foreground locations for the supervoxels
+
+    Parameters:
+        supervoxel_folder (str): The path to the folder containing the supervoxel files
+    """
+    bloscio = BloscReaderWriter()
+    # Load the supervoxel files
+    supervoxel_files = [f for f in os.listdir(supervoxel_folder) if f.endswith(".b2nd")]
+
+    if num_processes == 1:
+        for file in tqdm(supervoxel_files):
+            process_file(file, supervoxel_folder, bloscio)
+    else:
+        with mp.Pool(num_processes) as pool:
+            list(
+                tqdm(
+                    pool.imap(
+                        partial(process_file, supervoxel_folder=supervoxel_folder, bloscio=bloscio), supervoxel_files
+                    ),
+                    total=len(supervoxel_files),
+                )
+            )

nnInteractive/supervoxel/src/reader.py

@@ -0,0 +1,175 @@
+from copy import deepcopy
+import math
+from typing import Tuple, Union
+import SimpleITK as sitk
+import numpy as np
+import blosc2
+
+
+class NfitiReaderWriter:
+    def __init__(self):
+        """
+        NfitiReaderWriter class constructor. This class is responsible for reading and writing nifti files.
+        """
+
+    def read(self, image_path: str):
+        """
+        Read the image file.
+
+        Returns:
+            sitk_image (SimpleITK.Image): The image object.
+        """
+        sitk_image = sitk.ReadImage(image_path)
+        array = sitk.GetArrayFromImage(sitk_image)
+        return array, sitk_image
+
+    def write(self, array: np.ndarray, sitk_image: sitk.Image, output_path: str):
+        """
+        Write the image file.
+
+        Parameters:
+            sitk_image (SimpleITK.Image): The image object.
+            output_path (str): The path to save the image file.
+        """
+        out_image = sitk.GetImageFromArray(array)
+        out_image.SetDirection(sitk_image.GetDirection())
+        out_image.SetOrigin(sitk_image.GetOrigin())
+        out_image.SetSpacing(sitk_image.GetSpacing())
+        sitk.WriteImage(out_image, output_path)
+
+
+class BloscReaderWriter:
+    def __init__(self):
+        """
+        BloscReaderWriter class constructor. This class is responsible for reading and writing blosc files.
+        """
+        blosc2.set_nthreads(1)
+
+    def read(self, image_path: str):
+        """
+        Read the image file.
+
+        Returns:
+            array (np.ndarray): The image array.
+        """
+        dparams = {"nthreads": 1}
+        im = blosc2.open(urlpath=image_path, mode="r", dparams=dparams, mmap_mode="r")
+        return im[:], None
+
+    def write(self, array: np.ndarray, properties, output_path: str):
+        """
+        Write the image file.
+
+        Parameters:
+            array (np.ndarray): The image array.
+            properties: Unused
+            output_path (str): The path to save the image file.
+        """
+        cparams = {
+            "codec": blosc2.Codec.ZSTD,
+            # 'filters': [blosc2.Filter.SHUFFLE],
+            # 'splitmode': blosc2.SplitMode.ALWAYS_SPLIT,
+            "clevel": 8,
+        }
+        chunks, blocks = None, None  # self.comp_blosc2_params(array.shape, [192, 192, 192], array.itemsize)
+        # print(output_filename_truncated, data.shape, seg.shape, blocks, chunks, blocks_seg, chunks_seg, data.dtype, seg.dtype)
+        blosc2.asarray(
+            np.ascontiguousarray(array),
+            urlpath=output_path,
+            chunks=chunks,
+            blocks=blocks,
+            cparams=cparams,
+            mmap_mode="w+",
+        )
+
+    def comp_blosc2_params(
+        self,
+        image_size: Tuple[int, int, int, int],
+        patch_size: Union[Tuple[int, int], Tuple[int, int, int]],
+        bytes_per_pixel: int = 4,  # 4 byte are float32
+        l1_cache_size_per_core_in_bytes=32768,  # 1 Kibibyte (KiB) = 2^10 Byte;  32 KiB = 32768 Byte
+        l3_cache_size_per_core_in_bytes=1441792,
+        # 1 Mibibyte (MiB) = 2^20 Byte = 1.048.576 Byte; 1.375MiB = 1441792 Byte
+        safety_factor: float = 0.8,  # we dont will the caches to the brim. 0.8 means we target 80% of the caches
+    ):
+        """
+        Computes a recommended block and chunk size for saving arrays with blosc v2.
+
+        Bloscv2 NDIM doku: "Remember that having a second partition means that we have better flexibility to fit the
+        different partitions at the different CPU cache levels; typically the first partition (aka chunks) should
+        be made to fit in L3 cache, whereas the second partition (aka blocks) should rather fit in L2/L1 caches
+        (depending on whether compression ratio or speed is desired)."
+        (https://www.blosc.org/posts/blosc2-ndim-intro/)
+        -> We are not 100% sure how to optimize for that. For now we try to fit the uncompressed block in L1. This
+        might spill over into L2, which is fine in our books.
+
+        Note: this is optimized for nnU-Net dataloading where each read operation is done by one core. We cannot use threading
+
+        Cache default values computed based on old Intel 4110 CPU with 32K L1, 128K L2 and 1408K L3 cache per core.
+        We cannot optimize further for more modern CPUs with more cache as the data will need be be read by the
+        old ones as well.
+
+        Args:
+            patch_size: Image size, must be 4D (c, x, y, z). For 2D images, make x=1
+            patch_size: Patch size, spatial dimensions only. So (x, y) or (x, y, z)
+            bytes_per_pixel: Number of bytes per element. Example: float32 -> 4 bytes
+            l1_cache_size_per_core_in_bytes: The size of the L1 cache per core in Bytes.
+            l3_cache_size_per_core_in_bytes: The size of the L3 cache exclusively accessible by each core. Usually the global size of the L3 cache divided by the number of cores.
+
+        Returns:
+            The recommended block and the chunk size.
+        """
+        # Fabians code is ugly, but eh
+
+        num_channels = image_size[0]
+        if len(patch_size) == 2:
+            patch_size = [1, *patch_size]
+        patch_size = np.array(patch_size)
+        block_size = np.array((num_channels, *[2 ** (max(0, math.ceil(math.log2(i)))) for i in patch_size]))
+
+        # shrink the block size until it fits in L1
+        estimated_nbytes_block = np.prod(block_size) * bytes_per_pixel
+        while estimated_nbytes_block > (l1_cache_size_per_core_in_bytes * safety_factor):
+            # pick largest deviation from patch_size that is not 1
+            axis_order = np.argsort(block_size[1:] / patch_size)[::-1]
+            idx = 0
+            picked_axis = axis_order[idx]
+            while block_size[picked_axis + 1] == 1 or block_size[picked_axis + 1] == 1:
+                idx += 1
+                picked_axis = axis_order[idx]
+            # now reduce that axis to the next lowest power of 2
+            block_size[picked_axis + 1] = 2 ** (max(0, math.floor(math.log2(block_size[picked_axis + 1] - 1))))
+            block_size[picked_axis + 1] = min(block_size[picked_axis + 1], image_size[picked_axis + 1])
+            estimated_nbytes_block = np.prod(block_size) * bytes_per_pixel
+
+        block_size = np.array([min(i, j) for i, j in zip(image_size, block_size)])
+
+        # note: there is no use extending the chunk size to 3d when we have a 2d patch size! This would unnecessarily
+        # load data into L3
+        # now tile the blocks into chunks until we hit image_size or the l3 cache per core limit
+        chunk_size = deepcopy(block_size)
+        estimated_nbytes_chunk = np.prod(chunk_size) * bytes_per_pixel
+        while estimated_nbytes_chunk < (l3_cache_size_per_core_in_bytes * safety_factor):
+            if patch_size[0] == 1 and all([i == j for i, j in zip(chunk_size[2:], image_size[2:])]):
+                break
+            if all([i == j for i, j in zip(chunk_size, image_size)]):
+                break
+            # find axis that deviates from block_size the most
+            axis_order = np.argsort(chunk_size[1:] / block_size[1:])
+            idx = 0
+            picked_axis = axis_order[idx]
+            while chunk_size[picked_axis + 1] == image_size[picked_axis + 1] or patch_size[picked_axis] == 1:
+                idx += 1
+                picked_axis = axis_order[idx]
+            chunk_size[picked_axis + 1] += block_size[picked_axis + 1]
+            chunk_size[picked_axis + 1] = min(chunk_size[picked_axis + 1], image_size[picked_axis + 1])
+            estimated_nbytes_chunk = np.prod(chunk_size) * bytes_per_pixel
+            if np.mean([i / j for i, j in zip(chunk_size[1:], patch_size)]) > 1.5:
+                # chunk size should not exceed patch size * 1.5 on average
+                chunk_size[picked_axis + 1] -= block_size[picked_axis + 1]
+                break
+        # better safe than sorry
+        chunk_size = [min(i, j) for i, j in zip(image_size, chunk_size)]
+
+        # print(image_size, chunk_size, block_size)
+        return tuple(block_size), tuple(chunk_size)

nnInteractive/supervoxel/src/run.py

@@ -0,0 +1,136 @@
+import os
+import yaml
+import argparse
+from typing import List, Tuple
+import numpy as np
+from supervoxel import SuperVoxelGenerator
+from metadata import generate_fg_locations
+from tqdm import tqdm
+import torch
+import gc
+
+
+def list_and_clear_tensors_on_gpu():
+
+    gpu_tensors = []  # Collect GPU tensors to analyze them
+    tensor_sizes = []  # Collect tensor sizes to analyze them
+
+    for obj in gc.get_objects():
+        try:
+            if torch.is_tensor(obj) and obj.is_cuda:
+                print(f"Tensor: {type(obj)}, size: {obj.size()}, device: {obj.device}")
+                gpu_tensors.append(obj)
+                tensor_sizes.append(obj.nbytes)
+        except Exception as e:
+            pass  # Handle any inspection errors
+
+    # Delete all tensors found
+    print(f"Found {len(gpu_tensors)} tensors on GPU.")
+    bytes_sum = sum(tensor_sizes)
+    print(f"Total size: {bytes_sum / 1024 ** 3} GB")
+    for tensor in gpu_tensors:
+        del tensor  # Remove local references to the tensors
+
+    # Trigger garbage collection
+    gc.collect()
+
+    # Empty CUDA cache
+    torch.cuda.empty_cache()
+
+    print("Cleared GPU tensors and memory.")
+
+
+def run(input_folder: str, output_folder: str, config: str):
+    """
+    Run the SuperVoxel generation using SAM
+
+    :param input_folder: Path to folder containing the files to process
+    :param output_folder: Path to output folder. If not provided, the output will be saved in the same folder as the dataset.
+    """
+    if output_folder is None:
+        output_folder = os.path.join(input_folder, os.pardir, "supervoxel")
+    os.makedirs(output_folder, exist_ok=True)
+
+    # Load congiguration file
+    with open(config, "r") as file:
+        config = yaml.safe_load(file)
+
+    gen = SuperVoxelGenerator(input_folder, output_folder, config)
+
+    # List of files
+    list_of_files = [
+        f for f in os.listdir(input_folder) if f.endswith(config["file_format"]) and config["excluded_strings"] not in f
+    ]
+
+    # Shuffle the list of files
+    np.random.shuffle(list_of_files)
+    for image_name in tqdm(list_of_files):
+        out_path = os.path.join(output_folder, image_name)
+        if os.path.exists(out_path):
+            continue
+
+        image_data, metadata = gen.reader_writer.read(os.path.join(input_folder, image_name))
+
+        if len(image_data.shape) == 4:
+            image_data = image_data[0]
+            # chatch OOM error
+        try:
+            out_img = None
+            out_img = gen.sam_supervoxel(image_data)
+        except torch.OutOfMemoryError:
+            print("OOM error for image:", image_name)
+            if out_img is not None:
+                del out_img
+            if gen is not None:
+                del gen
+            gc.collect()
+            torch.cuda.empty_cache()
+            torch.cuda.ipc_collect()
+            gen = SuperVoxelGenerator(input_folder, output_folder, config)
+            continue
+
+        if os.path.exists(out_path):
+            continue
+        gen.reader_writer.write(out_img, metadata, out_path)
+
+
+def run_entrypoint():
+    parser = argparse.ArgumentParser(description="Run SuperVoxel generation using SAM")
+    parser.add_argument(
+        "-i",
+        "-input_folder",
+        type=str,
+        help="Path to folder containing the images. They can be in raw Nifit format \
+                         or using the new nnUNet supported bloscv2, depending on the file format provided in the config file.",
+    )
+    parser.add_argument(
+        "-o",
+        "-output_folder",
+        type=str,
+        help="Path to output folder. If not provided, the output will be saved in the \
+                         same parent folder as the dataset and named 'supervoxel'.",
+    )
+    parser.add_argument(
+        "-c",
+        "-config",
+        type=str,
+        help="Path to configuration file containing the parameters for the SuperVoxel generation.",
+        default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "../configs/nnUNet_preprocessed.yaml"),
+    )
+    args = parser.parse_args()
+
+    run(args.i, args.o, args.c)
+
+
+def run_save_fg_locations_entrypoint():
+    parser = argparse.ArgumentParser(description="Run generation of pkl files for nnUNet")
+    parser.add_argument(
+        "-supervoxel_folder",
+        type=str,
+        help="Path to folder containing the supervoxel masks",
+        default="/home/m574s/PhD/projects/SuperVoxel/supervoxels/",
+    )
+    parser.add_argument("-np", "-num_processes", type=int, help="Number of processes to use")
+    args = parser.parse_args()
+
+    generate_fg_locations(args.supervoxel_folder, args.np)

nnInteractive/supervoxel/src/sam2/__init__.py

@@ -0,0 +1,2 @@
+if __name__ == "__main__":
+    print("Hello world")

nnInteractive/supervoxel/src/sam2/sam2/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from hydra import initialize_config_module
+from hydra.core.global_hydra import GlobalHydra
+
+if not GlobalHydra.instance().is_initialized():
+    initialize_config_module("sam2", version_base="1.2")