From 282578ddc0037ea966c28942af13072836ce1e20 Mon Sep 17 00:00:00 2001 From: Benjamin Trom Date: Thu, 21 Sep 2023 10:19:19 +0200 Subject: [PATCH] add Segment Anything (SAM) to foundational models MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Note: dense prompts (i.e. masks) support is still partial (see MaskEncoder) Co-authored-by: Cédric Deltheil --- poetry.lock | 35 +- pyproject.toml | 5 +- .../conversion/convert_segment_anything.py | 236 +++++++++++ .../segment_anything/__init__.py | 0 .../segment_anything/image_encoder.py | 369 ++++++++++++++++++ .../segment_anything/mask_decoder.py | 264 +++++++++++++ .../foundationals/segment_anything/model.py | 166 ++++++++ .../segment_anything/prompt_encoder.py | 190 +++++++++ .../segment_anything/transformer.py | 157 ++++++++ tests/conftest.py | 5 + .../segment_anything/test_sam.py | 317 +++++++++++++++ .../segment_anything/test_sam_ref/README.md | 3 + .../segment_anything/test_sam_ref/truck.jpg | Bin 0 -> 271475 bytes tests/foundationals/segment_anything/utils.py | 107 +++++ 14 files changed, 1843 insertions(+), 11 deletions(-) create mode 100644 scripts/conversion/convert_segment_anything.py create mode 100644 src/refiners/foundationals/segment_anything/__init__.py create mode 100644 src/refiners/foundationals/segment_anything/image_encoder.py create mode 100644 src/refiners/foundationals/segment_anything/mask_decoder.py create mode 100644 src/refiners/foundationals/segment_anything/model.py create mode 100644 src/refiners/foundationals/segment_anything/prompt_encoder.py create mode 100644 src/refiners/foundationals/segment_anything/transformer.py create mode 100644 tests/foundationals/segment_anything/test_sam.py create mode 100644 tests/foundationals/segment_anything/test_sam_ref/README.md create mode 100644 tests/foundationals/segment_anything/test_sam_ref/truck.jpg create mode 100644 tests/foundationals/segment_anything/utils.py diff --git a/poetry.lock b/poetry.lock index 599aac9..6baa469 100644 --- a/poetry.lock +++ b/poetry.lock @@ -651,21 +651,19 @@ tests = ["asttokens", "littleutils", "pytest", "rich"] [[package]] name = "filelock" -version = "3.12.3" +version = "3.12.4" description = "A platform independent file lock." optional = false python-versions = ">=3.8" files = [ - {file = "filelock-3.12.3-py3-none-any.whl", hash = "sha256:f067e40ccc40f2b48395a80fcbd4728262fab54e232e090a4063ab804179efeb"}, - {file = "filelock-3.12.3.tar.gz", hash = "sha256:0ecc1dd2ec4672a10c8550a8182f1bd0c0a5088470ecd5a125e45f49472fac3d"}, + {file = "filelock-3.12.4-py3-none-any.whl", hash = "sha256:08c21d87ded6e2b9da6728c3dff51baf1dcecf973b768ef35bcbc3447edb9ad4"}, + {file = "filelock-3.12.4.tar.gz", hash = "sha256:2e6f249f1f3654291606e046b09f1fd5eac39b360664c27f5aad072012f8bcbd"}, ] -[package.dependencies] -typing-extensions = {version = ">=4.7.1", markers = "python_version < \"3.11\""} - [package.extras] docs = ["furo (>=2023.7.26)", "sphinx (>=7.1.2)", "sphinx-autodoc-typehints (>=1.24)"] testing = ["covdefaults (>=2.3)", "coverage (>=7.3)", "diff-cover (>=7.7)", "pytest (>=7.4)", "pytest-cov (>=4.1)", "pytest-mock (>=3.11.1)", "pytest-timeout (>=2.1)"] +typing = ["typing-extensions (>=4.7.1)"] [[package]] name = "frozenlist" @@ -2507,6 +2505,25 @@ dev = ["click", "cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyl doc = ["jupytext", "matplotlib (>2)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (==0.9.0)", "sphinx (!=4.1.0)", "sphinx-design (>=0.2.0)"] test = ["asv", "gmpy2", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] +[[package]] +name = "segment_anything" +version = "1.0" +description = "" +optional = true +python-versions = "*" +files = [] +develop = false + +[package.extras] +all = ["matplotlib", "onnx", "onnxruntime", "opencv-python", "pycocotools"] +dev = ["black", "flake8", "isort", "mypy"] + +[package.source] +type = "git" +url = "https://github.com/facebookresearch/segment-anything" +reference = "HEAD" +resolved_reference = "6fdee8f2727f4506cfbbe553e23b895e27956588" + [[package]] name = "sentry-sdk" version = "1.31.0" @@ -3289,11 +3306,11 @@ docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.link testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy (>=0.9.1)", "pytest-ruff"] [extras] -conversion = ["diffusers", "transformers"] -test = ["diffusers", "invisible-watermark", "piq", "transformers"] +conversion = ["diffusers", "segment-anything", "transformers"] +test = ["diffusers", "invisible-watermark", "piq", "segment-anything", "transformers"] training = ["bitsandbytes", "datasets", "loguru", "prodigyopt", "pydantic", "scipy", "tomli", "torchvision", "wandb"] [metadata] lock-version = "2.0" python-versions = ">=3.10,<3.12" -content-hash = "b2646e04015b05eba32e6556b4aa37d3c5c31218c09fd0ea53d7540af558b7de" +content-hash = "6e35f01f2fc8611203da972939170d18371182443e4c6f45b4cfc40b4e785dff" diff --git a/pyproject.toml b/pyproject.toml index 7c4e083..4c7bde5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -29,11 +29,12 @@ diffusers = {version = "^0.18.0", optional = true} transformers = {version = "^4.27.4", optional = true} piq = {version = "^0.7.1", optional = true} invisible-watermark = {version = "^0.2.0", optional = true} +segment-anything = {git = "https://github.com/facebookresearch/segment-anything", optional = true} [tool.poetry.extras] training = ["datasets", "tomli", "wandb", "loguru", "bitsandbytes", "prodigyopt", "pydantic", "scipy", "torchvision"] -conversion = ["diffusers", "transformers"] -test = ["diffusers", "transformers", "piq", "invisible-watermark"] +conversion = ["diffusers", "transformers", "segment-anything"] +test = ["diffusers", "transformers", "piq", "invisible-watermark", "segment-anything"] [tool.poetry.group.dev.dependencies] black = "^23.1.0" diff --git a/scripts/conversion/convert_segment_anything.py b/scripts/conversion/convert_segment_anything.py new file mode 100644 index 0000000..fdfd9bd --- /dev/null +++ b/scripts/conversion/convert_segment_anything.py @@ -0,0 +1,236 @@ +import argparse +import types +from typing import Any, Callable, cast +import torch +import torch.nn as nn +from torch import Tensor + +import refiners.fluxion.layers as fl +from refiners.fluxion.model_converter import ModelConverter +from refiners.fluxion.utils import manual_seed, save_to_safetensors +from refiners.foundationals.segment_anything.image_encoder import SAMViTH +from refiners.foundationals.segment_anything.prompt_encoder import PointEncoder, MaskEncoder + +from segment_anything import build_sam_vit_h # type: ignore +from segment_anything.modeling.common import LayerNorm2d # type: ignore + +from refiners.foundationals.segment_anything.mask_decoder import MaskDecoder + + +class FacebookSAM(nn.Module): + image_encoder: nn.Module + prompt_encoder: nn.Module + mask_decoder: nn.Module + + +build_sam_vit_h = cast(Callable[[], FacebookSAM], build_sam_vit_h) + + +assert issubclass(LayerNorm2d, nn.Module) +custom_layers = {LayerNorm2d: fl.LayerNorm2d} + + +class Args(argparse.Namespace): + source_path: str + output_path: str + half: bool + verbose: bool + + +def convert_mask_encoder(prompt_encoder: nn.Module) -> dict[str, Tensor]: + state_dict: dict[str, Tensor] = { + "no_mask_embedding": nn.Parameter(data=prompt_encoder.no_mask_embed.weight.clone()), # type: ignore + } + + refiners_mask_encoder = MaskEncoder() + # TODO: handle other weights + refiners_mask_encoder.load_state_dict(state_dict=state_dict, strict=False) + + return state_dict + + +def convert_point_encoder(prompt_encoder: nn.Module) -> dict[str, Tensor]: + manual_seed(seed=0) + point_embeddings: list[Tensor] = [pe.weight for pe in prompt_encoder.point_embeddings] + [prompt_encoder.not_a_point_embed.weight] # type: ignore + pe = prompt_encoder.pe_layer.positional_encoding_gaussian_matrix # type: ignore + assert isinstance(pe, Tensor) + state_dict: dict[str, Tensor] = { + "Residual.Chain.PointTypeEmbedding.weight": nn.Parameter(data=torch.cat(tensors=point_embeddings, dim=0)), + "CoordinateEncoder.Linear.weight": nn.Parameter(data=pe.T.contiguous()), + } + + refiners_prompt_encoder = PointEncoder() + refiners_prompt_encoder.load_state_dict(state_dict=state_dict) + + return state_dict + + +def convert_vit(vit: nn.Module) -> dict[str, Tensor]: + manual_seed(seed=0) + refiners_sam_vit_h = SAMViTH() + + converter = ModelConverter( + source_model=vit, + target_model=refiners_sam_vit_h, + custom_layer_mapping=custom_layers, # type: ignore + ) + converter.skip_init_check = True + + x = torch.randn(1, 3, 1024, 1024) + mapping = converter.map_state_dicts(source_args=(x,)) + assert mapping + + mapping["PositionalEncoder.Chain.Parameter.parameter"] = "pos_embed" + + target_state_dict = refiners_sam_vit_h.state_dict() + del target_state_dict["PositionalEncoder.Chain.Parameter.parameter"] + + source_state_dict = vit.state_dict() + pos_embed = source_state_dict["pos_embed"] + del source_state_dict["pos_embed"] + + target_rel_keys = [ + ( + f"Transformer.TransformerLayer_{i}.Residual_1.Chain.FusedSelfAttention.RelativePositionAttention.horizontal_embedding", + f"Transformer.TransformerLayer_{i}.Residual_1.Chain.FusedSelfAttention.RelativePositionAttention.vertical_embedding", + ) + for i in range(1, 33) + ] + source_rel_keys = [(f"blocks.{i}.attn.rel_pos_w", f"blocks.{i}.attn.rel_pos_h") for i in range(32)] + + rel_items: dict[str, Tensor] = {} + + for (key_w, key_h), (target_key_w, target_key_h) in zip(source_rel_keys, target_rel_keys): + rel_items[target_key_w] = source_state_dict[key_w] + rel_items[target_key_h] = source_state_dict[key_h] + del source_state_dict[key_w] + del source_state_dict[key_h] + del target_state_dict[target_key_w] + del target_state_dict[target_key_h] + + converted_source = converter._convert_state_dict( # pyright: ignore[reportPrivateUsage] + source_state_dict=source_state_dict, target_state_dict=target_state_dict, state_dict_mapping=mapping + ) + + converted_source["PositionalEncoder.Chain.Parameter.parameter"] = pos_embed # type: ignore + converted_source.update(rel_items) + + refiners_sam_vit_h.load_state_dict(state_dict=converted_source) + assert converter.compare_models((x,), threshold=1e-3) + + return converted_source + + +def convert_mask_decoder(mask_decoder: nn.Module) -> dict[str, Tensor]: + manual_seed(seed=0) + + refiners_mask_decoder = MaskDecoder() + + image_embedding = torch.randn(1, 256, 64, 64) + dense_positional_embedding = torch.randn(1, 256, 64, 64) + point_embedding = torch.randn(1, 3, 256) + mask_embedding = torch.randn(1, 256, 64, 64) + + import refiners.fluxion.layers as fl + from segment_anything.modeling.common import LayerNorm2d # type: ignore + + assert issubclass(LayerNorm2d, nn.Module) + custom_layers = {LayerNorm2d: fl.LayerNorm2d} + + converter = ModelConverter( + source_model=mask_decoder, + target_model=refiners_mask_decoder, + custom_layer_mapping=custom_layers, # type: ignore + ) + + inputs = { + "image_embeddings": image_embedding, + "image_pe": dense_positional_embedding, + "sparse_prompt_embeddings": point_embedding, + "dense_prompt_embeddings": mask_embedding, + "multimask_output": True, + } + + refiners_mask_decoder.set_image_embedding(image_embedding) + refiners_mask_decoder.set_point_embedding(point_embedding) + refiners_mask_decoder.set_mask_embedding(mask_embedding) + refiners_mask_decoder.set_dense_positional_embedding(dense_positional_embedding) + + mapping = converter.map_state_dicts(source_args=inputs, target_args={}) + assert mapping is not None + mapping["IOUMaskEncoder"] = "iou_token" + + state_dict = converter._convert_state_dict(source_state_dict=mask_decoder.state_dict(), target_state_dict=refiners_mask_decoder.state_dict(), state_dict_mapping=mapping) # type: ignore + state_dict["IOUMaskEncoder.weight"] = torch.cat(tensors=[mask_decoder.iou_token.weight, mask_decoder.mask_tokens.weight], dim=0) # type: ignore + + refiners_mask_decoder.load_state_dict(state_dict=state_dict) + + refiners_mask_decoder.set_image_embedding(image_embedding) + refiners_mask_decoder.set_point_embedding(point_embedding) + refiners_mask_decoder.set_mask_embedding(mask_embedding) + refiners_mask_decoder.set_dense_positional_embedding(dense_positional_embedding) + + # Perform (1) upscaling then (2) mask prediction in this order (= like in the official implementation) to make + # `compare_models` happy (MaskPrediction's Matmul runs those in the reverse order by default) + matmul = refiners_mask_decoder.ensure_find(fl.Matmul) + + def forward_swapped_order(self: Any, *args: Any) -> Any: + y = self[1](*args) # (1) + x = self[0](*args) # (2) + return torch.matmul(input=x, other=y) + + matmul.forward = types.MethodType(forward_swapped_order, matmul) + + assert converter.compare_models(source_args=inputs, target_args={}, threshold=1e-3) + + return state_dict + + +def main() -> None: + parser = argparse.ArgumentParser(description="Converts a Segment Anything ViT model to a Refiners SAMViTH model") + parser.add_argument( + "--from", + type=str, + dest="source_path", + default="sam_vit_h_4b8939.pth", + # required=True, + help="Path to the Segment Anything model weights", + ) + parser.add_argument( + "--to", + type=str, + dest="output_path", + default="segment-anything-h.safetensors", + help="Output path for converted model (as safetensors).", + ) + parser.add_argument("--half", action="store_true", default=False, help="Convert to half precision. Default: False") + parser.add_argument( + "--verbose", + action="store_true", + default=False, + help="Prints additional information during conversion. Default: False", + ) + args = parser.parse_args(namespace=Args()) + + sam_h = build_sam_vit_h() # type: ignore + sam_h.load_state_dict(state_dict=torch.load(f=args.source_path)) # type: ignore + + vit_state_dict = convert_vit(vit=sam_h.image_encoder) + mask_decoder_state_dict = convert_mask_decoder(mask_decoder=sam_h.mask_decoder) + point_encoder_state_dict = convert_point_encoder(prompt_encoder=sam_h.prompt_encoder) + mask_encoder_state_dict = convert_mask_encoder(prompt_encoder=sam_h.prompt_encoder) + + output_state_dict = { + **{".".join(("image_encoder", key)): value for key, value in vit_state_dict.items()}, + **{".".join(("mask_decoder", key)): value for key, value in mask_decoder_state_dict.items()}, + **{".".join(("point_encoder", key)): value for key, value in point_encoder_state_dict.items()}, + **{".".join(("mask_encoder", key)): value for key, value in mask_encoder_state_dict.items()}, + } + if args.half: + output_state_dict = {key: value.half() for key, value in output_state_dict.items()} + + save_to_safetensors(path=args.output_path, tensors=output_state_dict) + + +if __name__ == "__main__": + main() diff --git a/src/refiners/foundationals/segment_anything/__init__.py b/src/refiners/foundationals/segment_anything/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/refiners/foundationals/segment_anything/image_encoder.py b/src/refiners/foundationals/segment_anything/image_encoder.py new file mode 100644 index 0000000..4a4f7e7 --- /dev/null +++ b/src/refiners/foundationals/segment_anything/image_encoder.py @@ -0,0 +1,369 @@ +from torch import device as Device, dtype as DType, Tensor +from refiners.fluxion.context import Contexts +import refiners.fluxion.layers as fl +from refiners.fluxion.utils import pad +from torch import nn +import torch + + +class PatchEncoder(fl.Chain): + def __init__( + self, + in_channels: int, + out_channels: int, + patch_size: int = 16, + use_bias: bool = True, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + self.in_channels = in_channels + self.out_channels = out_channels + self.patch_size = patch_size + self.use_bias = use_bias + super().__init__( + fl.Conv2d( + in_channels=self.in_channels, + out_channels=self.out_channels, + kernel_size=(self.patch_size, self.patch_size), + stride=(self.patch_size, self.patch_size), + use_bias=self.use_bias, + device=device, + dtype=dtype, + ), + fl.Permute(0, 2, 3, 1), + ) + + +class PositionalEncoder(fl.Residual): + def __init__( + self, + embedding_dim: int, + image_embedding_size: tuple[int, int], + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + self.embedding_dim = embedding_dim + self.image_embedding_size = image_embedding_size + super().__init__( + fl.Parameter( + 1, + image_embedding_size[0], + image_embedding_size[1], + embedding_dim, + device=device, + dtype=dtype, + ), + ) + + +class RelativePositionAttention(fl.WeightedModule): + def __init__( + self, + embedding_dim: int, + num_heads: int, + spatial_size: tuple[int, int], + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + super().__init__() + self.embedding_dim = embedding_dim + self.num_heads = num_heads + self.head_dim = embedding_dim // num_heads + self.spatial_size = spatial_size + self.horizontal_embedding = nn.Parameter( + data=torch.zeros(2 * spatial_size[0] - 1, self.head_dim, device=device, dtype=dtype) + ) + self.vertical_embedding = nn.Parameter( + data=torch.zeros(2 * spatial_size[1] - 1, self.head_dim, device=device, dtype=dtype) + ) + + @property + def device(self) -> Device: + return self.horizontal_embedding.device + + @property + def dtype(self) -> DType: + return self.horizontal_embedding.dtype + + def forward(self, x: Tensor) -> Tensor: + batch, height, width, _ = x.shape + x = ( + x.reshape(batch, width * height, 3, self.num_heads, -1) + .permute(2, 0, 3, 1, 4) + .reshape(3, batch * self.num_heads, width * height, -1) + ) + query, key, value = x.unbind(dim=0) + horizontal_relative_embedding, vertical_relative_embedding = self.compute_relative_embedding(x=query) + attention = (query * self.head_dim**-0.5) @ key.transpose(dim0=-2, dim1=-1) + # Order of operations is important here + attention = ( + (attention.reshape(-1, height, width, height, width) + vertical_relative_embedding) + + horizontal_relative_embedding + ).reshape(attention.shape) + attention = attention.softmax(dim=-1) + attention = attention @ value + attention = ( + attention.reshape(batch, self.num_heads, height, width, -1) + .permute(0, 2, 3, 1, 4) + .reshape(batch, height, width, -1) + ) + return attention + + def compute_relative_coords(self, size: int) -> Tensor: + x, y = torch.meshgrid(torch.arange(end=size), torch.arange(end=size), indexing="ij") + return x - y + size - 1 + + def compute_relative_embedding(self, x: Tensor) -> tuple[Tensor, Tensor]: + width, height = self.spatial_size + horizontal_coords = self.compute_relative_coords(size=width) + vertical_coords = self.compute_relative_coords(size=height) + horizontal_positional_embedding = self.horizontal_embedding[horizontal_coords] + vertical_positional_embedding = self.vertical_embedding[vertical_coords] + x = x.reshape(x.shape[0], width, height, -1) + horizontal_relative_embedding = torch.einsum("bhwc,wkc->bhwk", x, horizontal_positional_embedding).unsqueeze( + dim=-2 + ) + vertical_relative_embedding = torch.einsum("bhwc,hkc->bhwk", x, vertical_positional_embedding).unsqueeze(dim=-1) + + return horizontal_relative_embedding, vertical_relative_embedding + + +class FusedSelfAttention(fl.Chain): + def __init__( + self, + embedding_dim: int = 768, + spatial_size: tuple[int, int] = (64, 64), + num_heads: int = 1, + use_bias: bool = True, + is_causal: bool = False, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + assert ( + embedding_dim % num_heads == 0 + ), f"Embedding dim (embedding_dim={embedding_dim}) must be divisible by num heads (num_heads={num_heads})" + self.embedding_dim = embedding_dim + self.num_heads = num_heads + self.use_bias = use_bias + self.is_causal = is_causal + super().__init__( + fl.Linear( + in_features=self.embedding_dim, + out_features=3 * self.embedding_dim, + bias=self.use_bias, + device=device, + dtype=dtype, + ), + RelativePositionAttention( + embedding_dim=self.embedding_dim, + num_heads=self.num_heads, + spatial_size=spatial_size, + device=device, + dtype=dtype, + ), + fl.Linear( + in_features=self.embedding_dim, + out_features=self.embedding_dim, + bias=True, + device=device, + dtype=dtype, + ), + ) + + +class FeedForward(fl.Chain): + def __init__( + self, + embedding_dim: int, + feedforward_dim: int, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + self.embedding_dim = embedding_dim + self.feedforward_dim = feedforward_dim + super().__init__( + fl.Linear( + in_features=self.embedding_dim, + out_features=self.feedforward_dim, + bias=True, + device=device, + dtype=dtype, + ), + fl.GeLU(), + fl.Linear( + in_features=self.feedforward_dim, + out_features=self.embedding_dim, + bias=True, + device=device, + dtype=dtype, + ), + ) + + +class WindowPartition(fl.ContextModule): + def __init__(self) -> None: + super().__init__() + + def forward(self, x: Tensor) -> Tensor: + batch, height, width, channels = x.shape + context = self.use_context(context_name="window_partition") + context.update({"original_height": height, "original_width": width}) + window_size = context["window_size"] + padding_height = (window_size - height % window_size) % window_size + padding_width = (window_size - width % window_size) % window_size + if padding_height > 0 or padding_width > 0: + x = pad(x=x, pad=(0, 0, 0, padding_width, 0, padding_height)) + padded_height, padded_width = height + padding_height, width + padding_width + context.update({"padded_height": padded_height, "padded_width": padded_width}) + x = x.view(batch, padded_height // window_size, window_size, padded_width // window_size, window_size, channels) + windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, channels) + return windows + + +class WindowMerge(fl.ContextModule): + def __init__(self) -> None: + super().__init__() + + def forward(self, x: Tensor) -> Tensor: + context = self.use_context(context_name="window_partition") + window_size = context["window_size"] + padded_height, padded_width = context["padded_height"], context["padded_width"] + original_height, original_width = context["original_height"], context["original_width"] + batch_size = x.shape[0] // (padded_height * padded_width // window_size // window_size) + x = x.view(batch_size, padded_height // window_size, padded_width // window_size, window_size, window_size, -1) + x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(batch_size, padded_height, padded_width, -1) + if padded_height > original_height or padded_width > original_width: + x = x[:, :original_height, :original_width, :].contiguous() + return x + + +class TransformerLayer(fl.Chain): + def __init__( + self, + embedding_dim: int, + num_heads: int, + feedforward_dim: int, + image_embedding_size: tuple[int, int], + window_size: int | None = None, + layer_norm_eps: float = 1e-6, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + self.embedding_dim = embedding_dim + self.num_heads = num_heads + self.feedforward_dim = feedforward_dim + self.window_size = window_size + self.layer_norm_eps = layer_norm_eps + self.image_embedding_size = image_embedding_size + attention_spatial_size = (window_size, window_size) if window_size is not None else image_embedding_size + reshape_or_merge = ( + WindowMerge() + if self.window_size is not None + else fl.Reshape(self.image_embedding_size[0], self.image_embedding_size[1], embedding_dim) + ) + super().__init__( + fl.Residual( + fl.LayerNorm(normalized_shape=embedding_dim, eps=self.layer_norm_eps, device=device, dtype=dtype), + WindowPartition() if self.window_size is not None else fl.Identity(), + FusedSelfAttention( + embedding_dim=embedding_dim, + num_heads=num_heads, + spatial_size=attention_spatial_size, + device=device, + dtype=dtype, + ), + reshape_or_merge, + ), + fl.Residual( + fl.LayerNorm(normalized_shape=embedding_dim, eps=self.layer_norm_eps, device=device, dtype=dtype), + FeedForward(embedding_dim=embedding_dim, feedforward_dim=feedforward_dim, device=device, dtype=dtype), + ), + ) + + def init_context(self) -> Contexts: + return {"window_partition": {"window_size": self.window_size}} + + +class Neck(fl.Chain): + def __init__(self, in_channels: int = 768, device: Device | str | None = None, dtype: DType | None = None) -> None: + self.in_channels = in_channels + super().__init__( + fl.Permute(0, 3, 1, 2), + fl.Conv2d( + in_channels=self.in_channels, + out_channels=256, + kernel_size=1, + use_bias=False, + device=device, + dtype=dtype, + ), + fl.LayerNorm2d(channels=256, device=device, dtype=dtype), + fl.Conv2d( + in_channels=256, + out_channels=256, + kernel_size=3, + padding=1, + use_bias=False, + device=device, + dtype=dtype, + ), + fl.LayerNorm2d(channels=256, device=device, dtype=dtype), + ) + + +class Transformer(fl.Chain): + pass + + +class SAMViT(fl.Chain): + def __init__( + self, + embedding_dim: int, + num_layers: int, + num_heads: int, + global_attention_indices: tuple[int, ...] | None = None, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + self.embedding_dim = embedding_dim + self.num_layers = num_layers + self.num_heads = num_heads + self.image_size = (1024, 1024) + self.patch_size = 16 + self.window_size = 14 + self.image_embedding_size = (self.image_size[0] // self.patch_size, self.image_size[1] // self.patch_size) + self.feed_forward_dim = 4 * self.embedding_dim + self.global_attention_indices = global_attention_indices or tuple() + super().__init__( + PatchEncoder( + in_channels=3, out_channels=embedding_dim, patch_size=self.patch_size, device=device, dtype=dtype + ), + PositionalEncoder( + embedding_dim=embedding_dim, image_embedding_size=self.image_embedding_size, device=device, dtype=dtype + ), + Transformer( + TransformerLayer( + embedding_dim=embedding_dim, + num_heads=num_heads, + feedforward_dim=self.feed_forward_dim, + window_size=self.window_size if i not in self.global_attention_indices else None, + image_embedding_size=self.image_embedding_size, + device=device, + dtype=dtype, + ) + for i in range(num_layers) + ), + Neck(in_channels=embedding_dim, device=device, dtype=dtype), + ) + + +class SAMViTH(SAMViT): + def __init__(self, device: Device | str | None = None, dtype: DType | None = None) -> None: + super().__init__( + embedding_dim=1280, + num_layers=32, + num_heads=16, + global_attention_indices=(7, 15, 23, 31), + device=device, + dtype=dtype, + ) diff --git a/src/refiners/foundationals/segment_anything/mask_decoder.py b/src/refiners/foundationals/segment_anything/mask_decoder.py new file mode 100644 index 0000000..5502bca --- /dev/null +++ b/src/refiners/foundationals/segment_anything/mask_decoder.py @@ -0,0 +1,264 @@ +import refiners.fluxion.layers as fl +from torch import device as Device, dtype as DType, Tensor, nn +import torch + +from refiners.foundationals.segment_anything.transformer import ( + SparseCrossDenseAttention, + TwoWayTranformerLayer, +) +from refiners.fluxion.context import Contexts + + +class EmbeddingsAggregator(fl.ContextModule): + def __init__(self, num_output_mask: int = 3) -> None: + super().__init__() + self.num_mask_tokens = num_output_mask + + def forward(self, iou_mask_tokens: Tensor) -> Tensor: + mask_decoder = self.ensure_parent + mask_decoder_context = mask_decoder.use_context(context_name="mask_decoder") + image_embedding = mask_decoder_context["image_embedding"] + point_embedding = mask_decoder_context["point_embedding"] + mask_embedding = mask_decoder_context["mask_embedding"] + dense_positional_embedding = mask_decoder_context["dense_positional_embedding"] + + sparse_embedding = torch.cat(tensors=(iou_mask_tokens, point_embedding), dim=1) + dense_embedding = (image_embedding + mask_embedding).flatten(start_dim=2).transpose(1, 2) + if dense_positional_embedding.shape != dense_embedding.shape: + dense_positional_embedding = dense_positional_embedding.flatten(start_dim=2).transpose(1, 2) + + mask_decoder_context.update( + { + "dense_embedding": dense_embedding, + "dense_positional_embedding": dense_positional_embedding, + "sparse_embedding": sparse_embedding, + } + ) + mask_decoder.set_context(context="mask_decoder", value=mask_decoder_context) + + return sparse_embedding + + +class Transformer(fl.Chain): + pass + + +class Hypernetworks(fl.Concatenate): + def __init__( + self, + embedding_dim: int = 256, + num_layers: int = 3, + num_mask_tokens: int = 3, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + super().__init__() + self.embedding_dim = embedding_dim + self.num_layers = num_layers + self.num_mask_tokens = num_mask_tokens + + super().__init__( + *[ + fl.Chain( + fl.Slicing(dim=1, start=i + 1, length=1), + fl.MultiLinear( + input_dim=embedding_dim, + output_dim=embedding_dim // 8, + inner_dim=embedding_dim, + num_layers=num_layers, + device=device, + dtype=dtype, + ), + ) + for i in range(num_mask_tokens + 1) + ], + dim=1, + ) + + +class DenseEmbeddingUpscaling(fl.Chain): + def __init__( + self, + embedding_dim: int = 256, + dense_embedding_side_dim: int = 64, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + super().__init__() + self.embedding_dim = embedding_dim + self.dense_embedding_side_dim = dense_embedding_side_dim + + super().__init__( + fl.UseContext(context="mask_decoder", key="dense_embedding"), + fl.Transpose(dim0=1, dim1=2), + fl.Reshape(embedding_dim, dense_embedding_side_dim, dense_embedding_side_dim), + fl.ConvTranspose2d( + in_channels=embedding_dim, + out_channels=embedding_dim // 4, + kernel_size=2, + stride=2, + device=device, + dtype=dtype, + ), + fl.LayerNorm2d(channels=embedding_dim // 4, device=device, dtype=dtype), + fl.GeLU(), + fl.ConvTranspose2d( + in_channels=embedding_dim // 4, + out_channels=embedding_dim // 8, + kernel_size=2, + stride=2, + device=device, + dtype=dtype, + ), + fl.GeLU(), + fl.Flatten(start_dim=2), + ) + + +class IOUMaskEncoder(fl.WeightedModule): + def __init__( + self, + embedding_dim: int = 256, + num_mask_tokens: int = 4, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + super().__init__() + self.embedding_dim = embedding_dim + self.num_mask_tokens = num_mask_tokens + # aka prompt tokens + output token (for IoU scores prediction) + self.weight = nn.Parameter(data=torch.randn(num_mask_tokens + 1, embedding_dim, device=device, dtype=dtype)) + + def forward(self) -> Tensor: + return self.weight.unsqueeze(dim=0) + + +class MaskPrediction(fl.Chain): + def __init__( + self, + embedding_dim: int, + num_mask_tokens: int, + num_layers: int = 3, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + self.embedding_dim = embedding_dim + self.num_mask_tokens = num_mask_tokens + self.num_layers = num_layers + super().__init__( + fl.Matmul( + input=Hypernetworks( + embedding_dim=embedding_dim, + num_layers=num_layers, + num_mask_tokens=num_mask_tokens, + device=device, + dtype=dtype, + ), + other=DenseEmbeddingUpscaling(embedding_dim=embedding_dim, device=device, dtype=dtype), + ), + fl.Slicing(dim=1, start=1, length=num_mask_tokens), + fl.Reshape(num_mask_tokens, embedding_dim, embedding_dim), + ) + + +class IOUPrediction(fl.Chain): + def __init__( + self, + embedding_dim: int, + num_layers: int, + num_mask_tokens: int, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + self.embedding_dim = embedding_dim + self.num_layers = num_layers + super().__init__( + fl.Slicing(dim=1, start=0, length=1), + fl.Squeeze(dim=0), + fl.MultiLinear( + input_dim=embedding_dim, + output_dim=num_mask_tokens + 1, + inner_dim=embedding_dim, + num_layers=num_layers, + device=device, + dtype=dtype, + ), + fl.Slicing(dim=-1, start=1, length=num_mask_tokens), + ) + + +class MaskDecoder(fl.Chain): + def __init__( + self, + embedding_dim: int = 256, + feed_forward_dim: int = 2048, + num_layers: int = 2, + num_output_mask: int = 3, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + super().__init__() + self.embedding_dim = embedding_dim + self.num_mask_tokens = num_output_mask + self.feed_forward_dim = feed_forward_dim + self.num_layers = num_layers + + super().__init__( + IOUMaskEncoder( + embedding_dim=embedding_dim, num_mask_tokens=num_output_mask + 1, device=device, dtype=dtype + ), + EmbeddingsAggregator(num_output_mask=num_output_mask), + Transformer( + *( + TwoWayTranformerLayer( + embedding_dim=embedding_dim, + num_heads=8, + feed_forward_dim=feed_forward_dim, + use_residual_self_attention=i > 0, + device=device, + dtype=dtype, + ) + for i in range(num_layers) + ), + SparseCrossDenseAttention(embedding_dim=embedding_dim, device=device, dtype=dtype), + fl.LayerNorm(normalized_shape=embedding_dim, device=device, dtype=dtype), + ), + fl.Parallel( + MaskPrediction( + embedding_dim=embedding_dim, num_mask_tokens=num_output_mask, device=device, dtype=dtype + ), + IOUPrediction( + embedding_dim=embedding_dim, + num_layers=3, + num_mask_tokens=num_output_mask, + device=device, + dtype=dtype, + ), + ), + ) + + def init_context(self) -> Contexts: + return { + "mask_decoder": { + "image_embedding": None, + "point_embedding": None, + "mask_embedding": None, + "dense_positional_embedding": None, + } + } + + def set_image_embedding(self, image_embedding: Tensor) -> None: + mask_decoder_context = self.use_context(context_name="mask_decoder") + mask_decoder_context["image_embedding"] = image_embedding + + def set_point_embedding(self, point_embedding: Tensor) -> None: + mask_decoder_context = self.use_context(context_name="mask_decoder") + mask_decoder_context["point_embedding"] = point_embedding + + def set_mask_embedding(self, mask_embedding: Tensor) -> None: + mask_decoder_context = self.use_context(context_name="mask_decoder") + mask_decoder_context["mask_embedding"] = mask_embedding + + def set_dense_positional_embedding(self, dense_positional_embedding: Tensor) -> None: + mask_decoder_context = self.use_context(context_name="mask_decoder") + mask_decoder_context["dense_positional_embedding"] = dense_positional_embedding diff --git a/src/refiners/foundationals/segment_anything/model.py b/src/refiners/foundationals/segment_anything/model.py new file mode 100644 index 0000000..1c841c2 --- /dev/null +++ b/src/refiners/foundationals/segment_anything/model.py @@ -0,0 +1,166 @@ +from dataclasses import dataclass +from typing import Sequence +from PIL import Image +from torch import device as Device, dtype as DType, Tensor +import numpy as np +import torch +import refiners.fluxion.layers as fl +from refiners.fluxion.utils import image_to_tensor, normalize, pad, interpolate +from refiners.foundationals.segment_anything.image_encoder import SAMViT, SAMViTH +from refiners.foundationals.segment_anything.mask_decoder import MaskDecoder +from refiners.foundationals.segment_anything.prompt_encoder import MaskEncoder, PointEncoder + + +@dataclass +class ImageEmbedding: + features: Tensor + original_image_size: tuple[int, int] # (height, width) + + +class SegmentAnything(fl.Module): + mask_threshold: float = 0.0 + + def __init__( + self, + image_encoder: SAMViT, + point_encoder: PointEncoder, + mask_encoder: MaskEncoder, + mask_decoder: MaskDecoder, + device: Device | str = "cpu", + dtype: DType = torch.float32, + ) -> None: + super().__init__() + self.device: Device = device if isinstance(device, Device) else Device(device=device) + self.dtype = dtype + self.image_encoder = image_encoder.to(device=self.device, dtype=self.dtype) + self.point_encoder = point_encoder.to(device=self.device, dtype=self.dtype) + self.mask_encoder = mask_encoder.to(device=self.device, dtype=self.dtype) + self.mask_decoder = mask_decoder.to(device=self.device, dtype=self.dtype) + + def compute_image_embedding(self, image: Image.Image) -> ImageEmbedding: + original_size = (image.height, image.width) + target_size = self.compute_target_size(original_size) + return ImageEmbedding( + features=self.image_encoder(self.preprocess_image(image=image, target_size=target_size)), + original_image_size=original_size, + ) + + def predict( + self, + input: Image.Image | ImageEmbedding, + foreground_points: Sequence[tuple[float, float]] | None = None, + background_points: Sequence[tuple[float, float]] | None = None, + box_points: Sequence[Sequence[tuple[float, float]]] | None = None, + masks: Sequence[Image.Image] | None = None, + binarize: bool = True, + ) -> tuple[Tensor, Tensor, Tensor]: + if isinstance(input, ImageEmbedding): + original_size = input.original_image_size + target_size = self.compute_target_size(original_size) + image_embedding = input.features + else: + original_size = (input.height, input.width) + target_size = self.compute_target_size(original_size) + image_embedding = self.image_encoder(self.preprocess_image(image=input, target_size=target_size)) + + coordinates, type_mask = self.point_encoder.points_to_tensor( + foreground_points=foreground_points, + background_points=background_points, + box_points=box_points, + ) + self.point_encoder.set_type_mask(type_mask=type_mask) + + if masks is not None: + mask_tensor = torch.stack( + tensors=[image_to_tensor(image=mask, device=self.device, dtype=self.dtype) for mask in masks] + ) + mask_embedding = self.mask_encoder(mask_tensor) + else: + mask_embedding = self.mask_encoder.get_no_mask_dense_embedding( + image_embedding_size=self.image_encoder.image_embedding_size + ) + point_embedding = self.point_encoder( + self.normalize(coordinates, target_size=target_size, original_size=original_size) + ) + dense_positional_embedding = self.point_encoder.get_dense_positional_embedding( + image_embedding_size=self.image_encoder.image_embedding_size + ) + + self.mask_decoder.set_image_embedding(image_embedding=image_embedding) + self.mask_decoder.set_mask_embedding(mask_embedding=mask_embedding) + self.mask_decoder.set_point_embedding(point_embedding=point_embedding) + self.mask_decoder.set_dense_positional_embedding(dense_positional_embedding=dense_positional_embedding) + + low_res_masks, iou_predictions = self.mask_decoder() + + high_res_masks = self.postprocess_masks( + masks=low_res_masks, target_size=target_size, original_size=original_size + ) + + if binarize: + high_res_masks = high_res_masks > self.mask_threshold + + return high_res_masks, iou_predictions, low_res_masks + + @property + def image_size(self) -> int: + w, h = self.image_encoder.image_size + assert w == h + return w + + def compute_target_size(self, size: tuple[int, int]) -> tuple[int, int]: + oldh, oldw = size + scale = self.image_size * 1.0 / max(oldh, oldw) + newh, neww = oldh * scale, oldw * scale + neww = int(neww + 0.5) + newh = int(newh + 0.5) + return (newh, neww) + + def preprocess_image(self, image: Image.Image, target_size: tuple[int, int]) -> Tensor: + h, w = target_size + padh = self.image_size - h + padw = self.image_size - w + image_tensor = torch.tensor( + np.array(image.resize((w, h), resample=Image.Resampling.BILINEAR)).astype(np.float32).transpose(2, 0, 1), + device=self.device, + dtype=self.dtype, + ).unsqueeze(0) + return pad( + normalize(image_tensor, mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375]), (0, padw, 0, padh) + ) + + def normalize(self, coordinates: Tensor, target_size: tuple[int, int], original_size: tuple[int, int]) -> Tensor: + coordinates[:, :, 0] = ((coordinates[:, :, 0] * (target_size[1] / original_size[1])) + 0.5) / self.image_size + coordinates[:, :, 1] = ((coordinates[:, :, 1] * (target_size[0] / original_size[0])) + 0.5) / self.image_size + return coordinates + + def postprocess_masks(self, masks: Tensor, target_size: tuple[int, int], original_size: tuple[int, int]) -> Tensor: + masks = interpolate(masks, factor=torch.Size((self.image_size, self.image_size)), mode="bilinear") + masks = masks[..., : target_size[0], : target_size[1]] # remove padding added at `preprocess_image` time + masks = interpolate(masks, factor=torch.Size(original_size), mode="bilinear") + return masks + + +class SegmentAnythingH(SegmentAnything): + def __init__( + self, + image_encoder: SAMViTH | None = None, + point_encoder: PointEncoder | None = None, + mask_encoder: MaskEncoder | None = None, + mask_decoder: MaskDecoder | None = None, + device: Device | str = "cpu", + dtype: DType = torch.float32, + ) -> None: + image_encoder = image_encoder or SAMViTH() + point_encoder = point_encoder or PointEncoder() + mask_encoder = mask_encoder or MaskEncoder() + mask_decoder = mask_decoder or MaskDecoder() + + super().__init__( + image_encoder=image_encoder, + point_encoder=point_encoder, + mask_encoder=mask_encoder, + mask_decoder=mask_decoder, + device=device, + dtype=dtype, + ) diff --git a/src/refiners/foundationals/segment_anything/prompt_encoder.py b/src/refiners/foundationals/segment_anything/prompt_encoder.py new file mode 100644 index 0000000..c803d46 --- /dev/null +++ b/src/refiners/foundationals/segment_anything/prompt_encoder.py @@ -0,0 +1,190 @@ +from enum import Enum, auto +from collections.abc import Sequence +from torch import device as Device, dtype as DType, Tensor, nn +import torch +from jaxtyping import Float, Int +import refiners.fluxion.layers as fl +from refiners.fluxion.context import Contexts + + +class CoordinateEncoder(fl.Chain): + def __init__( + self, + num_positional_features: int = 64, + scale: float = 1, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + self.num_positional_features = num_positional_features + self.scale = scale + + super().__init__( + fl.Multiply(scale=2, bias=-1), + fl.Linear(in_features=2, out_features=num_positional_features, bias=False, device=device, dtype=dtype), + fl.Multiply(scale=2 * torch.pi * self.scale), + fl.Concatenate(fl.Sin(), fl.Cos(), dim=-1), + ) + + +class PointType(Enum): + BACKGROUND = auto() + FOREGROUND = auto() + BOX_TOP_LEFT = auto() + BOX_BOTTOM_RIGHT = auto() + NOT_A_POINT = auto() + + +class PointTypeEmbedding(fl.WeightedModule, fl.ContextModule): + def __init__(self, embedding_dim: int, device: Device | str | None = None, dtype: DType | None = None) -> None: + super().__init__() + self.embedding_dim = embedding_dim + self.weight = nn.Parameter(data=torch.randn(len(PointType), self.embedding_dim, device=device, dtype=dtype)) + + def forward(self, type_mask: Int[Tensor, "1 num_points"]) -> Float[Tensor, "1 num_points embedding_dim"]: + assert isinstance(type_mask, Tensor), "type_mask must be a Tensor." + + embeddings = torch.zeros(*type_mask.shape, self.embedding_dim).to(device=type_mask.device) + for type_id in PointType: + mask = type_mask == type_id.value + embeddings[mask] = self.weight[type_id.value - 1] + + return embeddings + + +class PointEncoder(fl.Chain): + def __init__( + self, embedding_dim: int = 256, scale: float = 1, device: Device | str | None = None, dtype: DType | None = None + ) -> None: + assert embedding_dim % 2 == 0, "embedding_dim must be divisible by 2." + self.embedding_dim = embedding_dim + self.scale = scale + + super().__init__( + CoordinateEncoder(num_positional_features=embedding_dim // 2, scale=scale, device=device, dtype=dtype), + fl.Lambda(func=self.pad), + fl.Residual( + fl.UseContext(context="point_encoder", key="type_mask"), + PointTypeEmbedding(embedding_dim=embedding_dim, device=device, dtype=dtype), + ), + ) + + def pad(self, x: Tensor) -> Tensor: + type_mask: Tensor = self.use_context("point_encoder")["type_mask"] + if torch.any((type_mask == PointType.BOX_TOP_LEFT.value) | (type_mask == PointType.BOX_BOTTOM_RIGHT.value)): + # Some boxes have been passed: no need to pad in this case + return x + type_mask = torch.cat( + [type_mask, torch.full((type_mask.shape[0], 1), PointType.NOT_A_POINT.value, device=type_mask.device)], + dim=1, + ) + self.set_context(context="point_encoder", value={"type_mask": type_mask}) + return torch.cat([x, torch.zeros((x.shape[0], 1, x.shape[-1]), device=x.device)], dim=1) + + def init_context(self) -> Contexts: + return { + "point_encoder": { + "type_mask": None, + } + } + + def set_type_mask(self, type_mask: Int[Tensor, "1 num_points"]) -> None: + self.set_context(context="point_encoder", value={"type_mask": type_mask}) + + def get_dense_positional_embedding( + self, image_embedding_size: tuple[int, int] + ) -> Float[Tensor, "num_positional_features height width"]: + coordinate_encoder = self.ensure_find(layer_type=CoordinateEncoder) + height, width = image_embedding_size + grid = torch.ones((height, width), device=self.device, dtype=torch.float32) + y_embedding = grid.cumsum(dim=0) - 0.5 + x_embedding = grid.cumsum(dim=1) - 0.5 + y_embedding = y_embedding / height + x_embedding = x_embedding / width + positional_embedding = ( + coordinate_encoder(torch.stack(tensors=[x_embedding, y_embedding], dim=-1)) + .permute(2, 0, 1) + .unsqueeze(dim=0) + ) + return positional_embedding + + def points_to_tensor( + self, + foreground_points: Sequence[tuple[float, float]] | None = None, + background_points: Sequence[tuple[float, float]] | None = None, + not_a_points: Sequence[tuple[float, float]] | None = None, + box_points: Sequence[Sequence[tuple[float, float]]] | None = None, + ) -> tuple[Float[Tensor, "1 num_points 2"], Int[Tensor, "1 num_points"]]: + foreground_points = foreground_points or [] + background_points = background_points or [] + not_a_points = not_a_points or [] + box_points = box_points or [] + top_left_points = [box[0] for box in box_points] + bottom_right_points = [box[1] for box in box_points] + coordinates: list[Tensor] = [] + type_ids: list[Tensor] = [] + + # Must be in sync with PointType enum + for type_id, coords_seq in zip( + PointType, [background_points, foreground_points, top_left_points, bottom_right_points, not_a_points] + ): + if len(coords_seq) > 0: + coords_tensor = torch.tensor(data=list(coords_seq), dtype=torch.float, device=self.device) + coordinates.append(coords_tensor) + point_ids = torch.tensor(data=[type_id.value] * len(coords_seq), dtype=torch.int, device=self.device) + type_ids.append(point_ids) + + all_coordinates = torch.cat(tensors=coordinates, dim=0).unsqueeze(dim=0) + type_mask = torch.cat(tensors=type_ids, dim=0).unsqueeze(dim=0) + + return all_coordinates, type_mask + + +class MaskEncoder(fl.Chain): + def __init__( + self, + embedding_dim: int = 256, + intermediate_channels: int = 16, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + self.embedding_dim = embedding_dim + self.intermediate_channels = intermediate_channels + super().__init__( + fl.Conv2d( + in_channels=1, + out_channels=self.intermediate_channels // 4, + kernel_size=2, + stride=2, + device=device, + dtype=dtype, + ), + fl.LayerNorm2d(channels=self.intermediate_channels // 4, device=device, dtype=dtype), + fl.GeLU(), + fl.Conv2d( + in_channels=self.intermediate_channels // 4, + out_channels=self.intermediate_channels, + kernel_size=2, + stride=2, + device=device, + dtype=dtype, + ), + fl.LayerNorm2d(channels=self.intermediate_channels, device=device, dtype=dtype), + fl.GeLU(), + fl.Conv2d( + in_channels=self.intermediate_channels, + out_channels=self.embedding_dim, + kernel_size=1, + device=device, + dtype=dtype, + ), + ) + self.register_parameter( + "no_mask_embedding", nn.Parameter(torch.randn(1, embedding_dim, device=device, dtype=dtype)) + ) + + def get_no_mask_dense_embedding( + self, image_embedding_size: tuple[int, int], batch_size: int = 1 + ) -> Float[Tensor, "batch embedding_dim image_embedding_height image_embedding_width"]: + return self.no_mask_embedding.reshape(1, -1, 1, 1).expand( + batch_size, -1, image_embedding_size[0], image_embedding_size[1] + ) diff --git a/src/refiners/foundationals/segment_anything/transformer.py b/src/refiners/foundationals/segment_anything/transformer.py new file mode 100644 index 0000000..4c72bab --- /dev/null +++ b/src/refiners/foundationals/segment_anything/transformer.py @@ -0,0 +1,157 @@ +from torch import dtype as DType, device as Device +import refiners.fluxion.layers as fl + + +class CrossAttention(fl.Attention): + def __init__( + self, + embedding_dim: int, + cross_embedding_dim: int | None = None, + num_heads: int = 1, + inner_dim: int | None = None, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + super().__init__( + embedding_dim=embedding_dim, + key_embedding_dim=cross_embedding_dim, + num_heads=num_heads, + inner_dim=inner_dim, + is_optimized=False, + device=device, + dtype=dtype, + ) + self.cross_embedding_dim = cross_embedding_dim or embedding_dim + self.insert(index=0, module=fl.Parallel(fl.GetArg(index=0), fl.GetArg(index=1), fl.GetArg(index=1))) + + +class FeedForward(fl.Residual): + def __init__( + self, embedding_dim: int, feed_forward_dim: int, device: Device | str | None = None, dtype: DType | None = None + ) -> None: + self.embedding_dim = embedding_dim + self.feed_forward_dim = feed_forward_dim + super().__init__( + fl.Linear(in_features=embedding_dim, out_features=feed_forward_dim, device=device, dtype=dtype), + fl.ReLU(), + fl.Linear(in_features=feed_forward_dim, out_features=embedding_dim, device=device, dtype=dtype), + ) + + +class SparseSelfAttention(fl.Residual): + def __init__( + self, + embedding_dim: int, + inner_dim: int | None = None, + num_heads: int = 1, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + add_sparse_embedding = fl.Residual(fl.UseContext(context="mask_decoder", key="sparse_embedding")) + super().__init__( + fl.Parallel(add_sparse_embedding, add_sparse_embedding, fl.Identity()), + fl.Attention( + embedding_dim=embedding_dim, + inner_dim=inner_dim, + num_heads=num_heads, + is_optimized=False, + device=device, + dtype=dtype, + ), + ) + + +class SparseCrossDenseAttention(fl.Residual): + def __init__( + self, embedding_dim: int, num_heads: int = 8, device: Device | str | None = None, dtype: DType | None = None + ) -> None: + self.embedding_dim = embedding_dim + self.num_heads = num_heads + super().__init__( + fl.Parallel( + fl.Residual( + fl.UseContext(context="mask_decoder", key="sparse_embedding"), + ), + fl.Sum( + fl.UseContext(context="mask_decoder", key="dense_embedding"), + fl.UseContext(context="mask_decoder", key="dense_positional_embedding"), + ), + fl.UseContext(context="mask_decoder", key="dense_embedding"), + ), + fl.Attention( + embedding_dim=embedding_dim, + inner_dim=embedding_dim // 2, + num_heads=num_heads, + is_optimized=False, + device=device, + dtype=dtype, + ), + ) + + +class DenseCrossSparseAttention(fl.Chain): + def __init__( + self, embedding_dim: int, num_heads: int = 8, device: Device | str | None = None, dtype: DType | None = None + ) -> None: + super().__init__( + fl.Parallel( + fl.Sum( + fl.UseContext(context="mask_decoder", key="dense_embedding"), + fl.UseContext(context="mask_decoder", key="dense_positional_embedding"), + ), + fl.Residual( + fl.UseContext(context="mask_decoder", key="sparse_embedding"), + ), + fl.Identity(), + ), + fl.Attention( + embedding_dim=embedding_dim, + inner_dim=embedding_dim // 2, + num_heads=num_heads, + is_optimized=False, + device=device, + dtype=dtype, + ), + ) + + +class TwoWayTranformerLayer(fl.Chain): + def __init__( + self, + embedding_dim: int, + num_heads: int = 8, + feed_forward_dim: int = 2048, + use_residual_self_attention: bool = True, + device: Device | str | None = None, + dtype: DType | None = None, + ) -> None: + self.embedding_dim = embedding_dim + self.num_heads = num_heads + self.feed_forward_dim = feed_forward_dim + + self_attention = ( + SparseSelfAttention(embedding_dim=embedding_dim, num_heads=num_heads, device=device, dtype=dtype) + if use_residual_self_attention + else fl.SelfAttention( + embedding_dim=embedding_dim, num_heads=num_heads, is_optimized=False, device=device, dtype=dtype + ) + ) + + super().__init__( + self_attention, + fl.LayerNorm(normalized_shape=embedding_dim, device=device, dtype=dtype), + SparseCrossDenseAttention(embedding_dim=embedding_dim, num_heads=num_heads, device=device, dtype=dtype), + fl.LayerNorm(normalized_shape=embedding_dim, device=device, dtype=dtype), + FeedForward(embedding_dim=embedding_dim, feed_forward_dim=feed_forward_dim, device=device, dtype=dtype), + fl.LayerNorm(normalized_shape=embedding_dim, device=device, dtype=dtype), + fl.Passthrough( + fl.Sum( + fl.UseContext(context="mask_decoder", key="dense_embedding"), + DenseCrossSparseAttention( + embedding_dim=embedding_dim, num_heads=num_heads, device=device, dtype=dtype + ), + ), + fl.LayerNorm(normalized_shape=embedding_dim, device=device, dtype=dtype), + fl.SetContext(context="mask_decoder", key="dense_embedding"), + ), + ) diff --git a/tests/conftest.py b/tests/conftest.py index decf97f..b57459d 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -28,3 +28,8 @@ def test_e2e_path() -> Path: @fixture(scope="session") def test_textual_inversion_path() -> Path: return PARENT_PATH / "foundationals" / "clip" / "test_concepts_ref" + + +@fixture(scope="session") +def test_sam_path() -> Path: + return PARENT_PATH / "foundationals" / "segment_anything" diff --git a/tests/foundationals/segment_anything/test_sam.py b/tests/foundationals/segment_anything/test_sam.py new file mode 100644 index 0000000..b2b40bc --- /dev/null +++ b/tests/foundationals/segment_anything/test_sam.py @@ -0,0 +1,317 @@ +from math import isclose +from pathlib import Path +from typing import cast +from warnings import warn + +import pytest +import torch +import torch.nn as nn +import numpy as np + +from PIL import Image +from torch import Tensor +from refiners.fluxion import manual_seed +from refiners.fluxion.model_converter import ModelConverter + +from refiners.fluxion.utils import image_to_tensor +from refiners.foundationals.segment_anything.image_encoder import FusedSelfAttention +from refiners.foundationals.segment_anything.model import SegmentAnythingH +from refiners.foundationals.segment_anything.transformer import TwoWayTranformerLayer +from tests.foundationals.segment_anything.utils import ( + FacebookSAM, + FacebookSAMPredictor, + SAMPrompt, + intersection_over_union, +) + +# See predictor_example.ipynb official notebook (note: mask_input is not yet properly supported) +PROMPTS: list[SAMPrompt] = [ + SAMPrompt(foreground_points=((500, 375),)), + SAMPrompt(background_points=((500, 375),)), + SAMPrompt(foreground_points=((500, 375), (1125, 625))), + SAMPrompt(foreground_points=((500, 375),), background_points=((1125, 625),)), + SAMPrompt(box_points=[[(425, 600), (700, 875)]]), + SAMPrompt(box_points=[[(425, 600), (700, 875)]], background_points=((575, 750),)), +] + + +@pytest.fixture(params=PROMPTS) +def prompt(request: pytest.FixtureRequest) -> SAMPrompt: + return request.param + + +@pytest.fixture +def one_prompt() -> SAMPrompt: + return PROMPTS[0] + + +@pytest.fixture(scope="module") +def facebook_sam_h_weights(test_weights_path: Path) -> Path: + sam_h_weights = test_weights_path / "sam_vit_h_4b8939.pth" + if not sam_h_weights.is_file(): + warn(f"could not find weights at {sam_h_weights}, skipping") + pytest.skip(allow_module_level=True) + return sam_h_weights + + +@pytest.fixture(scope="module") +def sam_h_weights(test_weights_path: Path) -> Path: + sam_h_weights = test_weights_path / "segment-anything-h.safetensors" + if not sam_h_weights.is_file(): + warn(f"could not find weights at {sam_h_weights}, skipping") + pytest.skip(allow_module_level=True) + return sam_h_weights + + +@pytest.fixture(scope="module") +def facebook_sam_h(facebook_sam_h_weights: Path, test_device: torch.device) -> FacebookSAM: + from segment_anything import build_sam_vit_h # type: ignore + + sam_h = cast(FacebookSAM, build_sam_vit_h()) + sam_h.load_state_dict(state_dict=torch.load(f=facebook_sam_h_weights)) # type: ignore + return sam_h.to(device=test_device) + + +@pytest.fixture(scope="module") +def facebook_sam_h_predictor(facebook_sam_h: FacebookSAM) -> FacebookSAMPredictor: + from segment_anything import SamPredictor # type: ignore + from segment_anything.modeling import Sam # type: ignore + + predictor = SamPredictor(cast(Sam, facebook_sam_h)) + return cast(FacebookSAMPredictor, predictor) + + +@pytest.fixture(scope="module") +def sam_h(sam_h_weights: Path, test_device: torch.device) -> SegmentAnythingH: + sam_h = SegmentAnythingH(device=test_device) + # TODO: make strict=True when the MasKEncoder conversion is done + sam_h.load_from_safetensors(tensors_path=sam_h_weights, strict=False) + return sam_h + + +@pytest.fixture(scope="module") +def ref_path(test_sam_path: Path) -> Path: + return test_sam_path / "test_sam_ref" + + +@pytest.fixture +def truck(ref_path: Path) -> Image.Image: + return Image.open(ref_path / "truck.jpg").convert("RGB") + + +@torch.no_grad() +def test_fused_self_attention(facebook_sam_h: FacebookSAM) -> None: + manual_seed(seed=0) + x = torch.randn(25, 14, 14, 1280, device=facebook_sam_h.device) + + attention = cast(nn.Module, facebook_sam_h.image_encoder.blocks[0].attn) # type: ignore + + refiners_attention = FusedSelfAttention( + embedding_dim=1280, num_heads=16, spatial_size=(14, 14), device=facebook_sam_h.device + ) + refiners_attention.Linear_1.weight = attention.qkv.weight # type: ignore + refiners_attention.Linear_1.bias = attention.qkv.bias # type: ignore + refiners_attention.Linear_2.weight = attention.proj.weight # type: ignore + refiners_attention.Linear_2.bias = attention.proj.bias # type: ignore + refiners_attention.RelativePositionAttention.horizontal_embedding = attention.rel_pos_w + refiners_attention.RelativePositionAttention.vertical_embedding = attention.rel_pos_h + + y_1 = attention(x) + assert y_1.shape == x.shape + + y_2 = refiners_attention(x) + assert y_2.shape == x.shape + + assert torch.equal(input=y_1, other=y_2) + + +@torch.no_grad() +def test_image_encoder(sam_h: SegmentAnythingH, facebook_sam_h: FacebookSAM, truck: Image.Image) -> None: + image_tensor = image_to_tensor(image=truck.resize(size=(1024, 1024)), device=facebook_sam_h.device) + y_1 = facebook_sam_h.image_encoder(image_tensor) + y_2 = sam_h.image_encoder(image_tensor) + + assert torch.equal(input=y_1, other=y_2) + + +@torch.no_grad() +def test_prompt_encoder_dense_positional_embedding(facebook_sam_h: FacebookSAM, sam_h: SegmentAnythingH) -> None: + facebook_prompt_encoder = facebook_sam_h.prompt_encoder + refiners_prompt_encoder = sam_h.point_encoder + + facebook_dense_pe: Tensor = cast(Tensor, facebook_prompt_encoder.get_dense_pe()) # type: ignore + refiners_dense_pe = refiners_prompt_encoder.get_dense_positional_embedding(image_embedding_size=(64, 64)) + + assert torch.equal(input=refiners_dense_pe, other=facebook_dense_pe) + + +@torch.no_grad() +def test_prompt_encoder_no_mask_dense_embedding(facebook_sam_h: FacebookSAM, sam_h: SegmentAnythingH) -> None: + facebook_prompt_encoder = facebook_sam_h.prompt_encoder + refiners_prompt_encoder = sam_h.mask_encoder + + _, facebook_dense_pe = facebook_prompt_encoder(points=None, boxes=None, masks=None) + refiners_dense_pe = refiners_prompt_encoder.get_no_mask_dense_embedding(image_embedding_size=(64, 64)) + + assert torch.equal(input=refiners_dense_pe, other=facebook_dense_pe) + + +@torch.no_grad() +def test_point_encoder(facebook_sam_h: FacebookSAM, sam_h: SegmentAnythingH, prompt: SAMPrompt) -> None: + facebook_prompt_encoder = facebook_sam_h.prompt_encoder + refiners_prompt_encoder = sam_h.point_encoder + + facebook_sparse_pe, _ = facebook_prompt_encoder( + **prompt.facebook_prompt_encoder_kwargs(device=facebook_sam_h.device) + ) + + coordinates, type_mask = refiners_prompt_encoder.points_to_tensor(**prompt.__dict__) + # Shift to center of pixel + normalize in [0, 1] (see `_embed_points` in segment-anything official repo) + coordinates[:, :, 0] = (coordinates[:, :, 0] + 0.5) / 1024.0 + coordinates[:, :, 1] = (coordinates[:, :, 1] + 0.5) / 1024.0 + refiners_prompt_encoder.set_type_mask(type_mask=type_mask) + refiners_sparse_pe = refiners_prompt_encoder(coordinates) + + assert torch.equal(input=refiners_sparse_pe, other=facebook_sparse_pe) + + +@torch.no_grad() +def test_two_way_transformer(facebook_sam_h: FacebookSAM) -> None: + dense_embedding = torch.randn(1, 64 * 64, 256, device=facebook_sam_h.device) + dense_positional_embedding = torch.randn(1, 64 * 64, 256, device=facebook_sam_h.device) + sparse_embedding = torch.randn(1, 3, 256, device=facebook_sam_h.device) + + refiners_layer = TwoWayTranformerLayer( + embedding_dim=256, feed_forward_dim=2048, num_heads=8, device=facebook_sam_h.device + ) + facebook_layer = facebook_sam_h.mask_decoder.transformer.layers[1] # type: ignore + assert isinstance(facebook_layer, nn.Module) + + refiners_layer.set_context( + context="mask_decoder", + value={ + "dense_embedding": dense_embedding, + "dense_positional_embedding": dense_positional_embedding, + "sparse_embedding": sparse_embedding, + }, + ) + facebook_inputs = { + "queries": sparse_embedding, + "keys": dense_embedding, + "query_pe": sparse_embedding, + "key_pe": dense_positional_embedding, + } + + converter = ModelConverter( + source_model=facebook_layer, + target_model=refiners_layer, + skip_output_check=True, # done below, manually + ) + + assert converter.run(source_args=facebook_inputs, target_args=(sparse_embedding,)) + + refiners_layer.set_context( + context="mask_decoder", + value={ + "dense_embedding": dense_embedding, + "dense_positional_embedding": dense_positional_embedding, + "sparse_embedding": sparse_embedding, + }, + ) + y_1 = facebook_layer(**facebook_inputs)[0] + y_2 = refiners_layer(sparse_embedding)[0] + + assert torch.equal(input=y_1, other=y_2) + + +@torch.no_grad() +def test_mask_decoder(facebook_sam_h: FacebookSAM, sam_h: SegmentAnythingH) -> None: + manual_seed(seed=0) + facebook_mask_decoder = facebook_sam_h.mask_decoder + refiners_mask_decoder = sam_h.mask_decoder + + image_embedding = torch.randn(1, 256, 64, 64, device=facebook_sam_h.device) + dense_positional_embedding = torch.randn(1, 256, 64, 64, device=facebook_sam_h.device) + point_embedding = torch.randn(1, 3, 256, device=facebook_sam_h.device) + mask_embedding = torch.randn(1, 256, 64, 64, device=facebook_sam_h.device) + + import refiners.fluxion.layers as fl + from segment_anything.modeling.common import LayerNorm2d # type: ignore + + assert issubclass(LayerNorm2d, nn.Module) + custom_layers = {LayerNorm2d: fl.LayerNorm2d} + + converter = ModelConverter( + source_model=facebook_mask_decoder, + target_model=refiners_mask_decoder, + custom_layer_mapping=custom_layers, # type: ignore + ) + + inputs = { + "image_embeddings": image_embedding, + "image_pe": dense_positional_embedding, + "sparse_prompt_embeddings": point_embedding, + "dense_prompt_embeddings": mask_embedding, + "multimask_output": True, + } + + refiners_mask_decoder.set_image_embedding(image_embedding) + refiners_mask_decoder.set_point_embedding(point_embedding) + refiners_mask_decoder.set_mask_embedding(mask_embedding) + refiners_mask_decoder.set_dense_positional_embedding(dense_positional_embedding) + + mapping = converter.map_state_dicts(source_args=inputs, target_args={}) + assert mapping is not None + mapping["IOUMaskEncoder"] = "iou_token" + + state_dict = converter._convert_state_dict(source_state_dict=facebook_mask_decoder.state_dict(), target_state_dict=refiners_mask_decoder.state_dict(), state_dict_mapping=mapping) # type: ignore + state_dict["IOUMaskEncoder.weight"] = torch.cat([facebook_mask_decoder.iou_token.weight, facebook_mask_decoder.mask_tokens.weight], dim=0) # type: ignore + refiners_mask_decoder.load_state_dict(state_dict=state_dict) + + facebook_output = facebook_mask_decoder(**inputs) + + refiners_mask_decoder.set_image_embedding(image_embedding) + refiners_mask_decoder.set_point_embedding(point_embedding) + refiners_mask_decoder.set_mask_embedding(mask_embedding) + refiners_mask_decoder.set_dense_positional_embedding(dense_positional_embedding) + mask_prediction, iou_prediction = refiners_mask_decoder() + + facebook_masks = facebook_output[0] + facebook_prediction = facebook_output[1] + + assert torch.equal(input=mask_prediction, other=facebook_masks) + assert torch.equal(input=iou_prediction, other=facebook_prediction) + + +@torch.no_grad() +def test_predictor( + facebook_sam_h_predictor: FacebookSAMPredictor, sam_h: SegmentAnythingH, truck: Image.Image, prompt: SAMPrompt +) -> None: + predictor = facebook_sam_h_predictor + predictor.set_image(np.array(truck)) + facebook_masks, facebook_scores, _ = predictor.predict(**prompt.facebook_predict_kwargs()) # type: ignore + + assert len(facebook_masks) == 3 + + masks, scores, _ = sam_h.predict(truck, **prompt.__dict__) + masks = masks.squeeze(0) + scores = scores.squeeze(0) + + assert len(masks) == 3 + + for i in range(3): + mask_prediction = masks[i].cpu() + facebook_mask = torch.as_tensor(facebook_masks[i]) + assert isclose(intersection_over_union(mask_prediction, facebook_mask), 1.0, rel_tol=5e-05) + assert isclose(scores[i].item(), facebook_scores[i].item(), rel_tol=1e-05) + + +@torch.no_grad() +def test_predictor_image_embedding(sam_h: SegmentAnythingH, truck: Image.Image, one_prompt: SAMPrompt) -> None: + masks_ref, scores_ref, _ = sam_h.predict(truck, **one_prompt.__dict__) + + image_embedding = sam_h.compute_image_embedding(truck) + masks, scores, _ = sam_h.predict(image_embedding, **one_prompt.__dict__) + + assert torch.equal(masks, masks_ref) + assert torch.equal(scores_ref, scores) diff --git a/tests/foundationals/segment_anything/test_sam_ref/README.md b/tests/foundationals/segment_anything/test_sam_ref/README.md new file mode 100644 index 0000000..0ad3a32 --- /dev/null +++ b/tests/foundationals/segment_anything/test_sam_ref/README.md @@ -0,0 +1,3 @@ +# Note about this data + +`truck.jpg` is one of the [images](https://github.com/facebookresearch/segment-anything/tree/main/notebooks/images) used in the official [segment-anything notebooks](https://github.com/facebookresearch/segment-anything/tree/main/notebooks). diff --git a/tests/foundationals/segment_anything/test_sam_ref/truck.jpg b/tests/foundationals/segment_anything/test_sam_ref/truck.jpg new file mode 100644 index 0000000000000000000000000000000000000000..6b98688c3c84981200c06259b8d54820ebf85660 GIT binary patch literal 271475 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

D>Q;SW)@UhJx3GGk5LQWX4bTy*KLAXnrGh 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

TKdvf6^l_rsI~x16*WS^j#l#yr3T>cfSl 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%0A-;3#X>B2^;lu&{Q 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 GH~N21xIRh% literal 0 HcmV?d00001 diff --git a/tests/foundationals/segment_anything/utils.py b/tests/foundationals/segment_anything/utils.py new file mode 100644 index 0000000..37085e2 --- /dev/null +++ b/tests/foundationals/segment_anything/utils.py @@ -0,0 +1,107 @@ +from collections.abc import Sequence +from dataclasses import dataclass +from typing import Any, TypedDict + +from jaxtyping import Bool +from torch import Tensor, nn +import numpy as np +import numpy.typing as npt +import torch + +NDArrayUInt8 = npt.NDArray[np.uint8] +NDArray = npt.NDArray[Any] + + +class SAMInput(TypedDict): + image: Tensor + original_size: tuple[int, int] + point_coords: Tensor | None + point_labels: Tensor | None + boxes: Tensor | None + mask_inputs: Tensor | None + + +class SAMOutput(TypedDict): + masks: Tensor + iou_predictions: Tensor + low_res_logits: Tensor + + +class FacebookSAM(nn.Module): + image_encoder: nn.Module + prompt_encoder: nn.Module + mask_decoder: nn.Module + + def __call__(self, batched_input: list[SAMInput], multimask_output: bool) -> list[SAMOutput]: ... + + @property + def device(self) -> Any: ... + + +class FacebookSAMPredictor: + model: FacebookSAM + + def set_image(self, image: NDArrayUInt8, image_format: str = "RGB") -> None: ... + + def predict( + self, + point_coords: NDArray | None = None, + point_labels: NDArray | None = None, + box: NDArray | None = None, + mask_input: NDArray | None = None, + multimask_output: bool = True, + return_logits: bool = False, + ) -> tuple[NDArray, NDArray, NDArray]: ... + + +@dataclass +class SAMPrompt: + foreground_points: Sequence[tuple[float, float]] | None = None + background_points: Sequence[tuple[float, float]] | None = None + box_points: Sequence[Sequence[tuple[float, float]]] | None = None + # TODO: support masks + # masks: Sequence[Image.Image] | None = None + + def facebook_predict_kwargs(self) -> dict[str, NDArray]: + prompt: dict[str, NDArray] = {} + # Note: the order matters since `points_to_tensor` processes points that way (background -> foreground -> etc) + if self.background_points: + prompt["point_coords"] = np.array(self.background_points) + prompt["point_labels"] = np.array([0] * len(self.background_points)) + if self.foreground_points: + coords = np.array(self.foreground_points) + prompt["point_coords"] = ( + coords if "point_coords" not in prompt else np.concatenate((prompt["point_coords"], coords)) + ) + labels = np.array([1] * len(self.foreground_points)) + prompt["point_labels"] = ( + labels if "point_labels" not in prompt else np.concatenate((prompt["point_labels"], labels)) + ) + if self.box_points: + prompt["box"] = np.array([coord for batch in self.box_points for xy in batch for coord in xy]).reshape( + len(self.box_points), 4 + ) + return prompt + + def facebook_prompt_encoder_kwargs(self, device: torch.device | None = None): + prompt = self.facebook_predict_kwargs() + coords: Tensor | None = None + labels: Tensor | None = None + boxes: Tensor | None = None + if "point_coords" in prompt: + coords = torch.as_tensor(prompt["point_coords"], dtype=torch.float, device=device).unsqueeze(0) + if "point_labels" in prompt: + labels = torch.as_tensor(prompt["point_labels"], dtype=torch.int, device=device).unsqueeze(0) + if "box" in prompt: + boxes = torch.as_tensor(prompt["box"], dtype=torch.float, device=device).unsqueeze(0) + points = (coords, labels) if coords is not None else None + # TODO: support masks + return {"points": points, "boxes": boxes, "masks": None} + + +def intersection_over_union( + input_mask: Bool[Tensor, "height width"], other_mask: Bool[Tensor, "height width"] +) -> float: + inter = (input_mask & other_mask).sum(dtype=torch.float32).item() + union = (input_mask | other_mask).sum(dtype=torch.float32).item() + return inter / union if union > 0 else 1.0